Java并发编程中的等待/通知范式

“等待-通知”是挺有用的一个编程范式、设计模式或者说套路。白话讲就是一个线程执行需要等待一个事件发生或者说一个条件具备，然后另一个线程去触发这个事件或者更新这个条件，那么前者就可以触发执行了。这种设计可以解藕两个线程的业务逻辑，类似于生产者和消费者。

实现这个模式，主要有3种方法：线程自旋不断的去轮询条件是否具备、Object监视器方法wait()/notify() 、Condition接口

1、比较容易想到的“经典的方法”

一个线程不断的自旋，去查询自己能够继续执行的条件，一旦发现条件具备（另一个线程修改了条件），则结束自旋，去执行业务逻辑。

package com.wangan.concurrent;

import java.util.concurrent.TimeUnit;

public class WaitAndNotifyPattern {
    
    public static volatile boolean flag = false;
    
    public static void main(String[] args) {
        new Thread(new Wait()).start();
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(new Notify()).start();
        
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class Wait implements Runnable{

    @Override
    public void run() {
        while(!WaitAndNotifyPattern.flag) {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("条件还未满足，睡1秒");
        }
        System.out.println("wait条件满足了，执行业务逻辑");
    }
    
}

class Notify implements Runnable{

    @Override
    public void run() {
        WaitAndNotifyPattern.flag = true;
        System.out.println("notify修改了条件为true");
    }
    
}

输出：

条件还未满足，睡1秒

notify修改了条件为true

条件还未满足，睡1秒这里体现了发现条件不及时

wait条件满足了，执行业务逻辑

这个方法最大的缺陷在于需要线程sleep，休眠多少时间是一对儿矛盾，少了的话cpu受不了，多了的话条件变了这边发现不及时。

所以就有了下面两个新方法。

2、使用Object监视器方法配合synchronized实现等待通知机制

package com.wangan.basic;

import java.util.concurrent.TimeUnit;

public class WaitAndNotify {
    public static Object lock = new Object();
    public static boolean flag = false;
    public static void main(String[] args) {
        new Thread(new Wait()).start();
        sleepSecond(5);
        new Thread(new Notify()).start();
    }
    
    public static void sleepSecond(int sec) {
        try {
            TimeUnit.SECONDS.sleep(sec);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
class Wait implements Runnable{

    @Override
    public void run() {
        synchronized(WaitAndNotify.lock) {
            while(!WaitAndNotify.flag) {
                try {
                    System.out.println("Wait还未具备条件，等待");
                    WaitAndNotify.lock.wait();    //等待并释放锁
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("Wait获得了条件，执行业务逻辑");
        }
    }
    
}

class Notify implements Runnable{

    @Override
    public void run() {
        synchronized(WaitAndNotify.lock) {
            WaitAndNotify.flag = true;
            WaitAndNotify.lock.notifyAll();
            System.out.println("Notify进行通知了、也修改了条件，但是Wait不会马上从wait()返回继续执行，需要等待Notify释放锁，并且还得竞争到这个锁");
            WaitAndNotify.sleepSecond(5);
            System.out.println("Notify在通知后延迟了5秒释放了锁");
        }
        synchronized(WaitAndNotify.lock) {
            System.out.println("Notify的恶作剧，证明Wait接收到通知之后仍要竞争Lock才能从wait()方法返回继续执行");
        }
    }
    
}

输出：

Wait还未具备条件，等待
Notify进行通知了、也修改了条件，但是Wait不会马上从wait()返回继续执行，需要等待Notify释放锁，并且还得竞争到这个锁
Notify在通知后延迟了5秒释放了锁
Notify的恶作剧，证明Wait接收到通知之后仍要竞争Lock才能从wait()方法返回继续执行这句不在最后输出出来说明本次执行Wait在得到通知之后竞争锁又被Notify抢走了
Wait获得了条件，执行业务逻辑

3、使用Condition配合Lock实现等待通知机制

package com.wangan.basic;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ConditionWaitAndNotify {
    public static Lock lock = new ReentrantLock();
    public static Condition condition = lock.newCondition(); //Condition是依附于1个锁的
    public static boolean flag = false;
    
    public static void main(String[] args) {
        new Thread(new Consumer()).start();
        try {
            Thread.currentThread().sleep(2000);
        } catch (InterruptedException e) {}
        new Thread(new Producer()).start();
    }
    
}
class Consumer implements Runnable{

    @Override
    public void run() {
        ConditionWaitAndNotify.lock.lock();//先拿到锁
        try {
            while(!ConditionWaitAndNotify.flag) {
                System.out.println("Consumer条件尚未具备，等待");
                ConditionWaitAndNotify.condition.await();//在锁的Condition上等待
            }
            System.out.println("Consumer收到通知了、条件已具备，继续执行业务逻辑");
        }catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            ConditionWaitAndNotify.lock.unlock();
        }
    }
}
class Producer implements Runnable{

    @Override
    public void run() {
        ConditionWaitAndNotify.lock.lock();
        try {
            ConditionWaitAndNotify.flag = true;
            ConditionWaitAndNotify.condition.signalAll();
            System.out.println("Producer向Consumer通知条件已具备");
          }finally {
              ConditionWaitAndNotify.lock.unlock();
          }
        ConditionWaitAndNotify.lock.lock(); //跟Consumer抢锁
        System.out.println("Producer的恶作剧，发完通知用完了还跟Consumer抢一下锁");
        ConditionWaitAndNotify.lock.unlock();
    }
}

输出：

Consumer条件尚未具备，等待
Producer向Consumer通知条件已具备
Producer的恶作剧，发完通知用完了还跟Consumer抢一下锁
Consumer收到通知了、条件已具备，继续执行业务逻辑