利用J.U.C中的lock和condition实现生产者消费者模式

 package lockTest;

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

 public class ConditionTest {

     private Lock lock;

     private LinkedList<String> buffer;

     private int maxSize;

     private Condition notfullCondition;

     private Condition fullCondition;

     public ConditionTest(int maxSize) {
         this.maxSize = maxSize;
         lock = new ReentrantLock();
         buffer = new LinkedList<>();
         this.maxSize = maxSize;
         notfullCondition = lock.newCondition();
         fullCondition = lock.newCondition();
     }

     public void produce(String goods) throws InterruptedException {

         lock.lock();

         try {

             while (maxSize == buffer.size()) {
                 notfullCondition.await();
                 System.out.println("工厂产能达到极限，不能继续进行生产了,停工一段时间");
             }

             //队列没有满，可以生产
             buffer.add(goods);

             System.out.println("哈哈，我生产了" + goods + "，通知消费者进行消费...");
             //通知消费者线程进行消费
             fullCondition.signalAll();

         } finally {
             lock.unlock();
         }
     }

     public String consume() throws InterruptedException {

         String goods = null;
         lock.lock();

         try {

             while (buffer.size() == 0) {
                 System.out.println("工厂的产品已经消费完了，暂时不能剁手了");
                 fullCondition.await();
             }

             //开始消费
             goods = buffer.poll();
             System.out.println("哈哈，我消费" + goods + "，通知工厂进行生产...");
             //通知生成者
             notfullCondition.signalAll();

         } finally {
             lock.unlock();
         }

         return goods;
     }

     public static void main(String[] args) {

         ConditionTest conditionTest = new ConditionTest(100);

         new Thread(() -> {

             for (int i = 0; i < 1000000; i++) {
                 try {
                     conditionTest.produce("笔记本电脑" + i);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }

         }, "produce").start();

         new Thread(() -> {

             while (true) {
                 try {
                     conditionTest.consume();
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }

         }, "consume").start();

     }

 }