原理： 建立一个公共的容器用来存放产品（产品池），生产者和消费者分别为单独的线程对产品池进行操作。为了保证线程的安全需要利用synchronized来使得产品池来实现阻塞的功能（互锁）。

建立产品池（容器）：

public class Container<T> {                       //建立产品池的泛型
    private T[] arr;                              //泛型数组
    private  int top=0;                          //数组指针，指示数组的元素序号          
    public Container() {                        //确定容器的容量
        this(5);
    }

    public Container(int size) {                    //容器的构造方法
        this.arr = (T[])new Object[size];
    }

    public synchronized void save(T o){              //生产者生产产品的同步方法
        while (top==arr.length){                     //判定数组内没有元素
            try {
                this.wait();                          //等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
}
        arr[top]=o;                               //添加元素到数组
        for (int i=0;i<arr.length;i++)
        {
         top++;                                    //指针移动
        System.out.println("做了"+top+"个包子");
}
        notify();                                  //通知等待的对象
        System.out.println("有包子了");
    }

测试:

public class Test {
    public static void main(String[] args) {     //主线程
        Container<String> container = new Container<>(); //创建容器对象
        new Thread("做包子") {                      //创建生产者的线程（匿名类）
            @Override
            public void run() {
                for (int i = 0; i < 10; i++)         //生产者生产出的产品数量
                    container.save("包子");
                System.out.println("最后存量：" + container.count());
            }
        }.start();
        new Thread("取包子1") {   //消费者1
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) //保持有消费者进行购买
                    container.fetch();
            }
        }.start();
        new Thread("取包子2") {
            @Override
            public void run() {
                container.fetch();//消费者购买一次
            }
        }.start();
    }
}

此功能实现了在最大存货量达成后，在有消费者需求将不再回应，此时消费者保持等待（过程结束）。这类方法是利用了数组建立栈模型来存放产品，实际中利用队列的模型（或者是）更合适。

为了使主程序简洁，可以单独提出产品类、消费者类、生产者类使得整个程序结构更加优化

产品类：

public class BaoZi {
    private Integer id;
    private String name;

    public BaoZi() {

    }

    public BaoZi(Integer id, String name) {
        this.id = id;
        this.name = name;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "BaoZi{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

生产者类：

public class Productor extends Thread{
    private Container<BaoZi> container;
    private Integer sum;

    public Productor(Container<BaoZi> container,Integer sum,String name) {
        super(name);
        this.container=container;
        this.sum = sum;
    }

    @Override
    public void run() {
        String[] names={"鲜肉包","香菇包","豆沙包"};
        Random random=new Random();
        for(int i=0;i<sum;i++){
             BaoZi baozi=new BaoZi(i+1,names[random.nextInt(3)]);
            System.out.println(Thread.currentThread().getName()+"做一个"+baozi);
            container.save(baozi);
        }
    }
}

消费者类：

public class Customer extends Thread{
    private Container<BaoZi>container;
    private Integer sum;

    public Customer(Container<BaoZi>container,Integer sum,String name) {
        super(name);
        this.container=container;
        this.sum = sum;
    }

    @Override
    public void run() {

        Random random=new Random();
        for(int i=0;i<sum;i++){
            BaoZi baoZi=container.fetch();
            System.out.println(Thread.currentThread().getName()+"买了一个"+baoZi);
            try {
                Thread.sleep(1000+random.nextInt(1000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

产品池：

public class Container<T> {
    private T[] arr;
    private int top = 0;
    public Container() {
        this(5);
    }

    public Container(int size) {
        this.arr = (T[]) new Object[size];
    }

    public synchronized void save(T o) {
        while (top == arr.length) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
}
      arr[top] = o;
          top++;
     notify();
  }
public synchronized T fetch() {
        while (top == 0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        try {
            Thread.sleep(400);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        top--;
        T t = arr[top];
        notify();
         return t;
    }
 public int count() {
        return top;
    }
}