多线程设计模式之——Producer-Consumer Pattern

转载 2013年02月28日 12:36:19
此模式是在生产者与消费者之间加入一个“桥梁参与者”来缓冲线程之间的处理速度差。一般可以存在多个生产者与消费者,但当双方都只有一个的时候,又称为Pipe Pattern。 

例子:假设有2个生产者,2个消费者,仓库里只能放4个产品。(这里的产品就是String类型的名字而已) 


Java代码  收藏代码
  1. //Storage.java  
  2. public class Storage {  
  3.     private String[] buffer;  
  4.     private int head;//取走一个商品的位置  
  5.     private int tail;//存入一个商品的位置  
  6.     private int count;//buffer内的商品数量  
  7.       
  8.     public Storage(int count){  
  9.         this.buffer = new String[count];  
  10.         this.count = 0;  
  11.         this.head = 0;  
  12.         this.tail = 0;  
  13.     }  
  14.       
  15.     //这里的if警戒条件就运用了Guarded Suspension Pattern,要求不满足条件,便等待  
  16.     public synchronized void put(String goods) throws InterruptedException{  
  17.         System.out.println(Thread.currentThread().getName() + " produce the goods:" + goods);  
  18.         if(count >= buffer.length){  
  19.             System.out.println("the storage is full!");  
  20.             wait();  
  21.         }  
  22.         buffer[tail] = goods;  
  23.         tail = (tail + 1) % buffer.length;  
  24.         count++;  
  25.         notifyAll();  
  26.     }  
  27.       
  28.     public synchronized String get() throws InterruptedException{  
  29.         if(count <= 0){  
  30.             System.out.println("the storage is empty!");  
  31.             wait();  
  32.         }  
  33.         String goods = buffer[head];  
  34.         head = (head + 1) % buffer.length;  
  35.         count--;  
  36.         notifyAll();  
  37.         System.out.println(Thread.currentThread().getName() + " consume the goods:" + goods );  
  38.         return goods;  
  39.     }  
  40.   
  41. }  




Java代码  收藏代码
  1. //ProducerThread.java  
  2. import java.util.Random;  
  3.   
  4.   
  5. public class ProducerThread extends Thread {  
  6.     private Storage storage;  
  7.     private Random random;  
  8.     private static int pid;  //产品编号  
  9.       
  10.     public ProducerThread(String name , Storage storage){  
  11.         super(name);  
  12.         this.storage = storage;  
  13.         this.random = new Random();  
  14.     }  
  15.       
  16.     public void run(){  
  17.         try{  
  18.             for(int i=0; i<10; i++){  
  19.                 Thread.sleep(random.nextInt(1000));//模拟生产时间  
  20.                 String goods = getName() + " produce the goods" + nextPId();  
  21.                 storage.put(goods);  
  22.             }  
  23.         }catch(InterruptedException e){  
  24.             e.printStackTrace();  
  25.         }  
  26.     }  
  27.       
  28.     private static synchronized int nextPId(){  
  29.         return pid++;  
  30.     }  
  31.   
  32. }  




Java代码  收藏代码
  1. //ConsumerThread.java  
  2. import java.util.Random;  
  3.   
  4.   
  5. public class ConsumerThread extends Thread {  
  6.     private Storage storage;  
  7.     private Random random;  
  8.       
  9.     public ConsumerThread(String name , Storage storage){  
  10.         super(name);  
  11.         this.random = new Random();  
  12.         this.storage = storage;  
  13.     }  
  14.       
  15.     public void run(){  
  16.         try{  
  17.             while(true){  
  18.                 storage.get();  
  19.                 Thread.sleep(random.nextInt(2000));//模拟商品使用时间  
  20.             }  
  21.         }catch(InterruptedException e){  
  22.             e.printStackTrace();  
  23.         }  
  24.     }  
  25.   
  26. }  




Java代码  收藏代码
  1. //Main.java  
  2. public class Main {  
  3.   
  4.     public static void main(String[] args) {  
  5.         Storage storage = new Storage(4);  
  6.         new ProducerThread("producer_lulu01" , storage).start();  
  7.         new ProducerThread("producer_lulu02" , storage).start();  
  8.         new ConsumerThread("consumer_fang01" , storage).start();  
  9.         new ConsumerThread("consumer_fang02" , storage).start();  
  10.           
  11.   
  12.     }  
  13.   
  14. }  
