基于java callable及future接口解决生产者消费者问题

这两天复习java线程时，把java里面的线程基本知识点与jdk1.5以后新添加的一些类的使用都了解了一下，借用生产者消费者的问题来将他们实践一下。

 

题目：(题目在csdn一大牛的空间找的)

     生产者-消费者模式,这个食堂中只有1张桌子,同时最多放10个盘子,现在有4个厨师做菜,每做好一盘就往桌子上放(生产者将产品往仓库中放),而有6个食客不停地吃(消费者消费产品,为了说明问题,他们的食量是无的).一般而言,厨师200-400ms做出一盘菜,而食客要400-600ms吃完一盘.当桌子上放满了10个盘子后,所有厨师都不能再往桌子上放,而当桌子上没有盘子时,所有的食客都只好等待.

代码如下：

 

package net.xicp.tarbitrary.producerandcustomer;

import java.util.LinkedList;
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;


public class NewFeatureTest {

 public static void main(String[] args) throws InterruptedException,
   ExecutionException {
  // 创建一个具有10个线程的线程池
  ExecutorService se = Executors.newFixedThreadPool(30);
  // 产生一张桌子，桌子的最大容量为10
  DiningTable table = new DiningTable(10);
  // 产生生产者对象
  Chef chef = new Chef(table);
  // 产生消费者对象
  Eater eater = new Eater(table);
  
  
  //本例只是模拟10个生产者与10个消费者，并没有完全按照题目的意思来进行解答
  for (int i = 1; i < 11; i++) {
   final FutureTask cheafTask = new FutureTask(chef);
   final FutureTask eaterTask = new FutureTask(eater);
   // 启动一个生产者线程
   se.execute(cheafTask);
   // 启动一个消费者线程
   se.execute(eaterTask);
   // 启动一个线程监听当前生产者线程的结果
   se.execute(new Runnable() {
    @Override
    public void run() {
     try {
      String st = cheafTask.get();
      System.out.println(st);
     } catch (InterruptedException e) {
      e.printStackTrace();
     } catch (ExecutionException e) {
      e.printStackTrace();
     }

    }
   });
   // 启动一个线程监听当前消费者线程的结果
   se.execute(new Runnable() {
    @Override
    public void run() {
     try {
      String st = eaterTask.get();
      System.out.println(st);
     } catch (InterruptedException e) {
      e.printStackTrace();
     } catch (ExecutionException e) {
      e.printStackTrace();
     }
    }
   });
   //有序地关闭前面已经启动的一些线程
  }
  se.shutdown();
 }
}


class Chef implements Callable {
 private DiningTable t;
 private Random random = new Random();

 public Chef(DiningTable table) {
  this.t = table;
 }

 public DiningTable getT() {
  return t;
 }

 public void setT(DiningTable t) {
  this.t = t;
 }

 public Dish produce() {
  try {
   // 模拟做菜用的时间,200-400毫秒一道菜
   // 跟下面一句的效果一致
   TimeUnit.MILLISECONDS.sleep(200 + random.nextInt(201));
   // Thread.sleep(200 + random.nextInt(201));
  } catch (InterruptedException e) {
   e.printStackTrace();
  }
  Dish food = new Dish();
  return food;
 }

 @Override
 public String call() throws Exception {
  for (int i = 0; i < 10; i++) {
   Dish food = produce();
   t.putFood(food);
  }
  return Thread.currentThread().getName() + "结束";
 }

}


class Eater implements Callable {
 private DiningTable t;
 private Random random = new Random();

 public Eater(DiningTable table) {
  this.t = table;
 }

 public DiningTable getT() {
  return t;
 }

 public void setT(DiningTable t) {
  this.t = t;
 }

 
 public void consume(Dish food) {
  try {
   // 模拟吃菜用的时间
   // 跟下面一句的效果一致
   TimeUnit.MILLISECONDS.sleep(400 + random.nextInt(201));
   // Thread.sleep(400 + random.nextInt(201));
  } catch (InterruptedException e) {
   e.printStackTrace();
  }
 }

 @Override
 public String call() throws Exception {
  for (int i = 0; i < 10; i++) {
   Dish food = t.getFood();
   consume(food);
  }

  return Thread.currentThread().getName() + "结束";
 }

}


class Dish {
 Random random = new Random();

 private String foodName;

 public Dish() {
  super();
  int posi = random.nextInt(name.length);
  this.foodName = name[posi];
 }

 String name[] = { "巫山烤鱼", "清炒小白菜 ", "糖醋里脊", "手撕包菜", "拔丝香蕉", "水煮肉片", "酸菜鱼",
   "土豆肉片" };

 public String getName() {
  return foodName;
 }

}


class DiningTable {
 // 装食物用的容器
 private LinkedList list = new LinkedList();
 // 定义最大放菜量
 private int maxSize;
 // 创建一把锁
 private Lock lock = new ReentrantLock();
 // 获得当前lock对象的 Condition 实例
 private Condition condition;

 public Lock getLock() {
  return lock;
 }

 public void setLock(Lock lock) {
  this.lock = lock;
 }

 public Condition getCondition() {
  return condition;
 }

 public void setCondition(Condition condition) {
  this.condition = condition;
 }

 public LinkedList getList() {
  return list;
 }

 public void setList(LinkedList list) {
  this.list = list;
 }

 public int getMaxSize() {
  return maxSize;
 }

 
 public void setMaxSize(int maxSize) {
  this.maxSize = maxSize;
 }

 public DiningTable(int maxSize) {
  super();
  this.maxSize = maxSize;
  this.condition = lock.newCondition();
 }

 
 public void putFood(Dish food) {
  // 先进行锁定, 与synchronize起的作用类似
  lock.lock();
  try {
   // 防止假唤醒
   while (list.size() >= maxSize) {

    System.out.println( "菜已经上满了" + Thread.currentThread().getName() + ",让他们先吃,等消灭几盘再做菜");
    // 如果桌子的菜已经放满了，则让当前线程等待
    this.condition.await();
   }
   list.addLast(food);
   System.out.println(Thread.currentThread().getName() + "烹饪了"
     + food.getName());
   // 通知所有休眠的食客线程继续吃菜
   this.condition.signalAll();
  } catch (Exception e) {
   e.printStackTrace();
  } finally {
   // 解除锁定
   lock.unlock();
  }
 }

 
 public Dish getFood() {
  // 先进行锁定, 与synchronize起的作用类似
  lock.lock();
  Dish dish = null;
  try {
   // 防止假唤醒
   while (list.size() <= 0) {
    System.out.println( "菜已经被吃光了" + Thread.currentThread().getName() + "歇会再吃");

     // 如果桌子上已经没有菜了，则让当前线程等待
     this.condition.await();
    }
   dish = list.removeFirst();
   System.out.println(Thread.currentThread().getName() + "吃掉了"
     + dish.getName());
   // 通知所有休眠的做菜线程继续做菜
   this.condition.signalAll();
  } catch (Exception e) {
   e.printStackTrace();
  } finally {
   // 解除锁定
   lock.unlock();
  }

  return dish;
 }

}