生产者消费者问题也称为有限缓冲问题，是一个多线程同步的经典案例。该问题描述了共享固定大小缓冲区的两个线程——即“生产者”和“消费者”在实际运行时会发生的问题。
生产者的主要作用是产生一定量的数据放到缓冲区中，然后重复此过程。
同时，消费者在缓冲区消耗这些数据。
该问题的关键是保证生产者不会在缓冲区满时加入数据，消费者也不会在缓冲区中空时消耗数据。
**
案例：生产者生产鸡，两个消费者分别消费鸡

1. 使用synchronized+wait+notify+notifyAll 实现

  1. public class TestSynchronized {
  2.     public static void main(String[] args) {
  3.         Container container = new Container();
  4.         new Producer(container).start();
  5.         new Consumer(container).start();
  6.         new Consumer(container).start();
  7.     }
  8. }
  10. //商品
  11. class Chicken{
  12.     int id;
  13.     public Chicken(int id){
  14.         this.id = id;
  15.     }
  16. }
  18. //缓冲区
  19. class Container{
  20.     //定义一个固定大小的容器
  21.     Chicken[] chickens = new Chicken[10];
  22.     int size = 0;
  23.     //生产者生产完100只鸡后置为true
  24.     boolean flag = false;
  26.     //生产者放入产品
  27.     public synchronized void push(Chicken chicken) throws InterruptedException {
  29.         //如果容器满了，就需要等待消费者消费
  30.         while (size >= chickens.length) {
  31.             this.wait();
  32.         }
  34.         //如果没有满，就丢入产品
  35.         chickens[size] = chicken;
  36.         System.out.println("生产了第" +chicken.id+"只鸡");
  37.         size++;
  38.         if (chicken.id == 100){
  39.             flag = true;
  40.         }
  41.         this.notifyAll();
  44.     }
  46.     //消费者消费产品
  47.     public synchronized void poll() throws InterruptedException {
  48.         //如果没有鸡了，就得通知生产者生产
  49.         while (size <= 0){
  50.             if (flag){
  51.                 return;
  52.             }
  53.             this.notifyAll();
  54.             this.wait();
  55.         }
  57.         //如果还有鸡，就消费鸡
  58.         size--;
  59.         Chicken chicken = chickens[size];
  60.         System.out.println(Thread.currentThread().getName()+"消费了第"+chicken.id+"只鸡");
  63.     }
  65. }
  67. //生产者
  68. class Producer extends Thread{
  69.     Container container;
  71.     public Producer(Container container){
  72.         this.container= container;
  73.     }
  76.     public void run() {
  77.         for (int i = 1; i <= 100; i++) {
  78.             try {
  79.                 container.push(new Chicken(i));
  80.             } catch (InterruptedException e) {
  81.                 e.printStackTrace();
  82.             }
  83.         }
  84.     }
  85. }
  87. //消费者
  88. class Consumer extends Thread{
  89.     Container container;
  90.     public Consumer(Container container) {
  91.         this.container = container;
  92.     }
  94.     public void run() {
  95.         for (int i = 0; i < 100; i++) {
  96.             try {
  97.                 container.poll();
  98.             } catch (InterruptedException e) {
  99.                 e.printStackTrace();
  100.             }
  101.         }
  102.     }
  103. }

必须要注意的是：notify不能指定唤醒，但也不是随机唤醒，底层有一定的规则，但不知道是啥。
如果将poll()方法中this.notifyAll()换成this.notify()，则会出现两个消费者互相唤醒，但就是不唤醒生产者的问题。
注意，this.notify()和this.wait()必须在同步方法中使用。

2. 使用Lock

每条线程需要被一个同步监视器Condition来监视，做到精准唤醒。
如下代码，如果在Main方法中直接再new一条消费者线程，当唤醒消费者时会同时唤醒两个消费者，因为两条线程共用了consume()方法中的监视器，如果想要精准唤醒其中的一条线程就必须再写一组Condition+consume1方法+线程调用consume1方法。

  1. import java.util.LinkedList;
  2. import java.util.Queue;
  3. import java.util.concurrent.locks.Condition;
  4. import java.util.concurrent.locks.Lock;
  5. import java.util.concurrent.locks.ReentrantLock;
  7. public class TestLock {
  8.     public static void main(String[] args) {
  9.         Container1 container1 = new Container1();
  10.         new Producer1(container1).start();
  11.         new Consumer1(container1).start();
  12.     }
  14. }
  16. class Container1 {
  17.     Queue<Product> queue = new LinkedList<>();
  18.     Lock lock = new ReentrantLock();
  19.     Condition consumerCondition = lock.newCondition();
  20.     Condition producerCondition = lock.newCondition();
  22.     public void consume() {
  23.         lock.lock();
  24.         try {
  25.             while (queue.size() == 0) {
  26.                 consumerCondition.await();
  27.             }
  28.             Product product = queue.poll();
  29.             producerCondition.signal();
  30.             System.out.println(Thread.currentThread().getName()+"消费了---第"+product.id+"个产品---");
  31.         } catch (InterruptedException e) {
  32.             e.printStackTrace();
  33.         } finally {
  34.             lock.unlock();
  35.         }
  36.     }
  38.     public void produce(Product product) {
  39.         lock.lock();
  41.         try {
  42.             while(queue.size()>= 10) {
  43.                 producerCondition.await();
  44.             }
  45.             queue.add(product);
  46.             System.out.println(Thread.currentThread().getName()+"生产了第"+product.id+"个产品");
  47.             consumerCondition.signal();
  48.         } catch (InterruptedException e) {
  49.             e.printStackTrace();
  50.         } finally {
  51.             lock.unlock();
  52.         }
  54.     }
  55. }
  57. class Product{
  58.     int id ;
  59.     public Product(int id){
  60.         this.id  = id;
  61.     }
  62. }
  64. class Consumer1 extends Thread{
  65.     Container1 container1;
  66.     public Consumer1(Container1 container1){
  67.         this.container1 = container1;
  68.     }
  70.     public void run() {
  71.         for (int i = 1; i <= 100; i++) {
  72.             container1.consume();
  73.         }
  74.     }
  75. }
  77. class Producer1 extends Thread{
  78.     Container1 container1;
  79.     public Producer1(Container1 container1){
  80.         this.container1 = container1;
  81.     }
  82.     public void run() {
  83.         for (int i = 1; i <= 100; i++) {
  84.             container1.produce(new Product(i));
  85.         }
  86.     }
  87. }

