【线程间通信】sleep/wait/notify/notifyAll作用及使用

背景

在多线程开发过程中，由于线程最大的问题就是抢占式执行，随机调度, 因此线程之间执行的先后顺序难以预知。
但是实际开发中有时候我们希望合理的协调多个线程之间的执行先后顺序，让线程主动阻塞，主动放弃CPU，从而控制线程之间的执行顺序 ，去协调完成工作，怎么去控制线程之间的执行顺序，接下来我们展开介绍：

需要通过 join，sleep，wait和notify、notifyAll 这些API来实现

先来大致了解一下，这几个API的概念作用

• wait: 释放当前锁，阻塞直到被notify或notifyAll唤醒，或者超时，或者线程被中断(InterruptedException)
• notify: 任意选择一个（无法控制选哪个）正在这个对象上等待的线程把它唤醒，其它线程依然在等待被唤醒
• notifyAll: 唤醒所有线程，让它们去竞争，不过也只有一个能抢到锁
• sleep: 不是Object中的方法，而是Thread类的静态方法，让当前线程持有锁阻塞指定时间
• Join ：Join 方法是一个非常重要的同步机制，它用于控制线程的执行顺序。当一个线程调用了另一个线程的 Join 方法时，当前线程（即调用 Join 方法的线程）会暂停执行，直到被 Join 的那个线程执行完毕

本篇我们先来讲一下 wait和notify、notifyAll的使用：
wait()和notify()的工作原理
如果线程A1，A2，A3，A4都调用了obj.wait()方法，那么它们就会进入obj对象的等待队列。当obj.notify()被调用的时候，会从等待队列中随机选择一个线程并将其唤醒。而如果调用obj.notifyAll()，则会唤醒等待队列中的所有等待线程。

执行效果演示：

wait代码及演示

package com.atguigu.signcenter.thread;

/**
 *
 * wait  和join  notify  notifyAll 、sleep作用演示代码
 * @author: jd
 * @create: 2024-09-02
 */
public class ThreadDemo01 {

    public static void main(String[] args) {
        Object object = new Object();
        //这个线程负责等待
        Thread t1 = new Thread(()->{
            System.out.println("wait 之前");
            try {
                synchronized (object){
                    object.wait();
                }
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("wait 之后");
        });
        t1.start();
    }
}

说明：
在线程中调用wait，线程进入阻塞等待状态，比如在 线程t1 中调用 wait，就是让线程t1 进入阻塞等待状态（WAITING）。有有参和无参两个版本。无参版本，就是死等，直到被通知唤醒。有参版本，就是规定了一个最大的等待时间，超过时间就不等了。

当前使用的是无参的wait方法，所以会一直处于阻塞状态。 因此只会打印出来 “wait等待之前”

**特别注意：**对于使用wait方法的代码，必须包括在同步锁的内部；因为wait方法 wait 操作有3步：

• 1、先释放锁
• 2、进行阻塞等待
• 3、收到通知(notify)之后，重新尝试获取锁，并在获取锁后，继续往下执行**
  此时是释放了锁的，其他线程是可以对 锁对象 加锁的。

所以，wait 要搭配 synchronizwd 来使用，要先获取到锁，才能执行 wait 释放锁，否则就会报异常（IllegalMonitorStateException，非法的锁状态异常）。就像，你还没有女朋友，是个单身狗呢，就想分手，你要和谁分啊。

wait 结束等待的条件如下：
**- 1、如果 wait 有参数，超过时间就不等了

• 2、interrupt 触发异常唤醒 wait
• 3、其他线程调用了该对象的notify方法（这个对象就是锁对象），通知在 同一个对象上 等待的线程，此时在同一个对象上等待的线程就会**重新尝试加锁。（只能有一个线程会加锁成功）

如果不用synchronized 代码块或者是代码方法包含这个wait方法的话，会报错的，因为wait等待的时候，会释放锁，如果我们不加synchronized 的话，wait就无法释放锁了，因此会报下面的是错误

wait、notify代码及演示

和wait方法一样，notify方法是唤醒等待的线程.，因为方法notify()要先获取到锁，才能通知。因此也需要在同步方法或同步块中调用，该方法是用来通知那些可能等待该对象的对象锁的其它线程，对其发出通知notify，并使它们重新获取该对象的对象锁。

特别注意：因为这个API是通知在同一个对象上等待的线程，也就是说，此处 notify 的对象要和 wait 的对象要相同，如果通知和等待是两个不同对象，通知就不会生效，wait就不会唤醒。

Wait和notify代码：

package com.atguigu.signcenter.thread;

/**
 * @author: jd
 * @create: 2024-09-02
 */
public class ThreadDemo02 {

