多线程之wait&notify

目录：

前言

1.wait()方法

2 notify()方法

3.wait & notify的代码示例：

4.关于notifyAll()方法

前言

线程最大的问题就是抢占式执行，随机调度。虽然线程在操作系统内核里的调度是随机的，但是可以通过一些办法来控制线程之间的执行顺序，让一些线程主动阻塞，主动放弃CPU。

示例：

现在有t1 和t2两个线程,希望t1线程先进行工作，然后工作一段时间后，再让t2线程再来工作。就可以让t2线程先进行wait(阻塞,主动放弃cpu)，等t1线程工作一段时间后，再通过notify通知t2线程，把 t2线程唤醒，让 t2线程接着工作。

在上述场景,使用join 或者sleep可不可以呢？

使用join，则必须要t1线程彻底执行完,，t2线程才能运行。如果是希望t1线程先做50%的工作，就让t2线程开始执行，使用join是办不到的，因为join要等到一个线程彻底执行完毕。使用sleep，指定一个休眠时间的，但是t1线程执行的这些工作，到底用了多少时间是不确定的。那么是可以使用wait和notify来解决的。其中，wait 需要搭配 synchronized 使用，sleep 不需要；wait 是 Object 的方法，sleep 是 Thread 的静态方法。

1.wait()方法

wait要搭配 synchronized 来使用，脱离 synchronized 使用 wait 会直接抛出异常。

wait的操作：

释放当前的锁

使当前执行代码的线程进行阻塞等待

收到通知时被唤醒，重新尝试获取这个锁，在获取锁之后继续往下执行。

wait 结束等待的条件:

其他线程调用该对象的 notify 方法

wait 等待时间超时 (wait 方法提供一个带有 timeout 参数的版本，来指定等待时间)

其他线程调用该等待线程的 interrupted 方法, 导致 wait 抛出 InterruptedException 异常

2 notify()方法

notify的操作:（唤醒等待的线程）

notify()方法是用来通知同一个对象上等待的线程，对其发出通知notify，并使它们重新获取该对象的对象锁。

如果有多个线程等待，则有线程调度器随机挑选出一个呈 wait 状态的线程。

3.wait & notify的代码示例：

代码示例1：

public class ThreadDemo16 {
    public static void main(String[] args) throws InterruptedException {
        Object object = new Object();
        Thread t1 = new Thread(()->{
            System.out.println("t1线程等待之前");
            try {
                synchronized (object){
                    object.wait();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("t1线程被唤醒");
        });

        Thread t2 = new Thread(()->{
            System.out.println("t2线程notify之前");
            synchronized (object){
                object.notify();
            }
            System.out.println("t2线程notify之后");
        });

        t1.start();
        Thread.sleep(1000);//这个保证t1线程一定要先进行阻塞等待，t2才能进行唤醒
        t2.start();
    }
}

代码示例2：三个线程顺序打印ABC

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

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

        Thread t2 = new Thread(()->{
            try {
                synchronized (locker1){
                    locker1.wait();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("B");

            synchronized (locker2){
                locker2.notify();
            }
        });

        Thread t3 = new Thread(()->{
            try {
                synchronized (locker2){
                    locker2.wait();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("C");
        });
        t2.start();
        t3.start();
        Thread.sleep(1000);//保证t2和t3先执行了，先进行等待
        t1.start();
    }
}