Java线程:并发合作-生产者消费者模子[Java编程]

实际上,精确说应当是“生产者-消费者-仓储”模子,脱离了仓储,生产者消费者模子就显得没有说服力了.

关于此模子,应当明确一下几点:

1、生产者仅仅在仓储未满时刻生产,仓满则终止生产.

2、消费者仅仅在仓储有产品时刻才能消费,仓空则等候.

3、当消费者发现仓储没产品可消费时刻会告诉生产者生产.

4、生产者在生产出可消费产品时刻,应当告诉等候的消费者去消费.

此模子将要结合java.lang.Object的wait与notify、notifyAll办法来实现以上的需求.这是非常重要的.

/**
*　Java线程:并发合作-生产者消费者模子
*
*　@author　leizhimin
*/
public　class　Test　{
　　　　　　　　 public　static　void　main(String[]　args)　{
　　　　　　　　　　　　　　　　 Godown　godown　=　new　Godown(30);
　　　　　　　　　　　　　　　　 Consumer　c1　=　new　Consumer(50,　godown);
　　　　　　　　　　　　　　　　 Consumer　c2　=　new　Consumer(20,　godown);
　　　　　　　　　　　　　　　　 Consumer　c3　=　new　Consumer(30,　godown);
　　　　　　　　　　　　　　　　 Producer　p1　=　new　Producer(10,　godown);
　　　　　　　　　　　　　　　　 Producer　p2　=　new　Producer(10,　godown);
　　　　　　　　　　　　　　　　 Producer　p3　=　new　Producer(10,　godown);
　　　　　　　　　　　　　　　　 Producer　p4　=　new　Producer(10,　godown);
　　　　　　　　　　　　　　　　 Producer　p5　=　new　Producer(10,　godown);
　　　　　　　　　　　　　　　　 Producer　p6　=　new　Producer(10,　godown);
　　　　　　　　　　　　　　　　 Producer　p7　=　new　Producer(80,　godown);
　　　　　　　　　　　　　　　　 c1.start();
　　　　　　　　　　　　　　　　 c2.start();
　　　　　　　　　　　　　　　　 c3.start();
　　　　　　　　　　　　　　　　 p1.start();
　　　　　　　　　　　　　　　　 p2.start();
　　　　　　　　　　　　　　　　 p3.start();
　　　　　　　　　　　　　　　　 p4.start();
　　　　　　　　　　　　　　　　 p5.start();
　　　　　　　　　　　　　　　　 p6.start();
　　　　　　　　　　　　　　　　 p7.start();
　　　　　　　　 }
}
/**
*　仓库
*/
class　Godown　{
　　　　　　　　 public　static　final　int　max_size　=　100;　//最大库存量
　　　　　　　　 public　int　curnum;　//当前库存量
　　　　　　　　 Godown()　{
　　　　　　　　 }
　　　　　　　　 Godown(int　curnum)　{
　　　　　　　　　　　　　　　　 this.curnum　=　curnum;
　　　　　　　　 }
　　　　　　　　 /**
　　　　　　　　　 *　生产指定数目的产品
　　　　　　　　　 *
　　　　　　　　　 *　@param　neednum
　　　　　　　　　 */
　　　　　　　　 public　synchronized　void　produce(int　neednum)　{
　　　　　　　　　　　　　　　　 //测试能否需求生产
　　　　　　　　　　　　　　　　 while　(neednum　+　curnum　>　max_size)　{
　　　　　　　　　　　　　　　　　　　　　　　　 System.out.println("要生产的产品数目"　+　neednum　+　"超越剩余库存量"　+　(max_size　-　curnum)　+　",暂时不能履行生产任务!");
　　　　　　　　　　　　　　　　　　　　　　　　 try　{
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 //当前的生产线程等候
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 wait();
　　　　　　　　　　　　　　　　　　　　　　　　 }　catch　(InterruptedException　e)　{
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 e.printStackTrace();
　　　　　　　　　　　　　　　　　　　　　　　　 }
　　　　　　　　　　　　　　　　 }
　　　　　　　　　　　　　　　　 //满意生产条件,则举行生产,这里简单的更改当前库存量
　　　　　　　　　　　　　　　　 curnum　+=　neednum;
　　　　　　　　　　　　　　　　 System.out.println("已经生产了"　+　neednum　+　"个产品,现仓储量为"　+　curnum);
　　　　　　　　　　　　　　　　 //唤醒在此对象监督器上等候的全部线程
　　　　　　　　　　　　　　　　 notifyAll();
　　　　　　　　 }
　　　　　　　　 /**
　　　　　　　　　 *　消费指定数目的产品
　　　　　　　　　 *
　　　　　　　　　 *　@param　neednum
　　　　　　　　　 */
　　　　　　　　 public　synchronized　void　consume(int　neednum)　{
　　　　　　　　　　　　　　　　 //测试能否可消费
　　　　　　　　　　　　　　　　 while　(curnum　<　neednum)　{
　　　　　　　　　　　　　　　　　　　　　　　　 try　{
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 //当前的生产线程等候
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 wait();
　　　　　　　　　　　　　　　　　　　　　　　　 }　catch　(InterruptedException　e)　{
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 e.printStackTrace();
　　　　　　　　　　　　　　　　　　　　　　　　 }
　　　　　　　　　　　　　　　　 }
　　　　　　　　　　　　　　　　 //满意消费条件,则举行消费,这里简单的更改当前库存量
　　　　　　　　　　　　　　　　 curnum　-=　neednum;
　　　　　　　　　　　　　　　　 System.out.println("已经消费了"　+　neednum　+　"个产品,现仓储量为"　+　curnum);
　　　　　　　　　　　　　　　　 //唤醒在此对象监督器上等候的全部线程
　　　　　　　　　　　　　　　　 notifyAll();
　　　　　　　　 }
}
/**
*　生产者
*/
class　Producer　extends　Thread　{
　　　　　　　　 private　int　neednum;　//生产产品的数目
　　　　　　　　 private　Godown　godown;　//仓库
　　　　　　　　 Producer(int　neednum,　Godown　godown)　{
　　　　　　　　　　　　　　　　 this.neednum　=　neednum;
　　　　　　　　　　　　　　　　 this.godown　=　godown;
　　　　　　　　 }
　　　　　　　　 public　void　run()　{
　　　　　　　　　　　　　　　　 //生产指定数目的产品
　　　　　　　　　　　　　　　　 godown.produce(neednum);
　　　　　　　　 }
}
/**
*　消费者
*/
class　Consumer　extends　Thread　{
　　　　　　　　 private　int　neednum;　//生产产品的数目
　　　　　　　　 private　Godown　godown;　//仓库
　　　　　　　　 Consumer(int　neednum,　Godown　godown)　{
　　　　　　　　　　　　　　　　 this.neednum　=　neednum;
　　　　　　　　　　　　　　　　 this.godown　=　godown;
　　　　　　　　 }
　　　　　　　　 public　void　run()　{
　　　　　　　　　　　　　　　　 //消费指定数目的产品
　　　　　　　　　　　　　　　　 godown.consume(neednum);
　　　　　　　　 }
}

　　以上是“Java线程:并发合作-生产者消费者模子[Java编程]”的内容，如果你对以上该文章内容感兴趣，你可以看看七道奇为您推荐以下文章：