<script type="text/javascript"><!-- google_ad_client = "ca-pub-1944176156128447"; /* cnblogs 首页横幅 */ google_ad_slot = "5419468456"; google_ad_width = 728; google_ad_height = 90; //--></script><script type="text/javascript" src="http://pagead2.googlesyndication.com/pagead/show_ads.js"></script>

Android设计模式精解(第9课) :策略模式(Strategy pattern)

本章介绍这些类的协作模式,通称为策略模式。不同的App通常会采取不同的组装策略,来创造出各式各样的复合对象,需要撰写不同的策略类别,来实现其组装策略。Anrdoid 应用程序之类别(如myActivity)可视应用情境不同而与不同的策略类别互相搭配,然后将其不同的策略(即会变的部份)委托给不同的策略对象(各来自不同的策略类别)。本章介绍这些类的协作模式,通称为策略模式。
  • 2015年09月23日 05:35

Java多线程:Producer-Consumer不同的几种实现方式

生产者消费者问题是一个典型的线程同步问题。 主要有如下实现方式: wait() notifyAll() class Queue { //共享队列的目的用于...
  • langjian2012
  • langjian2012
  • 2015-03-22 20:55:42
  • 1389

多线程设计模式之——Producer-Consumer Pattern

此模式是在生产者与消费者之间加入一个“桥梁参与者”来缓冲线程之间的处理速度差。一般可以存在多个生产者与消费者,但当双方都只有一个的时候,又称为Pipe Pattern。 例子:假设有2个生产者,2个消...
  • dyllove98
  • dyllove98
  • 2013-02-28 12:36:19
  • 1040

Producer-Consumer Pattern

Producer-ConsumerPattern Producer是“生产者”的意思,是指产生数据的线程。而Consumer是“消费者”的意思,意指使用数据的线程。 生产者必须将数据安全地交给消费...
  • Leaderman_IT
  • Leaderman_IT
  • 2012-04-06 19:57:02
  • 838

Java多线程设计模式详解学习笔记七——Producer-Consumer

public class Main { public static void main(String[] args) { Table table=new Table(3); new Make...
  • GaoMatrix
  • GaoMatrix
  • 2011-11-17 15:24:00
  • 3879

kafka学习笔记整理1

比较不错的一篇入门例子,注释很详细很详细感谢博主:https://blog.csdn.net/cjf_wei/article/details/78075263KafkaProducer(org.apa...
  • nieji3057
  • nieji3057
  • 2018-03-30 21:36:10
  • 44

Java线程之Producer-Consumer Pattern

 Producer-Consumer Pattern的参与者:1. Data参与者    被Producer参与者所创建,并由Consumer参与者所使用。 2. Producer(生产者)参与者  ...
  • derekjiang
  • derekjiang
  • 2009-11-21 08:25:00
  • 2015

Java 多线程设计模式之Producer-Consumer

Producer-Consumer 模式通过在数据的生产者和消费者之间引入一个通道(Channel, 暂时可以将其简单地理解为一个队列)对二者进行解耦(Decouping):生产者将其生产的数据放入通...
  • lilele12211104
  • lilele12211104
  • 2017-12-08 11:10:22
  • 53

用Condition条件变量实现生产者消费者模式

import java.util.LinkedList; import java.util.concurrent.locks.Condition; import java.util.concurren...
  • jb_peng
  • jb_peng
  • 2016-04-01 17:40:09
  • 901

Java并发编程实践笔记之—阻塞队列和生产者-消费者模式(Blocking Queues and the Producer-consumer Pattern)

BlockingQueue 提供了可阻塞的put和take,和支持定时的offer和pollQueue可以是有界的或者无界的支持了生产者-消费者的设计模式,将两个过程解耦如果数据项添加队列失败,...
  • manicpixies
  • manicpixies
  • 2015-02-02 20:38:19
  • 339
收藏助手
不良信息举报
您举报文章:多线程设计模式之——Producer-Consumer Pattern
举报原因:
原因补充:

(最多只允许输入30个字)