生产者和消费者（资源数目多个）

 

package book.j2se5;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * BlockingQueue:如果BlockingQueue是空的，从BlockingQueue取东西
 * 的操作都会被阻塞进入等待状态，直到BlockingQueue进了东西才会被唤醒。
 * 同时如果BlockingQueue是满的，任何试图存东西的操作都被阻塞进入等待
 * 状态。(可以放多个苹果）
 * @author wuhailin
 *
 */
public class BlockingQueueTest {

 /**定义装苹果的篮子*/
 public static class Basket{
  //篮子，能够容纳3个苹果
  BlockingQueue<String> basket=new ArrayBlockingQueue<String>(3);
  //生产苹果，放入篮子
  public void produce()throws InterruptedException{
   //put方法放入一个苹果，若basket满了，等待basket有位置
   basket.put("An apple");
  }
  //消费苹果，从篮子中取苹果
  public String consume()throws InterruptedException{
     //take方法取出一个苹果，若为空，则等待有苹果为止
   return basket.take();
  }
 }
 //测试方法
 public static void testBasket(){
  final Basket basket=new Basket();//建立一个装苹果的篮子
  //定义苹果消费者
  class Producer implements Runnable{
   public void run(){
    try{
     while(true){
      //生产苹果
      System.out.println("生产者准备生产苹果："+System.currentTimeMillis());
      basket.produce();
      System.out.println(" 生产者生产苹果完毕："+System.currentTimeMillis());
      Thread.sleep(300);
     }
    }catch(InterruptedException ex){
     
    }
   }
  }
  class Consumer implements Runnable{
   public void run(){
    try{
     while(true){
      System.out.println("消费者准备消费苹果："+System.currentTimeMillis());
      basket.consume();
      System.out.println("消费者消费苹果完毕："+System.currentTimeMillis());
      Thread.sleep(1000);
     }
    }catch(InterruptedException ex){
     
    }
   }
  }
  ExecutorService service=Executors.newCachedThreadPool();
  Producer producer=new Producer();
  Consumer consumer=new Consumer();
  service.submit(producer);
  service.submit(consumer);
  try{
   Thread.sleep(5000);
  }catch(InterruptedException e){
   
  }
  service.shutdownNow();
 }
 public static void main(String[] args) {
  BlockingQueueTest.testBasket();
 }
}