如下为生产者消费者的最简单的使用方式

    1. public static class InstanceFuture<T> {
    2.         private volatile T hz;
    3.         private volatile Throwable throwable;
    5.         public T get() {
    6.             if (hz != null) {
    7.                 return hz;
    8.             }
    10.             boolean restoreInterrupt = false;
    11.             synchronized (this) {
    12.                 while (hz == null && throwable == null) {
    13.                     try {
    14.                         wait();
    15.                     } catch (InterruptedException ignored) {
    16.                         restoreInterrupt = true;
    17.                     }
    18.                 }
    19.             }
    21.             if (restoreInterrupt) {
    22.                 Thread.currentThread().interrupt();
    23.             }
    25.             if (hz != null) {
    26.                 return hz;
    27.             }
    29.             throw new IllegalStateException(throwable);
    30.         }
    32.         public void set(T proxy) {
    33.             synchronized (this) {
    34.                 this.hz = proxy;
    35.                 notifyAll();
    36.             }
    37.         }
    39.         public void setFailure(Throwable throwable) {
    40.             synchronized (this) {
    41.                 this.throwable = throwable;
    42.                 notifyAll();
    43.             }
    44.         }
    46.         public boolean isSet() {
    47.             return hz != null;
    48.         }
    49.     }

    典型的生产者和消费者模式，中最主要的就是这个相互间交互的这个数据存储部分，而这个存储部分，我觉得我们就可以将这个封装为一个类，然后这个类去做生产者和消费者之间的调度，这样我们就可以先提供接口。

    1. public interface Storage{
    2.     void produce();
    3.     void consume();
    4. }

    然后在根据顶层接口做抽象类

    1. public class AbstractStorage {
    2.     // 锁对象，也可以为当前对象
    3.     private Object lock;
    4.     // 循环的条件
    5.     private boolean condition;
    6.     public void produce(int num){
    7.         //同步
    8.         synchronized (lock){
    9.            //当前有的不满足需要，进行等待，直到满足条件
    10.             while(condition){
    11.                 try {
    12.                     //等待阻塞
    13.                     lock.wait();
    14.                 } catch (InterruptedException e) {
    15.                     e.printStackTrace();
    16.                 }
    17.             }
    18.         }
    19.         // ...
    20.         throw new IllegalStateException(throwable);
    21.     }
    23.     public void consume() {
    24.         synchronized (this) {
    25.             this.hz = proxy;
    26.             notifyAll();
    27.         }
    28.     }
    29. }

    参考：
    https://www.cnblogs.com/moongeek/p/7631447.html