Java EE之wait和notify

一.多线程的执行顺序

由于多个线程执行是抢占式执行，就会导致顺序不同，同时就会导致出现问题，就比如俩个线程同时对同一个变量进行修改，我们难以预知执行顺序。

但在实际开发中，我们希望代码按一定的逻辑顺序执行，希望可以协调多个线程的执行顺序。

之前提到过join，会让调用它的线程进入阻塞等待，但有个缺陷就是，它必须得等那个线程完全执行完才能继续执行。怎么才能随意调度？

可以用到wait和notify方法

二.wait和notify

1.wait和notify可以协调多个线程的执行顺序

wait可以让指定线程进入阻塞等待状态，notify可以唤醒正在wait的线程

2.wait和notify是依赖对象的

wait和notify都是Object类里面的成员方法，它们的调用是依赖对象的

3.wait所做的工作

在了解wait所做的工作之前，我们先看一个wait和notify使用的实例：

我们发现唤醒wait之后，没有进行打印操作，而是抛出了异常，这个异常叫做：IllegalMonitorStatementException非法的监视器状态异常，什么是监视器？其实这里说的是synchronized锁，它也叫做监视器锁。这里我们就可以来了解一下wait所作的工作：

1.释放当前所持有的锁

2.让线程进入阻塞状态，并等待被唤醒。

3.当线程被唤醒时，重新获取到锁

所以说，使用wait的前提是得加锁，同时notify也得加锁，对谁加锁？就是对调用wait和notify的哪个对象进行加锁。

为什么要这样加锁呢？首先对线程1进行加锁，当它不想做任何事情时，就进入阻塞状态，此时它啥也不干，就没必要拿着锁，就释放了，让急需锁的线程2先用，当线程2的任务完成的差不多时，他就可以把锁还给线程1了。所以代码修改如下：

4.notify

唤醒正在等待的线程。当有多个线程都在等待时（前提是这几个等待的线程都在等待同一把锁），notify唤醒时是随即唤醒其中的一个线程而其他线程还在等待。并且，如果notify后面还有代码（在synronized里面），就会先执行完这些代码，再唤醒wait的线程如下例子：

public class Test2 {
    private static Object object=new Object();
    public static void main(String[] args) {
        Thread t1=new Thread(()->{
            synchronized(object) {
                System.out.println("t1kaishi");
                try {
                    object.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("t1jieshu");
            }
        });
        Thread t2=new Thread(()->{
            synchronized (object){
                System.out.println("t2kaishi");
                try {
                    object.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("t2jieshu");
            }
        });
        Thread t3=new Thread(()->{
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (object){
                try {
                    object.notify();
                    Thread.sleep(1000);
                    System.out.println("t3jieshu");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t1.start();
        t2.start();
        t3.start();
    }
}

首先，t1t2是等待线程，t3是通知线程。t1开始，先得到了锁，然后wait时释放了锁，这时t2拿到了锁，然后wait时释放了锁；之后等1秒过后，t3拿到了锁，然后唤醒等待该锁的线程，但我们发现，最终是t1结束了，但t2没有结束而且程序迟迟没有结束，这说明只有t1被唤醒了，而t2还在wait。而且可以发现，是t3结束先打印的，说明是notify之后会把后面的代码全部执行完才会去唤醒线程，而在调用了notify和t3后续代码执行完期间，t1的状态就是BLOCKED状态，如下：

这是在t3执行了notify之后，t1的状态：Thread-2（也就是t3）持有锁，而Thread-0（t1）已经不是waiting状态了，而是BOLCKED状态，它已经被唤醒，在等锁。

5.notifyAll

notifyAll方法是一次唤醒所有线程。这与notify不同的是，所有线程都可以从WAITING状态转变成其他状态，但是，一i那位它们都想拿同一把锁，所以会出现锁金正，没拿到锁的就得等待持有锁的把锁释放了再去竞争，在等待锁的过程中，这些线程就是BLOCKED状态

public class Test2 {
    private static Object object=new Object();
    public static void main(String[] args) {
        Thread t1=new Thread(()->{
            synchronized(object) {
                System.out.println("t1kaishi");
                try {
                    object.wait();
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("t1jieshu");
            }
        });
        Thread t2=new Thread(()->{
            synchronized (object){
                System.out.println("t2kaishi");
                try {
                    object.wait();
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("t2jieshu");
            }
        });
        Thread t3=new Thread(()->{
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (object){
                try {
                    object.notifyAll();
                    Thread.sleep(1000);
                    System.out.println("t3jieshu");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t1.start();
        t2.start();
        t3.start();
    }
}