Java学习 第十八天
第一章 线程安全
1.1 问题概述
如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。
之前说过通过Runnable的实现类对象创建线程对象可以访问共享资源,这也是相比于继承Thread类创建多线程的一种优势,但是倘若多个线程同时修改共享资源,可能会引发安全问题。
我们通过一个案例，演示线程的安全问题：
电影院要卖票，我们模拟电影院的卖票过程。假设要播放的电影是“葫芦娃大战奥特曼”，本次电影的座位共100个(本场电影只能卖100张票)。
我们来模拟电影院的售票窗口，实现多个窗口同时卖“葫芦娃大战奥特曼”这场电影票(多个窗口一起卖这100张票)需要窗口，采用线程对象来模拟；需要票，Runnable接口子类来模拟
模拟票：
// 定义Runnable实现类
public class RunnableImpl implements Runnable{
// 定义一个线程共享的资源
private int ticket = 100;
// 重写run方法实现卖票功能
@Override
public void run(){
// 定义死循环,模拟窗口一直开启
while(true){
// 先判断票是否存在
if(ticket >= 0){
// 提高安全问题出现的概率,让程序睡眠一会儿
try{
Thread.sleep(10l);
}catch(InterrupteException e){
e.printStackTrace();
}
// 票存在，则卖票 ticket--
System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket-- + "张票");
}
}
}
}
// 定义测试类模拟三个窗口一起卖票
public class Demo01Ticket{
public static void main(String[] args){
// 创建Runnable接口的实现类对象
RunnableImpl run = new Runnable();
// 创建Thread类对象,构造方法中传入Runnable接口的实现类对象
// 定义0号窗口
Thread t0 = new Thread(run);
// 定义1号窗口
Thread t1 = new Thread(run);
// 定义2号窗口
Thread t2 = new Thread(run);
// 三个窗口同时开始卖票
t0.start();
t1.start();
t2.start();
}
}
上述代码运行之后会产生两个问题：
1.相同的票数,比如5这张票被卖了两回。
2.卖了不存在的票，比如0票与-1票，是不存在的。
1.2 线程安全问题产生原理
线程安全原因分析：
之所以会出现上面两个问题是因为三个窗口都访问了共享资源ticket,而ticket在run方法中的修改方式是ticket–(自减)。
假设t0窗口在卖票,也就是t0线程抢到了cpu资源运行到了System.out.println(Thread.currentThread().getName() + “正在卖第” + ticket-- + “张票”);语句，此时假设ticket = 1，就会输出thread-0正在卖第1张票，此时ticket还未进行自减操作。
倘若在ticket进行自减操作之前t2窗口又抢到了cpu资源，那么如果在此期间ticket一直没有完成自减操作，也就是ticket依然为1，那么就会满足if条件，就会输出thread-2正在卖第1张票，出现了重票。
倘若在t2窗口在System.out.println(Thread.currentThread().getName() + “正在卖第” + ticket-- + “张票”);语句之前一直没有自减，那么也将满足if条件，但是ticket在准备执行输出语句时又完成了自减操作，那么此时ticket = 0，就会产生thread-2正在卖第0张票的问题。
1.3 同步和异步
同步：
线程的同步就是多个线程协调处理同一资源，当一个线程在处理一个资源的时候，别人是不能干扰的，只有我处理完了，别人才能接着处理。简单来说就是有步骤、有秩序的处理一件事情！
异步：
多个人、多个线程，在处理一个事情或者一个资源的时候是没有规则或者执行的。简单来说就是，当一个线程在处理这个资源的时候，还没处理完，别人就又来处理了。
1.4 同步代码块
同步代码块： synchronized关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。
同步代码块使用格式：
synchronized(同步锁){
需要进行同步操作的代码
}
同步锁:
对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁.
注意：
1.通过代码块中的锁对象,可以使用任意的锁对象
2.但是必须保证多个线程使用的锁对象是同一个
3.锁对象作用：把同步代码块锁住,只让一个线程在同步代码块中执行
使用同步代码块修改卖票代码
// 定义Runnable实现类
public class RunnableImpl{
// 定义一个多个线程共享的票源
private int ticket = 100;
// 定义一个锁对象
Object lock = new Object();
while(true){
synchronized(lock){
if(ticket > 0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread.getName() + "--->正在卖第" + ticket + "张票");
ticket--;
}
}
}
}
1.5 同步的原理
1.6 同步方法
同步方法: 使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。
同步方法实际上就是把整个方法的代码都用锁对象给锁起来了，相当于把整个方法变成了同步代码块，因此同步方法用起来不太灵活。
既然同步方法实际上也相当于同步代码块，那么同步方法就应该有锁对象。
同步方法的锁对象有两种：
对于非静态同步方法而言，其锁对象就是调用该方法的对象this
对于静态同步方法而言，其锁对象不能是this，因为静态方法是优于对象先产生的。其实，静态同步方法的锁对象就是本类的class属性—>class文件对象(反射)
其实不难理解上面的锁对象为什么是this和本类的class属性。原因在于多个线程要想同步必须要使用同一把锁，而我们并没有定义公共的对象可以作为同步锁，因此用默认的this，这个对象就是Runnable的实现类对象本身，自然是共享的。而Runnable实现类的class属性也是相同的道理。
使用同步方法修改卖票案例
// 定义Runnable接口的实现类对象
public RunnableImpl implements Runnable{
private int ticket = 100;
@Override
public void run(){
System.out.println("this:" + this); // this:com.cqu.demo08.Synchronized.RunnableImpl@7c30a502
// 使用死循环,让其一直卖票
while(true){
payTicket();
}
}
public synchronized void payTicket(){
if(ticket > 0){
try{
Thread.sleep(10l);
}catch(InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread..getName() + "正在卖第" + i + "张票");
}
}
}
// 定义测试类
public class Demo01Ticket {
public static void main(String[] args) {
// 创建Runnable接口的实现类对象
RunnableImpl run = new RunnableImpl();
System.out.println("run:" + run); // run:com.cqu.demo08.Synchronized.RunnableImpl@7c30a502
// 创建Thread类对象,构造方法中传入Runnable接口的实现类对象
Thread t0 = new Thread(run);
Thread t1 = new Thread(run);
Thread t2 = new Thread(run);
// 调用strat方法开启多线程
t0.start();
t1.start();
t2.start();
}
}
实际上，上面代码中的同步方法payTicket和下面代码完全是等价的
public /*synchronized*/ void payTicket(){
synchronized (this){
// 先判断票是否存在
if(ticket > 0){
// 提高安全问题出现的概率,让程序睡眠
try {
Thread.sleep(10l);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 票存在,卖票 ticket--
System.out.println(Thread.currentThread().getName() + "--->正在卖第" + ticket + "张票");
ticket--;
}
}
}
静态同步方法
使用静态同步方法重写卖票案例
public class RunnableImpl implements Runnable{
private static ticket = 100;
@Override
public void run(){
while(true){
payTicketStatic();
}
}
public static synchronized void payTicketStatic(){
if(ticket > 0){
try {
Thread.sleep(10l);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 票存在,卖票 ticket--
System.out.println(Thread.currentThread().getName() + "--->正在卖第" + ticket + "张票");
ticket--;
}
}
}
// 定义测试类
public class Demo01Ticket {
public static void main(String[] args) {
// 创建Runnable接口的实现类对象
RunnableImpl run = new RunnableImpl();
System.out.println("run:" + run); // run:com.cqu.demo08.Synchronized.RunnableImpl@7c30a502
// 创建Thread类对象,构造方法中传入Runnable接口的实现类对象
Thread t0 = new Thread(run);
Thread t1 = new Thread(run);
Thread t2 = new Thread(run);
// 调用strat方法开启多线程
t0.start();
t1.start();
t2.start();
}
}
实际上，上面代码中的静态同步方法payTicketStatic和下面代码完全等价：
public static /*synchronized*/ void payTicketStatic(){
synchronized (Runnable.class){
// 先判断票是否存在
if(ticket > 0){
// 提高安全问题出现的概率,让程序睡眠
try {
Thread.sleep(10l);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 票存在,卖票 ticket--
System.out.println(Thread.currentThread().getName() + "--->正在卖第" + ticket + "张票");
ticket--;
}
}
}
1.7 Lock接口
使用synchronized关键字书写同步代码块和同步方法虽然可以实现线程同步,但是对于锁对象的获取和释放体现的不是很明显，而lock锁则很好体现了锁对象的获取和释放时间表，并且提供了比使用synchronized方法和语句可获得的更广泛的锁定操作，而且更体现了面向对象的思想。
Lock接口中的方法：
void lock(): 获取锁
void unlock(): 释放锁
java.util.concurrent.locks.ReentrantLock implements Lock接口，也就是说ReentrantLock是Lock接口的一个实现类
Lock锁的使用步骤：
1.在成员位置创建一个ReentrantLock对象
2.在可能出现安全问题的代码前调用Lock接口中的方法lock获取锁
3.在可能出现安全问题的代码后调用Lock接口中的方法unlock释放锁
注意：
锁对象必须也是线程共享的，因此最好将其写在成员位置。
使用Lock锁修改卖票代码
public class RunnableImpl implements Runnable{
// 定义一个多个线程共享的票源
private int ticket = 100;
// 1.在成员位置创建一个ReentrantLock对象
Lock l = new ReentrantLock(); // 多态创建
// 设置线程任务：买票
@Override
public void run(){
// 使用死循环,让买票操作重复执行
while(true){
// 2.在可能出现安全问题的代码前调用Lock接口中的方法lock获取锁
l.lock();
// 先判断票是否存在
if(ticket > 0){
// 提高安全问题出现的概率,让程序睡眠
try {
// 票存在,卖票 ticket--
System.out.println(Thread.currentThread().getName() + "--->正在卖第" + ticket + "张票");
ticket--;
Thread.sleep(10l);
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
// 3.在可能出现安全问题的代码后调用Lock接口中的方法unlock释放锁
l.unlock(); // 无论程序是否异常,都会把锁给释放
}
}
}
}
}
注意：
如果需要同步的代码块中可能有异常抛出，使用try…catch…处理异常，那么为了保证其他线程的正常运行，通常要将lock锁的释放写在finally代码块中，以保证一个线程无论是否出现异常都能够将锁释放。
第二章 线程状态
2.1 6种线程状态
我们不需要去研究这几种状态的实现原理，我们只需知道在做线程操作中存在这样的状态。那我们怎么去理解这几个状态呢，新建与被终止还是很容易理解的，我们就研究一下线程从Runnable（可运行）状态与非运行状态之间的转换问题。
要注意，Runnable（可运行）状态是线程可以运行的状态，并不是线程正在运行的状态，不要搞混淆。
2.2 Timed Waiting（计时等待）
TimedWaiting在API中的描述为：一个正在限时等待另一个线程执行一个（唤醒）动作的线程处于这一状态。单独的去理解这句话，真是玄之又玄，其实我们在之前的操作中已经接触过这个状态了，在哪里呢？
在我们写卖票的案例中，为了减少线程执行太快，现象不明显等问题，我们在run方法中添加了sleep语句，这样就强制当前正在执行的线程休眠（暂停执行），以“减慢线程”。
其实当我们调用了sleep方法之后，当前执行的线程就进入到“休眠状态”，其实就是所谓的TimedWaiting(计时等待)，那么我们通过一个案例加深对该状态的一个理解。
进入到TimedWaiting状态有两种方式：
- 使用sleep(long m)方法,在毫秒值结束后,线程睡醒进入到Runnable(运行)/Blocked(阻塞)状态
- 使用wait(long m)方法,wait方法在毫秒值结束后,还没有被notify唤醒,就会自动醒来,线程进入到Runnable(运行)/Blocked(阻塞)状态
实现一个计数器，计数到100，在每个数字之间暂停1秒，每隔10个数字输出一个字符串
// 使用sleep方式实现
// 定义Runnable实现类
public class RunnableImpl implements Runnable{
@Override
public void run(){
for (int i = 0; i < 100; i++) {
System.out.println(i);
if(i % 10 == 0){
try {
System.out.println("程序睡眠10秒");
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("-----------------------");
}
}
}
}
// 定义测试类
public class DemoMain {
public static void main(String[] args) {
Thread mt = new Thread(new RunnableImpl());
mt.start();
}
}
// 使用wait带参方法实现
// 定义Runnable实现类
public class RunnableImpl implements Runnable{
Object obj = new Object();
@Override
public void run(){
for (int i = 0; i < 100; i++) {
System.out.println(i);
synchronized (obj){
if(i % 10 == 0 && i != 0){
try {
obj.wait(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("-----------------------");
}
}
}
}
}
// 定义测试类
public class DemoMain {
public static void main(String[] args) {
Thread mt = new Thread(new RunnableImpl());
mt.start();
}
}
2.3 Blocked（锁阻塞状态）
locked状态在API中的介绍为：一个正在阻塞等待一个监视器锁（锁对象）的线程处于这一状态。
我们已经学完同步机制，那么这个状态是非常好理解的了。比如，线程A与线程B代码中使用同一锁，如果线程A获取到锁，线程A进入到Runnable状态，那么线程B就进入到Blocked锁阻塞状态。
这是由Runnable状态进入Blocked状态。除此Waiting以及TimeWaiting状态也会在某种情况下进入阻塞状态，而这部分内容作为扩充知识点带领大家了解一下。
Blocked线程状态图
2.4 Waiting（无限等待）
Object类当中的方法：
void wait() 在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。
void notify() 唤醒在此对象监视器上等待的单个线程。会继续执行wait方法之后的代码
Wating状态在API中介绍为：一个正在无限期等待另一个线程执行一个特别的（唤醒）动作的线程处于这一状态。
那么我们之前遇到过这种状态吗？答案是并没有，但并不妨碍我们进行一个简单深入的了解。我们通过一段代码来学习一下：
public class DemoMain {
// 创建锁对象obj
public static Object obj = new Object();
public static void main(String[] args) {
// 演示Waiting
new Thread(new Runnable(){
@Override
public void run() {
while(true){
synchronized(obj){
try {
System.out.println(Thread.currentThread().getName() + "===获取到锁对象，调用wait方法，进入Waiting状态，释放锁对象");
obj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"===从waiting状态醒来，获取到锁对象，继续执行了");
}
}
}
},"等待线程").start();
new Thread(new Runnable() {
@Override
public void run() {
while (true){
try {
System.out.println(Thread.currentThread().getName() + "---等待3秒钟");
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (obj){
System.out.println(Thread.currentThread().getName() + "---获取到锁对象，调用notify方法，释放锁对象");
obj.notify();
}
}
}
},"唤醒线程").start();
}
}
程序运行结果为
唤醒线程---等待3秒钟
等待线程===获取到锁对象，调用wait方法，进入Waiting状态，释放锁对象
唤醒线程---获取到锁对象，调用notify方法，释放锁对象
唤醒线程---等待3秒钟
等待线程===从waiting状态醒来，获取到锁对象，继续执行了
等待线程===获取到锁对象，调用wait方法，进入Waiting状态，释放锁对象
唤醒线程---获取到锁对象，调用notify方法，释放锁对象
唤醒线程---等待3秒钟
等待线程===从waiting状态醒来，获取到锁对象，继续执行了
等待线程===获取到锁对象，调用wait方法，进入Waiting状态，释放锁对象
唤醒线程---获取到锁对象，调用notify方法，释放锁对象
唤醒线程---等待3秒钟
等待线程===从waiting状态醒来，获取到锁对象，继续执行了
等待线程===获取到锁对象，调用wait方法，进入Waiting状态，释放锁对象
...
程序分析
1.“等待线程”和“唤醒线程”两个线程都调用start方法进入Runnable可运行状态
2.两个线程抢夺cpu资源选择其一进行运行。
3.根据程序运行结果来看，这里是“唤醒线程”首先抢到了cpu资源开始运行“唤醒线程”，并输出“唤醒线程---等待3秒钟”
4.“唤醒线程”执行到Thread.sleep(3000);开始进入Timed Waiting状态，释放cpu资源
5.此时“等待线程”夺取到cpu,开始运行“等待线程”，并输出“等待线程===获取到锁对象，调用wait方法，进入Waiting状态，释放锁对象”
6.“等待线程”继续运行到同步代码快，拿到锁对象obj，进入同步代码快，运行到obj.wait()
7.“等待线程”进入到Waiting无限等待状态，并立即释放锁对象obj
8.cpu此时空闲，并没有执行任意一个线程，直到“唤醒线程”睡醒(睡足来了3000毫秒)之后
9.由于"等待线程"处于无线等待状态，因此cpu资源不需要抢夺就到了“唤醒线程”手里，开始继续运行Thread.sleep(3000)之后的代码
10.发现Thread.sleep(3000)之后的是同步代码快，需要锁对象
11.“唤醒线程”抢到了"等待线程"释放的锁对象，开始运行同步代码块，并输出“唤醒线程---获取到锁对象，调用notify方法，释放锁对象”
12.“唤醒线程”运行到obj.notify()，此时唤醒了"等待线程",但是并没有立即释放锁对象obj,因此"等待线程"从Waiting无限等待状态进入到了Bolcked阻塞状态
13.“唤醒线程”运行完自己的同步代码块以后释放了锁对象
14.此时，两个线程由于又都处于Runnable可运行状态，所以再次进行cpu资源抢夺
15.根据程序运行结果来看，"唤醒线程"抢到了cpu资源，继续运行，输出"唤醒线程---等待3秒钟"
16."唤醒线程"运行到了Thread.sleep(3000)进入了Timed Waiting状态，释放了cpu资源，并且此时锁对象obj是空着的
17."等待线程"拿到cpu资源,从刚才进入Waiting状态的"obj.wait()"处继续执行代码，输出"等待线程===从waiting状态醒来，获取到锁对象，继续执行了"
...
注意：
只有锁对象才具有wait和notify方法
对于等待和唤醒的代码应当用同步代码快进行同步，以保证两个线程只能有一个运行。
2.5 卖包子案例
public class Demo01WaitAndNotify {
public static void main(String[] args) {
// 创建锁对象,保证唯一
Object obj = new Object();
// 创建一个顾客线程(消费者)
new Thread(){
@Override
public void run(){
// 一直等着买包子
while(true){
// 保证等待和唤醒的线程只能有一个执行,需要使用同步技术
synchronized (obj){
System.out.println("告知老板要的包子的种类和数量");
// 调用wait方法,放弃cpu的执行,进入到waitting状态
// 注意：父类的run方法没有抛出异常,所以这里只能try...catch不能throws抛出
try {
obj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
// 唤醒之后执行的代码
System.out.println("包子已经做好了,开吃！");
System.out.println("====================================");
}
}
}
}.start();
// 创建一个老板线程（生产者）
new Thread(){
@Override
public void run(){
// 一直做包子
while(true){
// 花5秒时间做包子
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 保证等待和唤醒的线程只有一个执行,需要使用同步技术
synchronized (obj){
System.out.println("老板5秒钟之后做好包子,告知顾客,可以吃包子了");
// 做好包子之后,调用notify方法,唤醒顾客吃包子
obj.notify();
}
}
}
}.start();
}
}
2.6 notifyAll方法
notify方法是唤醒在此同步锁上的单个线程（如果此同步锁上有多个线程，则随机唤醒一个）
notifyAll()方法是唤醒在此对象监视器上等待的所有线程。
使用notifyAlll方法修改卖包子代码
public class Demo02WaitAndNotify {
public static void main(String[] args) {
// 创建锁对象,保证唯一
Object obj = new Object();
// 创建一个顾客线程(消费者)
new Thread(){
@Override
public void run(){
// 一直等着买包子
while(true){
// 保证等待和唤醒的线程只能有一个执行,需要使用同步技术
synchronized (obj){
System.out.println("顾客1告知老板要的包子的种类和数量");
// 调用wait方法,放弃cpu的执行,进入到waitting状态
// 注意：父类的run方法没有抛出异常,所以这里只能try...catch不能throws抛出
try {
obj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
// 唤醒之后执行的代码
System.out.println("包子已经做好了,顾客1开吃！");
System.out.println("====================================");
}
}
}
}.start();
// 创建一个顾客线程(消费者)
new Thread(){
@Override
public void run(){
// 一直等着买包子
while(true){
// 保证等待和唤醒的线程只能有一个执行,需要使用同步技术
synchronized (obj){
System.out.println("顾客2告知老板要的包子的种类和数量");
// 调用wait方法,放弃cpu的执行,进入到waitting状态
// 注意：父类的run方法没有抛出异常,所以这里只能try...catch不能throws抛出
try {
obj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
// 唤醒之后执行的代码
System.out.println("包子已经做好了,顾客2开吃！");
System.out.println("====================================");
}
}
}
}.start();
// 创建一个老板线程（生产者）
new Thread(){
@Override
public void run(){
// 一直做包子
while(true){
// 花5秒时间做包子
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 保证等待和唤醒的线程只有一个执行,需要使用同步技术
synchronized (obj){
System.out.println("老板5秒钟之后做好包子,告知顾客,可以吃包子了");
// 做好包子之后,调用notify方法,唤醒顾客吃包子
// obj.notify();// 如果有多个等待线程,随机唤醒一个
obj.notifyAll(); // 唤醒所有等待的线程
}
}
}
}.start();
}
}
24万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
