生产者/消费者问题的多种Java实现方式

生产者消费者问题是研究多线程程序时绕不开的经典问题之一，它描述是有一块缓冲区作为仓库，生产者可以将产品放入仓库，消费者则可以从仓库中取走产品。解决生产者/消费者问题的方法可分为两类：
（1）采用某种机制保护生产者和消费者之间的同步；
（2）在生产者和消费者之间建立一个管道。
第一种方式有较高的效率，并且易于实现，代码的可控制性较好，属于常用的模式。第二种管道缓冲区不易控制，被传输数据对象不易于封装等，实用性不强。因此本文只介绍同步机制实现的生产者/消费者问题。
同步问题核心在于：如何保证同一资源被多个线程并发访问时的完整性。常用的同步方法是采用信号或加锁机制，保证资源在任意时刻至多被一个线程访问。Java语言在多线程编程上实现了完全对象化，提供了对同步机制的良好支持。在Java中一共有四种方法支持同步，其中前三个是同步方法，一个是管道方法。
（1）wait() / notify()方法（notifyAll()）
（2）await() / signal()方法（signalAll()）
（3）BlockingQueue阻塞队列方法
（4）PipedInputStream / PipedOutputStream
本文只介绍最常用的前两种，第四种暂不做讨论，有兴趣的读者可以自己去网上找答案。
一、wait() / notify()方法
wait() / nofity()方法是基类Object的两个方法，也就意味着所有Java类都会拥有这两个方法，这样，我们就可以为任何对象实现同步机制。
wait()方法：当缓冲区已满/空时，生产者/消费者线程停止自己的执行，放弃锁，使自己处于等等状态，让其他线程执行。
notify()方法：当生处产者/消费者向缓冲区放入/取出一个产品时，向其他等待的线程发出可执行的通知，唤醒等待队列中的某个线程，同时放弃锁，使自己于等待状态，让该线程成为可运行状态。
notityAll()方法：就是唤醒所有等待队列中的线程，去参加这个锁的竞争，至于运行哪个线程则由cpu根据线程优先级决定。建议使用notifyAll()；

import java.util.LinkedList;
/**
 * 生产者消费者问题
 * @author zhaojw_420
 *
 */
public class BoundedBuffer {

      public static void main(String[] args) {
            //仓库对象
            Storge storge=new Storge();

            //生产者对象
            Producer p1=new Producer(storge);
            p1.setNum(10);
            Producer p2=new Producer(storge);
            p2.setNum(10);
            Producer p3=new Producer(storge);
            p3.setNum(10);
            Producer p4=new Producer(storge);
            p4.setNum(10);
            Producer p5=new Producer(storge);
            p5.setNum(10);
            Producer p6=new Producer(storge);
            p6.setNum(10);
            Producer p7=new Producer(storge);
            p7.setNum(10);
            //构建生产者对象线程
            Thread producer1=new Thread(p1);
            Thread producer2=new Thread(p2);
            Thread producer3=new Thread(p3);
            Thread producer4=new Thread(p4);
            Thread producer5=new Thread(p5);
            Thread producer6=new Thread(p6);
            Thread producer7=new Thread(p7);

            //消费者对象
            Consumer c1=new Consumer(storge);
            c1.setNum(50);
            Consumer c2=new Consumer(storge);
            c2.setNum(30);
            Consumer c3=new Consumer(storge);
            c3.setNum(20);

            //构建消费者对象线程
            Thread consumer1=new Thread(c1);
            Thread consumer2=new Thread(c2);
            Thread consumer3=new Thread(c3);

            //启动消费者线程
            consumer1.start();
            consumer2.start();
            consumer3.start();

            //启动生产者线程
            producer1.start();
            producer2.start();
            producer3.start();
            producer4.start();
            producer5.start();
            producer6.start();
            producer7.start();
      }
}
/**
 * 仓库类实现缓冲区
 * @author zhaojw_420
 *
 */
class Storge{
      /**
       * 仓库最大存储量
       */
      private final int MAX_SIZE=100;
      /**
       * 仓库存储的载体
       */
      private LinkedList<Object> list=new LinkedList<Object>();

      public LinkedList<Object> getList() {
            return list;
      }
      public void setList(LinkedList<Object> list) {
            this.list = list;
      }
      public int getMAX_SIZE() {
            return MAX_SIZE;
      }
      /**
       * 仓库中存进num个产品
       * @param num 存储产品个数
       */
      public void produce(int num){
            //同步代码快
            synchronized(list){
            while((list.size()+num)>MAX_SIZE){
                  System.err.println(System.currentTimeMillis()+"，本次生产的产品数量："+num+"个，此时的库存量："+list.size()+"，暂时不能执行生产任务！");

                  try {
                        list.wait();//仓库已满，不能生产，此时生产线程处于阻塞状态
                  } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                  }
            }
            //仓库未满，可以生产，生产num个产品
            for (int i = 0; i < num; i++) {
                  list.add(i);
            }

            System.out.println(System.currentTimeMillis()+"，此次生产产品数量："+num+"个，现在库存量为："+list.size());

            list.notifyAll();//唤醒等待队列的线程
            }
      }
      /**
       * 消费num个产品
       * @param num
       */
      public void consume(int num){
            //同步代码块
            synchronized(list){
                  //仓库数量不足，无法消费
                  while(list.size()<num){
                        System.err.println(System.currentTimeMillis()+"，本次消费的产品数量为："+num+"，库存量："+list.size()+"，暂时不能执行生产任务！");
                      try {
                              list.wait();//消费条件不满足，消费线程处于阻塞状态
                        } catch (InterruptedException e) {
                              // TODO Auto-generated catch block
                              e.printStackTrace();
                        }     
                  }

                  //消费情况满足，消费num个产品
                  for (int i = 0; i < num; i++) {
                        list.remove();
                  }

                  System.out.println(System.currentTimeMillis()+"，本次消费产品数量："+num+"，现库存量为："+list.size());

                  list.notifyAll();//唤醒等待队列的线程
            }
      }
}
/**
 * 生产类，实现Runable接口
 * @author zhaojw_420
 *
 */
