多线程（初阶五：wait和notify）

一、概念

我们知道，多线程在系统中的调度是随机的，我们不能干预多个线程的执行顺序，但是我们可以使某个线程放弃被系统调用，让其他线程先被调用，这样，可以达到我们的预期效果；

wait就是让多线程进行锁竞争的时候，让后执行的线程，放弃和别的线程进行锁竞争，别的线程执行完后，别的线程使用notify，将wait的线程不想进行锁竞争这个信息释放掉，再次和其他线程锁竞争。等待，通知的机制（和join用途类似）

二、用法

（1）举个栗子：

现在有很多滑稽老铁要去ATM里，滑稽A是取钱的，滑稽B是存钱的，滑稽C是运钞票的人员，负责给ATM机补充钱，防止ATM机没钱了，别人取不到钱。而这里的滑稽A，滑稽B，滑稽C我们当做是线程，每次去ATM机里，只能有一个人进去，相当于上锁了，其他人不能进去，等ATM机里面的人完成操作后，出来后，别的人才能进去，但是这里是多线程的原因，其他线程会有锁竞争。    

当A进去ATM机里后，就上锁，其他人不能进去，如图：

把滑稽A比作是线程，当A线程进去后就会上锁，A线程要进行取钱的操作，其他线程不能进去操作，当A线程执行完自己的操作后，其他线程才能去锁竞争。

但是如果ATM机里面没有钱时，A线程就不能完成取钱这个操作，它会退出ATM机，但退出后呢，它因为没有完成取钱的操作，就会想继续进去ATM里面，完成取钱这个操作，就会继续和其他线程进行锁竞争，因为A线程拿到了锁，处于RUNNABLE状态，其他线程因为阻塞，处于BLOCKED状态，需要被系统唤醒后，才能去竞争锁，但是线程A呢，不用唤醒就能去竞争锁，后面又被A线程拿到锁的可能性还是很大的（类似近水楼台先得月）。如果这样子，那线程A频繁的进去又出来，干不了事，但是其他线程也不能进去操作，用通俗的话说，就是占着茅坑不拉屎的意思。也就出现线程安全问题了。其他线程，无法拿到锁，这个情况称为 “线程饿死”。

这里的线程A的代码大概逻辑是这样的：

当A线程没有取到钱，就会一直重复加锁，解锁的操作。

这样的bug没有死锁那么严重，但也是要解决的。那如何解决呢。这时，就可以用wait和notify了。期望改进成，如下图：

这里的wait内部做了三件事

（1）释放锁，给其他线程竞争锁

（2）进入阻塞等待

（3）等其他线程使用notify后，解除wait，参与到锁竞争中

（2）wait和notify的使用

wait的使用前提必须是当前对象被上锁了才能使用，不能你对象没被上锁，就wait了，那也不知道是在wait谁。同时，有线程wait了，也必须有其他线程notify来释放这个wait，不然这个wait就会一直阻塞。

1、没有上锁的wait

代码：

public class TestDemo1 {
    public static void main(String[] args) throws InterruptedException {
        Object locker = new Object();
        locker.wait();
    }
}

执行结果：

2、当一个线程被wait，但没有其他线程notify来释放这个wait

代码：

public class TestDemo3 {
    public static void main(String[] args) {
        Object locker = new Object();
        Thread t1 = new Thread(() -> {
            synchronized (locker) {
                System.out.println("wait之前");
                try {
                    locker.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("wait之后");
            }
        });
        t1.start();
    }
}

执行结果：

打印不了 “wait之后”，一直是阻塞等待状态，在jconsole中，状态如图

3、两个线程，有一个线程wait，有一个线程notify来释放wait

代码：

public class TestDemo2 {
    public static void main(String[] args) {
        Object locker = new Object();
        Thread t1 = new Thread(() -> {
            synchronized (locker) {
                System.out.println("t1 wait之前");
                try {
                    locker.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("t2 wait之后");
            }
        });
        Thread t2 = new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            synchronized (locker) {
                System.out.println("t2 notify之前");
                locker.notify();
                System.out.println("t2 notify之后");
            }
        });
        t1.start();
        t2.start();
    }
}

注意：这里的释放wait的notify，用的对象必须是要一样的，如果不一样，wait是不能被释放的，t1也就不能被唤醒了.

在系统中，notify可以不用上锁，但是在java中，规定了要上锁，而且上锁的对象也要和notify对象一样，所以和系统是有区别的。

执行结果：

结果解析：

t1 和 t2 执行的时候

（1）因为t1 sleep了1秒，所以能保证t1 先wait，所以先打印 “t1 wait之前”，这时，t1就进入阻塞等待状态。

（2）t2线程sleep了1秒后，获得这个locker锁，打印“t2 notify 之前”，当t2线程执行了notify后，t1 线程的wait就被释放了。

（3）因为t2还在持有锁，所以t1会还会进入阻塞，t2打印 “t2 notify之后” ，释放锁。

（4）t1拿到锁，再打印“t1 wait之后”。

4、notifyAll

唤醒等待这个对象的所有线程；假设有很多个线程，都使用同一个对象wait，这时，使用notifyAll，所有使用了这个对象的wait的线程，都会被唤醒。

注意：当这些线程都被唤醒时，就要重新获取锁，他们还是要进行锁竞争的，这里也就相当于串行执行了（线程调度还是随机调度的）。而且使用notifyAll后，全部使用同一对象wait的线程，都被唤醒了，不好控制，更加推荐使用notify。

（3）wait的三个选项

如图：

没有参数的就是死等，但是很多情况，死等是不合理的，所以我们加参数，就是让某个线程在一定时间wait，如果超出了这个时间，就不wait了，直接过掉wait。

有一个参数的精确范围是毫秒级别，两个参数的精确范围是纳秒级别。

三、wait、sleep、join

wait：需要搭配synchronized使用，线程wait时，处于WAITING状态，需要其他线程notify后，才能被唤醒，或者设置时间，到时就唤醒，可以兜底。

sleep：线程sleep时，要到一定休眠时间才能被唤醒，但是也能被interrupt终止，但是这种情况是会抛异常的，是非常规手段，不符合我们预期的效果。

join：啥线程调用join，当前线程就要等啥线程执行完，才能之前当前线程；和wait一样有参数可以选择，到时就不等了。