wait() 、notify()、notifyAll() 的详细用法

首先，我们知道，线程的执行顺序是随机的(操作系统随机调度的，抢占式执行)，但是有时候，我们并不喜欢这种随机的执行，更喜欢的是它们能够顺序的执行，所以，Java就引入了一种机制，wait() 和 notify() ，它们的 作用就是保证线程执行的顺序；

而前面的文章中也讲过一个方法 join()，也是能影响线程的执行顺序，但是呢，这个join只能控制线程结束的顺序，而我们想要的是，线程不结束，也能按照我们自己规定的顺序去依次执行；

💐wait() 讲解

使用 wait() 时要注意一定要搭配 synchronized 使用，否则的话就会抛出异常

调用 wait() 时，wait() 会做三件事：

• 使当前的线程处于阻塞等待
• 释放当前线程获取到的锁
• 在其他线程中使用锁对象调用notify时或者使用带参数的wait(带有时间参数，超过时间就会被唤醒)被唤醒后，会再重新尝试获取锁

public class Main {
    public static void main(String[] args) {
        Object locker = new Object();
        Thread thread1 = new Thread(() -> {
            synchronized (locker) {
                System.out.println("调用wait(), 阻塞等待");
                try {
                    locker.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("thread1被唤醒");
            }
        });
        thread1.start();
    }
}

可以看到，当执行到 wait() 这行代码时，就一直处于了阻塞等待，需要在其他线程中使用 notify() 来唤醒，而目前代码中没有其他线程，所以就一直等待；这里也需要解释一下，关于调用 wait() 方法，因为 wait() 方法是Object类中的方法，所以，所有的对象都可以调用;

💐notify() 讲解

notify 作用：唤 醒其它调用了 wait() 导致阻塞等待的线程；

1. wati() 和 notify() 都要在加锁的代码块中使用，并且由锁对象调用

2. 使用 notify() 唤醒某个线程时，只能唤醒和调用 notify() 是同一个锁的线程

比如：thread1 线程中使用 锁对象 locker1 调用了 wait() 方法阻塞等待，那么在其他线程中，也要使用 locker1 来调用 notify() 方法对 thread1 进行唤醒

 public static void main(String[] args) throws InterruptedException {
        Object locker = new Object();
        Thread thread1 = new Thread(() -> {
            synchronized (locker) {
                System.out.println("thread1执行，调用wait，进行阻塞,同时锁被释放");
                try {
                    locker.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("thread1执行完");
            }
        });

        Thread thread2 = new Thread(() -> {
            //先进行一个睡眠，可以明显的观察效果
            try {
                Thread.sleep(100);//让thread1先执行
                System.out.println("thread2执行，进入睡眠四秒");
                Thread.sleep(4000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            synchronized (locker) {
                System.out.println("四秒后");
                System.out.println("进行唤醒");
                locker.notify();
            }
        });
        thread1.start();
        thread2.start();
   
 }

所以，wait() 结束的条件是：

1. 其他的线程调用 notify() 方法
2. 使用带有时间参数的 wait() 方法，等到时间到了以后，就自动结束等待
3. 其他的线程调用该等待线程的 interrupted 方法，进行线程阻断，导致 wait() 抛出 InterruptedException 异常

wait() 、notify() 也可以避免“线程饿死”

举个例子：

💐notifyAll()

如果多个线程都调用 wait() 的话，多个线程都会进入阻塞，调用 notify() 的话，就只能唤醒一个，但是用 notifyAll() 的话，就可以一次性全部唤醒(唤醒的是等待 同一个锁的所有线程)，这里要注意一点：多个线程被同时唤醒时，只有一个线程可以成功的获取到锁，其他的线程进行继续等待。

场景：有四个线程，thread1，thread2，thread3 调用 wait() 进行阻塞等待，thread4 调用 notify()，最终，三个阻塞的线程只会有一个被唤醒，代码如下：

public class Main {
    public static void main(String[] args) {
        Object locker = new Object();
        Thread thread1 = new Thread(() -> {
            synchronized (locker) {
                System.out.println("thread1调用wait(), 阻塞等待");
                try {
                    locker.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("thread1被唤醒");
            }
        });
        Thread thread2 = new Thread(() -> {
            synchronized (locker) {
                System.out.println("thread2调用wait(), 阻塞等待");
                try {
                    locker.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("thread2被唤醒");
            }
        });
        Thread thread3 = new Thread(() -> {
            synchronized (locker) {
                System.out.println("thread3调用wait(), 阻塞等待");
                try {
                    locker.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("thread3被唤醒");
            }
        });

        Thread thread4 = new Thread(() -> {
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            synchronized (locker) {
                locker.notify();
                System.out.println("thread4调用notify()");
            }
        });

        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
    }
}

执行结果：

如果将 notify() 换成 调用 notifyAll()，那么就会全部被唤醒，代码如下：

        Thread thread4 = new Thread(() -> {
            try {
                Thread.sleep(3);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            synchronized (locker) {
                locker.notifyAll();
                System.out.println("thread4调用notifyAll()");
            }
        }

通过结果可以看到，当 thread4 调用了 notifyAll() 后， thread3 先获取到了锁，然后释放锁后，thread2 又获取到了锁，最后是 thread1

💡wait() 和 sleep() 的区别

• 类不同：sleep() 是Thread线程类的静态方法， wait() 是 Object类的方法
• 调用后是否释放锁： sleep() 调用后不会有释放锁的操作； wait() 调用后会释放锁
• 用途不同： wait() 通常用于线程间交互/通信， sleep() 通常用于暂停执行
• 用法不同：wait() 方法被调用后，线程不会自动苏醒，需要别的线程调用 notify() 方法， 或者 notifyAll() 方法 或者是使用wait(long timeout),指定一个阻塞时间，超时后线程自动苏醒。sleep() 方法执行完后，线程会自动苏醒。