    public static void main(String[] args) throws InterruptedException {
        Object object = new Object();
        //此线程使用等待wait
        Thread  thread1 = new Thread(()->{
            System.out.println("wait 之前");
            try {
                synchronized (object){
                    object.wait();
                }
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("wait 之后");
        });

        // 此线程负责唤醒方法
        Thread thread2 = new Thread(()->{
            System.out.println("notify 之前");
            synchronized (object){
                object.notify();
            }
            System.out.println("notify之后");
        });
        thread1.start();
        Thread.sleep(500);
        thread2.start();
    }
}

特点：

• wait使用的对象要和notify使用的对象相同，不然notify不会有任何效果。notify 只能唤醒在同一个对象上等待的线程；
• 如果有多个线程等待，则有线程调度器随机挑选出一个呈 wait 状态的线程。(并没有 “先来后到”)
• 在notify()方法后，当前线程不会马上释放该对象锁，要等到执行notify()方法的线程将程序执行完，也就是退出同步代码块之后才会释放对象锁。

示例2：wait和notify使用

package com.atguigu.signcenter.thread;

import org.springframework.transaction.annotation.Transactional;

/**
 *
 * notify和wait的第二个例子
 *
 * 使用notify()方法唤醒线程
 *
 * 创建线程t1, 在run 内部循环调用 wait.
 *
 * 创建线程t2, 在 run 内部循环调用notify
 *
 * 注意：t1和 t2内部持有同一个 Object locker. WaitTask 和 NotifyTask 要想配合就需要搭配同一个 Object.
 *
 * @author: jd
 * @create: 2024-09-02
 */
public class ThreadDemo03 {

    //创建同一个对象,针对于这个对象来加锁解锁
    private static  final  Object objectLocker = new Object();


    public static void main(String[] args) throws InterruptedException {

        //创建一个线程，用于执行wait方法
        Thread t1 =   new Thread(()->{
            System.out.println("wait之前");
                try {
                    synchronized (objectLocker){
                    objectLocker.wait();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            System.out.println("wait之后");
        });

        //创建一个线程，用于执行notify方法
        Thread t2 =   new Thread(()->{
            System.out.println("notify之前");
                synchronized (objectLocker){
                    objectLocker.notify();
                }
            System.out.println("notify之前");
        });
        t1.start();
        Thread.sleep(500L);
        t2.start();



    }



}

总结：

wait和notify都要先获取到锁才能使用。获取到锁后，使用wait，线程会先释放锁对象，然后阻塞等待；使用notify，会通知在同一个锁对象上等待的线程，如果当前有多个线程在等待同一个锁对象，会随机唤醒一个等待的线程；而notifyAll，是所有线程都唤醒，这些线程再一起竞争锁。

随机唤醒验证：

package com.atguigu.signcenter.thread;

/**
 *
 * notifyAll()方法
 * @author: jd
 * @create: 2024-09-02
 */
public class TreadDemo05 {
    // 使用这个锁对象来负责加锁, wait, notify
    private static final Object locker = new Object();

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {

                synchronized (locker) {
                    System.out.println("t1 wait 开始");
                    try {
                        locker.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("t1 wait 结束");
                }
        });

        Thread t2 = new Thread(() -> {

                synchronized (locker) {
                    System.out.println("t2 wait 开始");
                    try {
                        locker.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("t2 wait 结束");
                }

        });

        Thread t3 = new Thread(() -> {

                synchronized (locker) {
                    System.out.println("t3 wait 开始");
                    try {
                        locker.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("t3 wait 结束");
                }

        });

        Thread t4 = new Thread(() -> {

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                synchronized (locker) {
                    System.out.println("t4 notify 开始");
                    locker.notify();
                    System.out.println("t4 notify 结束");
                }
        });
        t1.start();
        t2.start();
        t3.start();
        t4.start();

    }
}

随机唤醒-两次执行的结果：
第一次测试：

第二次测试：

notifyAll()代码及演示

把上面的locker.notify(); 换成locker.notifyAll();
验证结果：都被唤醒

至此验证结束。
ps:

1. 线程安全：在调用notifyAll()方法时，必须在同步块中使用synchronized关键字来确保线程安全性。
2. 唤醒所有等待线程：notifyAll()方法会唤醒所有等待在对象监视器上的线程，因此需要谨慎使用，以避免不必要的线程唤醒。
3. 避免过度竞争：过度使用notifyAll()可能导致线程竞争和性能问题，应该根据实际情况仅唤醒必要的线程。