2023.10.17 关于 wait 和 notify 的使用

news2025/3/13 10:21:16

引言

方法的使用

引入实例（wait 不带参数版本）

wait 方法执行流程

wait 和 notify 组合实例

wait 带参数版本

notify 和 notifyAll 的区别

经典例题

总结

引言

线程最大的问题是抢占式执行，随机调度
虽然线程在内核里的调度是随机的，但是可以通过一些api 来控制线程之间的执行顺序，让线程主动阻塞，主动放弃CPU，以便让给其他线程使用

简单示例

有线程t1 和线程t2，希望线程t1 先干活，等到干的差不多了，再让线程t2 来干活
此时就可以让线程t2 先 wait（阻塞，主动放弃CPU），等线程t1 干的差不多了，再通过 notify 通知线程t2，把线程t2 唤醒，让线程t2 接着干

注意：

join 或 sleep 与 wait 和 notify 之间使用的区别

使用 join ，则表示线程t1 必须要彻底执行完，线程t2 才能运行，如果希望线程t1 先干一半活，再让线程t2 接着干，此时 join 就不能满足需求
使用 sleep 来指定一个休眠时间，同理我们难以知道线程t1 干一半活所需的具体时间，所以难以满足我们的需求
可以认为 wait 和 notify 涵盖了 join 的用途，但是 wait 和 notify 的使用要比 join 麻烦很多，可以根据实际使用场景来自行选择

方法的使用

引入实例（wait 不带参数版本）
public class ThreadDemo16 {
    public static void main(String[] args) throws InterruptedException {
        Object object = new Object();
//        wait 不加任何参数，就是死等，一直等待，直到有其他线程唤醒它
        object.wait();
    }
}
执行结果：

该异常为非法的锁状态异常
锁状态就两种一种是加锁状态，一直是解锁状态
关于为啥会出现异常，我们还需了解 wait 方法的执行流程

wait 方法执行流程

先释放锁
进行阻塞等待
收到通知之后，重新尝试获取锁，并且在获取锁后，继续往下执行

修改实例
public class ThreadDemo16 {
    public static void main(String[] args) throws InterruptedException {
        Object object = new Object();
//        wait 不加任何参数，就是死等，一直等待，直到有其他线程唤醒它
        synchronized (object) {
            System.out.println("wait 之前");
            object.wait();
            System.out.println("wait 之后");
        }
    }
}
运行结果：

相较于 object 未加锁就调用 wait 方法，而出现锁状态异常的报错
这里先给 object 加上锁，再调用 wait 方法，就能很好的进行阻塞等待，并处于 WAITING 状态
此处阻塞释放掉了对象 object 的锁，从而其他线程便可以获取对象 object 的锁

wait 和 notify 组合实例
package Thread;

public class ThreadDemo17 {
    public static void main(String[] args) throws InterruptedException {
        Object object = new Object();
        Thread t1 = new Thread(() -> {
//            这个线程负责进行等待
            System.out.println("t1: wait 之前");

            synchronized (object) {
                try {
                    object.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("t1: wait 之后");
        });

        Thread t2 = new Thread(() -> {
//            这个线程负责唤醒
            System.out.println("t2: notify 之前");
            synchronized (object) {
//                notify 务必要获取到锁，才能进行通知
                object.notify();
            }
            System.out.println("t2: notify 之后");
        });

        t1.start();
//        这里添加 sleep 等待1秒
//        是为了能够尽量保证先执行线程t1 再执行线程t2
        Thread.sleep(1000);
        t2.start();
    }
}
运行结果：

注意：

此处的 notify 需和 wait 进行配对
如果 wait 使用的对象和 notify 使用的对象不一致
此时 notify 将不会有任何效果
因为 notify 只能唤醒在同一个对象上等待的线程

虽然这里的代码顺序是先执行线程t1 再执行线程t2
但是由于线程调度的随机性，并不能完全保证一定是先执行线程t1 再执行线程t2
如果调用 notify 时没有线程在 wait，此时的 wait 是无法被唤醒的，那么这种通知就是无效通知，但不会有啥副作用
所以在执行线程t1 之后，先 sleep 等待1秒，再执行线程t2，能很大程度的保证线程t1 先执行 wait 方法

wait 带参数版本

上述代码的 wait 为无参数版本，意味着只要线程t2 不进行 notify，此时线程t1 就会始终 wait 下去，也就是死等
所以 wait 带参数版本便能指定一个等待的最大时间，能很好的避免死等情况的出现

注意：

虽然 wait 带参数版本，看起来跟 sleep 有点像
都能指定等待时间
都能被提前唤醒，wait 使用 notify ，sleep 使用 interrupt
但是还是有本质差别的，其含义截然不同
notify 唤醒 wait，是正常的业务逻辑，并不会有任何异常
interrupt 唤醒 sleep 则会先触发中断异常，表示这是一个出了问题的逻辑

notify 和 notifyAll 的区别

当有多个线程等待 object 对象时
有一个线程执行 notify 方法，那么将会随机唤醒一个等待的线程
有一个线程执行 notifyAll 方法，那么将唤醒全部等待的线程，然后这些线程再一起竞争锁

经典例题

有三个线程，分别只能打印 A、B、C ，控制三个线程固定按照 ABC 的顺序来打印

具体思路

我们可以创建两个对象 object1 和 object2
object1 用来控制线程t1和线程t2 的执行顺序
object2 用来控制线程t2和线程t3 的执行顺序
让线程t3 wait 阻塞等待对象 object2，直到线程t2 执行 notify
让线程t2 wait 阻塞等待对象 object1，直到线程t1 执行 notify
这样便能很好的保证先执行线程t1 ，再执行线程t2，最后再执行线程t3
public class ThreadDemo18 {
    public static void main(String[] args) throws InterruptedException {
        Object object1 = new Object();
        Object object2 = new Object();

        Thread t1 = new Thread(() -> {
            System.out.println("A");
            synchronized (object1) {
                object1.notify();
            }
        });

        Thread t2 = new Thread(() -> {
            synchronized (object1) {
                try {
                    object1.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("B");
            synchronized (object2) {
                object2.notify();
            }
        });

        Thread t3 = new Thread(() -> {
            synchronized (object2) {
                try {
                    object2.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("C");
        });

        t2.start();
        t3.start();
        Thread.sleep(500);
        t1.start();
    }
}
运行结果：

注意：

之所以这样安排线程的执行顺序并在执行线程t1 前先等待 0.5秒
是因为能很大程度上避免线程t1 执行 notify 之后，线程t2 还未执行 wait 方法阻塞等待对象 object1
从而导致线程t1 notify 了个寂寞，便会导致线程t2 一直阻塞等待，出现死锁的情况