3. 使用阻塞队列

阻塞队列的特征：
当队列为空时，线程从中取元素会被阻塞并且置于等待状态，直到有线程向其中放入元素；
当队列为满时，向其中放入元素的线程会被阻塞并且置于等待状态，直到有线程取出元素。
使用ArrayBlockingQueue实现，put为放入，take为取出。

  1. import java.util.concurrent.ArrayBlockingQueue;
  2. import java.util.concurrent.BlockingQueue;
  4. public class TestBlockingQueue {
  5.     static BlockingQueue<Person> blockingQueue = new ArrayBlockingQueue<>(10);
  7.     public static void main(String[] args) {
  8.         new Thread(() -> {
  9.             for (int i = 1; i < 100; i++) {
  10.                 try {
  11.                     blockingQueue.put(new Person(i));
  12.                     System.out.println("第"+i+"个大佬进入队列排队");
  13.                     Thread.sleep(10);
  14.                 } catch (InterruptedException e) {
  15.                     e.printStackTrace();
  16.                 }
  17.             }
  18.         },"Producer").start();
  20.         new Thread(() -> {
  21.             for (int i = 1; i < 100; i++) {
  22.                 Person person = null;
  23.                 try {
  24.                     person = blockingQueue.take();
  25.                 } catch (InterruptedException e) {
  26.                     e.printStackTrace();
  27.                 }
  28.                 System.out.println(Thread.currentThread().getName()+ "-----将第"+person.id+"位大佬带出队列");
  30.             }
  31.         },"Consumer1").start();
  33.         new Thread(() -> {
  34.             for (int i = 0; i < 100; i++) {
  35.                 Person person = null;
  36.                 try {
  37.                     person = blockingQueue.take();
  38.                 } catch (InterruptedException e) {
  39.                     e.printStackTrace();
  40.                 }
  41.                 System.out.println(Thread.currentThread().getName()+ "-----将第"+person.id+"位大佬带出队列");
  43.             }
  44.         },"Consumer2").start();
  46.         new Thread(() -> {
  47.             for (int i = 0; i < 100; i++) {
  48.                 Person person = null;
  49.                 try {
  50.                     person = blockingQueue.take();
  51.                 } catch (InterruptedException e) {
  52.                     e.printStackTrace();
  53.                 }
  54.                 System.out.println(Thread.currentThread().getName()+ "-----将第"+person.id+"位大佬带出队列");
  56.             }
  57.         },"Consumer3").start();
  58.     }
  59. }
  61. class Person{
  62.     int id;
  63.     public Person(int id){
  64.         this.id = id;
  65.     }
  66. }

4. 自旋锁+原子类实现

将原子类充当缓冲区数据量的计数器，先更新数据再更新原子类，可以实现生产者与消费者模型。
但由于更新数据和更新原子类计数器是分步操作，所以会出现问题：
存在一个数据但消费者无法消费或队列没有数据但生产者无法生产。
这里理论上可以不用原子类，但使用普通int数作为计数器产生了意料之外的死循环。

import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.atomic.AtomicInteger;

public class TestCAS {
    static AtomicInteger num = new AtomicInteger(0);
    static Queue<Chicken> queue = new LinkedList<>();
    public static void main(String[] args) {
        new Consumer2().start();
        new Producer2().start();
    }

    static class Producer2 extends Thread {
        public void run() {
            while (true) {
                while (num.get() >= 20) {
                }
                queue.add(new Chicken(1));
                int afterProduce = num.incrementAndGet();
                System.out.println("生产后剩余" + afterProduce + "个产品");
            }
        }
    }

    static class Consumer2 extends Thread {
        public void run() {
            while (true) {
                while (num.get() <= 0) {
                }
                queue.poll();
                int afterConsumer = num.getAndDecrement();
                System.out.println("消费后剩余" + afterConsumer + "个产品");
            }
        }
    }
}