class Producer implements Runnable{
      /**
       * 每次成产产品数量
       */
      private int num;

      /**
       * 所放置的仓库
       */
      private Storge storge;
      /**
       * 构造方法，设置仓库
       * @param boundedBuffer
       */
      public Producer(Storge storge) {
            this.storge = storge;
      }
      @Override
      public void run() {
            // TODO Auto-generated method stub
            storge.produce(num);
      }
      public int getNum() {
            return num;
      }
      public void setNum(int num) {
            this.num = num;
      }
      public Storge getStorge() {
            return storge;
      }
      public void setStorge(Storge storge) {
            this.storge = storge;
      }
}
/**
 * 消费者类，实现Runable接口
 * @author zhaojw_420
 *
 */
class Consumer implements Runnable{
      /**
       * 每次消费的产品数量
       */
      private int num;
      /**
       * 存储仓库
       */
      private Storge storge;
      /**
       * 构造函数，设置仓库
       * @param boundedBuffer
       */
      public Consumer(Storge storge) {
            this.storge = storge;
      }
      @Override
      public void run() {
            storge.consume(num);
      }
      public int getNum() {
            return num;
      }
      public void setNum(int num) {
            this.num = num;
      }
      public Storge getStorge() {
            return storge;
      }
      public void setStorge(Storge storge) {
            this.storge = storge;
      }
}

二、await()方法/signal()方法
在JDK5.0之后，Java提供了更加健壮的线程处理机制，包括同步、锁定、线程池等，它们可以实现更细粒度的线程控制。await()和signal()就是其中用来做同步的两种方法，它们的功能基本上和wait() / nofity()相同，完全可以取代它们，但是它们和新引入的锁定机制Lock直接挂钩，具有更大的灵活性。通过在Lock对象上调用newCondition()方法，将条件变量和一个锁对象进行绑定，进而控制并发程序访问竞争资源的安全。
例如：

/**
 * 仓库类实现缓冲区
 * @author zhaojw_420
 *
 */
class StorgeAwait{
      /**
       * 仓库最大存储量
       */
      private final int MAX_SIZE=100;
      /**
       * 仓库存储的载体
       */
      private LinkedList<Object> list=new LinkedList<Object>();

      /**
       * 可重入锁
       */
      private final Lock lock=new ReentrantLock();

      /**
       * 仓库满条件
       */
      private final Condition full=lock.newCondition();

      /**
       * 仓库空条件
       */
      private final Condition empty=lock.newCondition();

      public LinkedList<Object> getList() {
            return list;
      }
      public void setList(LinkedList<Object> list) {
            this.list = list;
      }
      public int getMAX_SIZE() {
            return MAX_SIZE;
      }
      /**
       * 仓库中存进num个产品
       * @param num 存储产品个数
       */
      public void produce(int num){
            //获得锁
            lock.lock();

            while((list.size()+num)>MAX_SIZE){
                  System.err.println(System.currentTimeMillis()+"，本次生产的产品数量："+num+"个，此时的库存量："+list.size()+"，暂时不能执行生产任务！");

                  try {
                        full.await();//仓库已满，不能生产，此时生产线程处于阻塞状态
                  } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                  }
            }
            //仓库未满，可以生产，生产num个产品
            for (int i = 0; i < num; i++) {
                  list.add(i);
            }

            System.out.println(System.currentTimeMillis()+"，此次生产产品数量："+num+"个，现在库存量为："+list.size());

            full.signalAll();//唤醒等待队列的线程
            empty.signalAll();

            //释放锁
            lock.unlock();

      }
      /**
       * 消费num个产品
       * @param num
       */
      public void consume(int num){

               //获得锁
               lock.lock();

                  //仓库数量不足，无法消费
                  while(list.size()<num){
                        System.err.println(System.currentTimeMillis()+"，本次消费的产品数量为："+num+"，库存量："+list.size()+"，暂时不能执行生产任务！");
                      try {
                              empty.await();//消费条件不满足，消费线程处于阻塞状态
                        } catch (InterruptedException e) {
                              // TODO Auto-generated catch block
                              e.printStackTrace();
                        }     
                  }

                  //消费情况满足，消费num个产品
                  for (int i = 0; i < num; i++) {
                        list.remove();
                  }

                  System.out.println(System.currentTimeMillis()+"，本次消费产品数量："+num+"，现库存量为："+list.size());

                  empty.signalAll();      //唤醒等待队列的线程
                  full.signalAll();

                  lock.unlock();//释放锁

      }
}