【多线程初阶】wait() notify()

文章目录

协调多个线程间的执行顺序
- join 和 wait 区别
- sleep 和 wait 区别
wait()方法
- 线程饿死
- 调用 wait()
- 唤醒 wait()
notify()方法
- wait() 和 notify() 需对同一对象使用
- 确保先 wait ,后 notify
- 多个线程在同一对象上wait notify随机唤醒一个wait
notifyAll()方法
应用 wait() 和 notify()协调多个线程的执行示例

协调多个线程间的执行顺序

由于线程之间是抢占式执行的,因此线程之间执行的先后顺序难以预知.但是实际开发中有时候我们希望合理的协调多个线程之间的执行先后顺序

在这里插入图片描述

比如:球场上的每个运动员都是独立的"执行流",可以认为是一个"线程"
而完成一个具体的进攻得分动作,则需要多个运动员的相互配合,按照一定的顺序执行一定的动作,线程1 先"传球",线程2 才能"扣篮"

在这里插入图片描述
注意:wait,notify,notifyAll都是Object类的方法,也就是说任意对象的线程都可以进行协调执行顺序的操作

join 和 wait 区别

join也是等
join是等另一个线程执行完,才继续走
wait也是等
wait是等到另一个线程执行notify,才继续走(不需要另一个线程执行完)

wait 和 join 类似的是:都提供了"死等"(不带参数)的版本和 “超过时间”(带参数)的版本

sleep 和 wait 区别

在这里插入图片描述

使用要求:

wait() 必须搭配锁,先加锁,才能使用 wait,否则会抛出IllegalMonitorSteteException
若在synchronized内部调用后,当前线程会释放锁.并进入等待状态
sleep() 方法可以在任意上下文使用,不需要锁
若在synchronized内部调用后,不会释放锁,线程进入休眠状态

方法所属类不同

wait() : 属于Object类的非静态方法
sleep() : 属于Thread类的静态方法

唤醒方式

wait()需要被其他线程通过notify()或notifyAll()唤醒或是wait(long timeout)超时唤醒
sleep()在超过时间后自动唤醒或是 interrupt()提前唤醒,抛出InterruptedException异常

用途不同

wait()通常配合 notify() 和 notifyAll()实现线程间的协调工作
sleep() 用于让线程暂停一段时间,比如停下来看一下日志或者我们前面保证会出现死锁的状态也是通过sleep实现的,用来模拟延时等等

误用sleep,sleep()并不会释放锁,可能会导致其他线程无法进入同步块,造成线程饥饿或死锁
synchronized(locker){
Thread.sleep(1000);
},这样sleep抱着锁睡~~,其他线程也无法获取这个锁
sleep()若被提前唤醒或抛出InterruptedException异常,若不处理,会导致线程提前退出

wait()方法

wait做的事情:

使当前执行代码的线程进行等待(把线程放到等待队列中)
释放当前的锁
满足一定条件时被唤醒,重新尝试获取这个锁

wait要搭配 synchronized来使用,脱离synchronized使用.抛出IllegalMonitorSteteException异常

wait结束等待的条件:

其他线程调用该对象的notify方法
wait等待超过时间
其他线程调用该等待线程的interrupted方法,导致wait抛出InterruptedException异常

在这里插入图片描述

线程饿死

在这里插入图片描述
当多个线程竞争一把锁的时候,获取到锁的线程如果释放了,其他是哪个线程拿到锁?—>不确定(随机调度)

操作系统的调度是随机的,其他线程都属于在锁上阻塞等待,是阻塞状态,而当前释放锁的这个线程,是就绪状态,所以很大概率还是这个线程再次拿到锁

这样就是导致其他线程一直捞不到CPU资源去执行,线程就饿死了

调用 wait()

wait() 和 notify() 都是Object方法–>Java中的任意对象都提供了 wait() 和 notify()
当拿到锁的线程,发现要执行的任务,时机还不成熟,就是用 wait 进行阻塞等待(把线程放到等待队列中)
wait() 一被调用,就会释放当前的锁
wait的使用要搭配synchronized使用;脱离synchronized,就会抛出上述异常
上述抛出异常的本质:就是对未加锁的对象进行解锁操作

唤醒 wait()

使用其他线程该对象的notify() 唤醒wait线程,wait就会解除,重新获取到锁,继续执行并返回
要求synchronized的锁对象和wait的对象是同一个

notify()方法

notify 方法是唤醒等待的线程

notify 方法也要在同步方法或同步代码块中(就是在synchronized修饰的方法或代码块中)调用,该方法是用来通知那些等待该对象的对象锁的其他线程,对其发出通知,使他们重新获取该对象的对象锁
如果多个线程等待,则由线程调度器随机挑选一个呈 wait 状态的线程(没有"先来后到")
在notify()后,当前线程不会马上释放该对象锁,要等到执行notify()方法的线程将程序执行完,也就是退出同步代码块之后才会释放对象锁

wait() 和 notify() 需对同一对象使用

通过相同的对象调用 wait() 和 notify() ,是两个线程沟通的桥梁
wait() 和 notify() 针对同一对象才会生效,不同对象使用是没有相互的影响和作用的
wait() 操作必须搭配锁来进行,notify操作原则上不涉及加锁解锁操作,但是在Java中强制要求notify搭配synchronized使用

