生产者/消费者问题的多种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();//释放锁

      }
}