1. package com.pln.gaoji;
    3. public class TestPC {
    4.     public static void main(String[] args) {
    5.         SynContainer container = new SynContainer();
    6.         new Producer(container).start();
    7.         new Customer(container).start();
    8.     }
    9. }
    10. //生产者
    11. class Producer extends Thread{
    12.     SynContainer container;
    13.     public Producer(SynContainer container){
    14.         this.container = container;
    15.     }
    16.     @Override
    17.     public void run() {
    18.         for (int i = 0; i < 100; i++) {
    19.             try {
    20.                 container.push(new Chicken(i));
    21.             } catch (InterruptedException e) {
    22.                 e.printStackTrace();
    23.             }
    24.             System.out.println("生产了"+i+"只鸡");
    25.         }
    26.     }
    27. }
    28. //消费者
    29. class Customer extends Thread{
    30.     SynContainer container;
    31.     public Customer(SynContainer container){
    32.         this.container = container;
    33.     }
    34.     @Override
    35.     public void run() {
    36.         for (int i = 0; i < 100; i++) {
    38.             try {
    39.                 System.out.println("消费了"+container.pop().id+"只鸡");
    40.             } catch (InterruptedException e) {
    41.                 e.printStackTrace();
    42.             }
    43.         }
    44.     }
    45. }
    46. //产品
    47. class Chicken{
    48.     int id;
    49.     public Chicken(int id) {
    50.         this.id = id;
    51.     }
    52. }
    53. //缓冲区
    54. class SynContainer{
    55. //    需要一个容器大小
    56.     Chicken[] chickens = new Chicken[10];
    57. //    容器计算器
    58.     int count = 0;
    59. //    生产者放入产品
    60.     public synchronized void push(Chicken chicken) throws InterruptedException {
    61.         //如果容器满了，需要等待消费者消费
    62.         if(count == chickens.length){
    63.             //通知消费者消费，等待生产
    64.             this.wait();
    65.         }
    66.         //如果没有满我们就需要丢入产品
    67.         chickens[count] = chicken;
    68.         count++;
    69.         //可以通过消费者消费了
    70.         this.notifyAll();
    71.     }
    72. //    消费者消费产品
    73.     public synchronized Chicken pop() throws InterruptedException {
    74.         //判断能否消费
    75.         if(count == 0){
    76.             //等待生产者生产，消费者等待
    77.             this.wait();
    78.         }
    79.         //如果可以消费
    80.         count--;
    81.         Chicken chicken = chickens[count];
    82.         //吃完了，通知生产者生产
    83.         this.notifyAll();
    84.         return chicken;
    85.     }
    86. }

    大概结果：
    image.png