在这里插入图片描述

在Java中强制要求notify搭配synchronized使用,操作系统原生API中wait必须搭配锁使用,notify则不需要

确保先 wait ,后 notify

务必确保,先wait,后notify,才有作用
如果先notify,后wait,此时wait无法被唤醒,notify的这个线程虽然没有副作用(notify一个没有wait的对象,并不会报错),但是就相当于后wait的这个线程无法被唤醒了,他的notify在他没有wait之前就已经通知过他了,毫无作用

在这里插入图片描述

多个线程在同一对象上wait notify随机唤醒一个wait

如果有多个线程在同一个对象上wait,进行notify的时候是随机唤醒其中一个线程
一次notify 唤醒一个wait
多个线程在同一对象上等待,线程调度器随机挑选出一个呈wait的线程(并没有"先来后到")

public class Demo25 {
    public static void main(String[] args) {
        Object locker = new Object();
        Thread t1 = new Thread(() ->{
            try{
                System.out.println("t1 wait 之前");
                synchronized (locker){
                    locker.wait();
                }
                System.out.println("t1 wait 之后");
            }catch (InterruptedException e){
                throw new RuntimeException();
            }
        });
        Thread t2 = new Thread(() ->{
            try{
                System.out.println("t2 wait 之前");
                synchronized (locker){
                    locker.wait();
                }
                System.out.println("t2 wait 之后");
            }catch (InterruptedException e){
                throw new RuntimeException();
            }
        });
        Thread t3 = new Thread(() ->{
            Scanner scanner = new Scanner(System.in);
            System.out.println("输入任意内容,唤醒一个线程");
            scanner.next();
            synchronized (locker){
                locker.notify();
            }
        });
        t1.start();
        t2.start();
        t3.start();
    }
}

在这里插入图片描述
再加一个notify,一次notify 唤醒一个 wait

public class Demo25 {
    public static void main(String[] args) {
        Object locker = new Object();
        Thread t1 = new Thread(() ->{
            try{
                System.out.println("t1 wait 之前");
                synchronized (locker){
                    locker.wait();
                }
                System.out.println("t1 wait 之后");
            }catch (InterruptedException e){
                throw new RuntimeException();
            }
        });
        Thread t2 = new Thread(() ->{
            try{
                System.out.println("t2 wait 之前");
                synchronized (locker){
                    locker.wait();
                }
                System.out.println("t2 wait 之后");
            }catch (InterruptedException e){
                throw new RuntimeException();
            }
        });
        Thread t3 = new Thread(() ->{
            Scanner scanner = new Scanner(System.in);
            System.out.println("输入任意内容,唤醒一个线程");
            scanner.next();
            synchronized (locker){
                locker.notify();
            }
            System.out.println("输入任意内容,唤醒另一个线程");
            scanner.next();
            synchronized (locker){
                locker.notify();
            }
        });
        t1.start();
        t2.start();
        t3.start();
    }
}

在这里插入图片描述

notifyAll()方法

对于上述多个线程在同一对象上等待,我们可以考虑使用notifyAll.唤醒同一对象的所有wait的线程
虽然同时唤醒了,t1 和 t2 由于 wait 唤醒之后,要重新加锁,其中某个线程,先加上锁,开始执行,另一个线程因为加锁失败,再次阻塞等待
等到先走的线程解锁了,后走的线程才能加上锁,继续执行

总结:

因为这个原因,notifyAll()在实际开发中,虽然可以唤醒所有的wait(),但使用并不多
notifyAll()在唤醒其中一个wait状态的线程时,其他的线程依旧因为wait()尝试重新获取锁对象,而陷入阻塞等待
而且一般这些wait的线程都是干同样的工作的,唤醒谁,其实都一样~~

应用 wait() 和 notify()协调多个线程的执行示例

题目:

有三个线程,分别只能打印A ,B和C
要求按顺序打印ABC,打印10次
输出示例:
ABC
ABC
ABC…

public class Demo26 {
    public static void main(String[] args) throws InterruptedException {
        Object locker1 = new Object();
        Object locker2 = new Object();
        Object locker3 = new Object();

        Thread t1 = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    synchronized (locker1) {
                        locker1.wait();
                    }
                    System.out.print("A");
                    synchronized (locker2) {
                        locker2.notify();
                    }
                }
            } catch (InterruptedException e) {
                throw new RuntimeException();
            }
        });
        Thread t2 = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    synchronized (locker2) {
                        locker2.wait();
                    }
                    System.out.print("B");
                    synchronized (locker3) {
                        locker3.notify();
                    }
                }
            } catch (InterruptedException e) {
                throw new RuntimeException();
            }
        });
        Thread t3 = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    synchronized (locker3) {
                        locker3.wait();
                    }
                    System.out.println("C");
                    synchronized (locker1) {
                        locker1.notify();
                    }
                }
            } catch (InterruptedException e) {
                throw new RuntimeException();
            }
        });
        t1.start();
        t2.start();
        t3.start();

        // 主线程中, 先通知一次 locker1, 让上述逻辑从 t1 开始执行
        // 需要确保上述三个线程都执行到 wait, 再进行 notify
        Thread.sleep(1000);//wait 确保三个线程都wait了,再执行notify
        synchronized (locker1) {
            locker1.notify();
        }
    }
}