生产者和消费者模式

生产者和消费者模式，由这个衍生的消息队列，任务队列...等等，原理都是这个，下面先上个代码。方便大家充分想象：

package com.my.jobQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
/**
 * <p>
 * 名称：BlockingQueueTest.java
 * </p>
 * <p>
 * 描述：
 * </p>
 * 
 * <pre>
 * 
 * </pre>
 * 
 * @author 鲍建明
 * @date 2015-1-13 下午4:10:32
 * @version 1.0.0
 */
public class BlockingQueueTest {
 final static AtomicInteger i = new AtomicInteger(0);
 /**
  * 定义装苹果的篮子
  */
 public static class Basket {
  // 篮子，能够容纳3个苹果
  // BlockingQueue<String> basket = new ArrayBlockingQueue<String>(3);
  BlockingQueue<String> basket = new LinkedBlockingQueue<String>(100);
  // 生产苹果，放入篮子
  public void produce() throws InterruptedException {
   // put方法放入一个苹果，若basket满了，等到basket有位置
   basket.put("第" + i.get() + "个苹果");
   System.out.println("放入第" + i.get() + "个苹果");
   i.getAndAdd(1);
  }
  // 消费苹果，从篮子中取走
  public String consume() throws InterruptedException {
   // get方法取出一个苹果，若basket为空，等到basket有苹果为止
   return basket.take();
  }
 }
 // 　测试方法
 public static void testBasket() {
  // 建立一个装苹果的篮子
  final Basket basket = new Basket();
  // 定义苹果生产者
  class Producer implements Callable<String> {
   public String instance = "";
   public Producer(String a) {
    instance = a;
   }
   public String call() throws Exception {
    try {
     while (true) {
      // 生产苹果
      basket.produce();
      // 休眠300ms
      TimeUnit.MILLISECONDS.sleep(300);
     }
    } catch (InterruptedException ex) {
    }
    return "生产任务成功后返回的参数";
   }
  }
  // 定义苹果消费者
  class Consumer implements Callable<String> {
   public String instance = "";
   public Consumer(String a) {
    instance = a;
   }
   public String call() throws Exception {
    try {
     while (true) {
      // 消费苹果
      String s = basket.consume();
      System.out.println("取出" + s);
      // 休眠1000ms
      TimeUnit.MILLISECONDS.sleep(1000);
     }
    } catch (InterruptedException ex) {
    }
    return "消费任务成功后返回的参数";
   }
  }
  ExecutorService service = Executors.newCachedThreadPool();
  Producer producer = new Producer("P1");
  Producer producer2 = new Producer("P2");
  Consumer consumer = new Consumer("C1");
  service.submit(producer); // 同时开启了2个生产者
  service.submit(producer2);
  service.submit(consumer);
  /*
   * ExecutorCompletionService<String> ecs = new
   * ExecutorCompletionService<String>(service);// 任务队列
   * ecs.submit(producer); ecs.submit(producer2); ecs.submit(consumer);
   * try { System.out.println(ecs.take().get()); } catch
   * (InterruptedException e1) { // TODO Auto-generated catch block
   * e1.printStackTrace(); } catch (ExecutionException e1) { // TODO
   * Auto-generated catch block e1.printStackTrace(); }
   */
  // 程序运行3s后，所有任务停止
  try {
   TimeUnit.SECONDS.sleep(3);
  } catch (InterruptedException e) {
  }
  service.shutdownNow(); // 强行停止
  // service.shutdown(); //等待任务完成后停止
 }
 public static void main(String[] args) {
  BlockingQueueTest.testBasket();
 }
}

附加一个文字说明的地址：http://my.oschina.net/u/153610/blog/23905