生产者消费者

之前看博客学了一种生产者消费者的写法，做一下笔记，以便回顾，因为感觉自己还没有很好的吸收。

可以有多个生产与多个消费， LinkedList 就像一个仓库容器，生产者往里加，消费者往外拿，只要没到满或空，就会这样进行下去，直到停止程序；

如果满了，生产者进行等待（说明生产的太快了，可以歇会了），消费者进行消费后会通知它，它再干活。

如果空了，消费者进行等待（说明消费的太快了，消费完了，没得消费了，也可以协会了，等有了再消费）。生产者生产了会通知它。

用了两个Condition ，之前没写过两个的情况，这次尝试一下，做个笔记。理解的是

一个Condition full 负责控制生产者的等待唤醒；

一个Condition empty 负责控制消费者的等待唤醒；

感觉这样做的有点是唤醒的时候可以唤醒所有的生产者，调用 full.signalAll() 唤醒的是所有生产者而没有一个消费者，感觉就是可以分开唤醒控制，更加的灵活。

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

public class Storage {

    private final int MAX_SIZE = 10;
    private LinkedList<String> list = new LinkedList<>();
    private final Lock lock = new ReentrantLock();
    /**
     * 仓库满的条件变量
     */
    private final Condition full = lock.newCondition();
    /**
     * 仓库空的条件变量
     */
    private final Condition empty = lock.newCondition();


    public void produce(){
        try {
            lock.lock();
            while (list.size() >= MAX_SIZE){
                System.out.println("生产者 "+Thread.currentThread().getName()+" 仓库已满");
                full.await();
            }

            list.add("1");
            System.out.println("生产者 "+Thread.currentThread().getName()+
                    " 生产一个产品，现存有："+list.size());

            // 唤醒其他所有线程，释放锁
            empty.signalAll();

        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void consume(){
        try {
            lock.lock();
            while (list.size() == 0){
                System.out.println("消费者"+Thread.currentThread().getName()+"仓库为空");
                empty.await();
            }

            list.remove();
            System.out.println("消费者"+Thread.currentThread().getName()+
                    "消费一个。现存有："+list.size());

            full.signalAll(); // 这样是唤醒所有生产者线程，而不是所有线程

        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }


}