多线程的等待/通知机制

等待/通知机制，是指一个线程A调用了对象O的wiat方法进入等待状态，而另一个线程B调用了对象O的notify或者notifyAll方法，线程A收到通知后从对象O的wait方法返回，进而执行后续操作。

等待/通知的实例分析

在下面的代码中，创建两个线程，WaitThread和NotifyThread。WaitThread负责检查flag是否为false，如果符号要求，则进行后续操作，否则在lock上等待。NotifyThread在睡眠了一段时间后对lock进行通知

public class WaitNotify{
    static boolean flag = true;
    static Object lock = new Object();
    static class WaitThread implements Runnable{

        @Override
        public void run() {
            //加锁，拥有lock的Monitor 
            synchronized (lock) {
                //当条件不满足时，继续wait，同时释放了lock的锁
                while(flag){

                    System.out.println("当前线程为："+Thread.currentThread().getName()+",flag is true！处于WAITING状态"+new SimpleDateFormat("HH:mm:ss").format(new Date()));

                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }
                //条件满足时，继续工作
                System.out.println("当前线程为："+Thread.currentThread().getName()+",flag is false！！处于RUNNING状态"+new SimpleDateFormat("HH:mm:ss").format(new Date()));

            }

        }

    }
    static class NotifyThread implements Runnable{

        @Override
        public void run() {
            //加锁，拥有lock的Monitor
            synchronized (lock) {
                //获取lock的锁，然后进行通知，但是通知时不会释放lock的锁
                //直到当前线程释放了lock后，等待线程才能从wait方法中返回
                System.out.println("当前线程为："+Thread.currentThread().getName()+",持有锁！"+new SimpleDateFormat("HH:mm:ss").format(new Date()));
                lock.notifyAll();
                flag=false;
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //再次加锁
            synchronized (lock) {
                System.out.println("当前线程为："+Thread.currentThread().getName()+",再次持有锁！！sleep"+new SimpleDateFormat("HH:mm:ss").format(new Date()));
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

    }
    public static void main(String[] args) throws InterruptedException{
        Thread waitThread = new Thread(new WaitThread(),"WaitThread");
        waitThread.start();
        TimeUnit.SECONDS.sleep(5);
        Thread notifyThread = new Thread(new NotifyThread(),"NotifyThread");
        notifyThread.start();
    }
}

执行结果：

当前线程为：WaitThread,flag is true！处于WAITING状态17:42:55
当前线程为：NotifyThread,持有锁！17:43:00
当前线程为：NotifyThread,再次持有锁！！sleep17:43:05
当前线程为：WaitThread,flag is false！！处于RUNNING状态17:43:10

执行过程大致如下：
WaitThread首先获取了对象的锁，然后调用对象的wait方法，从而放弃了锁并进入了等待对了WaitQueue中，进入等待状态。由于WaitThread释放了对象的锁，NotifyThread随后获取了对象的锁，并调用对象的notifyAll方法，将WaitThread从等待队列移到SynchronizeQueue中，此时WaitThread处于阻塞状态，NotifyThread释放了锁之后，WaitThread再次获取到锁并从wait方法返回继续执行。

以上就是完整的线程通讯的例子

等待/通知的范式

等待方（消费者）遵循如下原则：

1. 获取对象的锁

2. 如果条件不满足，则调用对象的wait方法，被通知后再此检查条件

3. 条件满足，则继续进行执行

对应的伪代码如下：

synchroniz(obj){
    while(flag){//条件不满足
        obj.wait();//等待
    }
    //如果条件满足,执行相应的逻辑
    ......
}

通知方（生产者）应该遵循的规则：

1. 获得对象的锁

2. 改变条件

3. 通知所有等待在对象上的线程

伪代码如下：

synchronize(obj){
    //改变条件
    flag=false;
    //通知等待的线程
    obj.notifyAll();
}