一个简单的生产者消费者模式

以下文字出自：http://canofy.iteye.com/blog/411408



在实际的软件开发过程中，经常会碰到如下场景：某个模块负责产生数据，这些数据由另一个模块来负责处理（此处的模块是广义的，可以是类、函数、线程、进程等）。产生数据的模块，就形象地称为生产者；而处理数据的模块，就称为消费者。
　
单单抽象出生产者和消费者，还够不上是生产者／消费者模式。该模式还需要有一个缓冲区处于生产者和消费者之间，作为一个中介。生产者把数据放入缓冲区，而消费者从缓冲区取出数据


◇解耦
　　假设生产者和消费者分别是两个类。如果让生产者直接调用消费者的某个方法，那么生产者对于消费者就会产生依赖（也就是耦合）。将来如果消费者的代码发生变化，可能会影响到生产者。而如果两者都依赖于某个缓冲区，两者之间不直接依赖，耦合也就相应降低了。
　　
◇支持并发（concurrency）
　　生产者直接调用消费者的某个方法，还有另一个弊端。由于函数调用是同步的（或者叫阻塞的），在消费者的方法没有返回之前，生产者只好一直等在那边。万一消费者处理数据很慢，生产者就会白白糟蹋大好时光。
　　使用了生产者／消费者模式之后，生产者和消费者可以是两个独立的并发主体（常见并发类型有进程和线程两种，后面的帖子会讲两种并发类型下的应用）。生产者把制造出来的数据往缓冲区一丢，就可以再去生产下一个数据。基本上不用依赖消费者的处理速度。其实当初这个模式，主要就是用来处理并发问题的。
　　
◇支持忙闲不均
　　缓冲区还有另一个好处。如果制造数据的速度时快时慢，缓冲区的好处就体现出来了。当数据制造快的时候，消费者来不及处理，未处理的数据可以暂时存在缓冲区中。等生产者的制造速度慢下来，消费者再慢慢处理掉。



自己写了个简单的程序...

   1. class Producer implements Runnable {//生产者  
   2.     Queue queue;  
   3.     public Producer(Queue q){  
   4.         queue = q;  
   5.     }  
   6.     @Override  
   7.     public void run() {  
   8.         for(int i=0;i<10;i++){  
   9.             queue.put(i);  
  10.             System.out.println("producter: "+i);  
  11.         }  
  12.     }  
  13. }  
  14. class Consumer implements Runnable {//消费者  
  15.     Queue queue;  
  16.     public Consumer(Queue q) {  
  17.         queue = q;  
  18.     }  
  19.     @Override  
  20.     public void run() {  
  21.         for(int i = 0; i < 10; i++){  
  22.             System.out.println("Consumer: "+queue.get());  
  23.         }  
  24.     }  
  25.   
  26. }  
  27.   
  28. class Queue {// 缓冲区，这里以队列来表示  
  29.     int value;  
  30.     boolean bFull = false;  
  31.     public synchronized void put(int i){  
  32.         if(!bFull){  
  33.             value = i;  
  34.             bFull = true;  
  35.             notify();  
  36.         }  
  37.         try {  
  38.             wait();  
  39.         } catch (Exception e) {  
  40.             e.printStackTrace();  
  41.         }  
  42.     }  
  43.     public synchronized int get(){  
  44.         if(!bFull){  
  45.             try {  
  46.                 wait();  
  47.             } catch (Exception e) {  
  48.                 e.printStackTrace();  
  49.             }  
  50.         }  
  51.             bFull = false;  
  52.             notify();  
  53.             return value;  
  54.           
  55.     }  
  56.       
  57. }  
  58. public class Test {//测试类  
  59.     public static void main(String[] args){  
  60.         Queue queue = new Queue();  
  61.         Producer producer = new Producer(queue);  
  62.         Consumer consumer = new Consumer(queue);  
  63.         Thread t1 = new Thread(producer);  
  64.         Thread t2 = new Thread(consumer);  
  65.         t1.start();  
  66.         t2.start();  
  67.     }  
  68. }