Java多线程之消费者生产者模式

开发 后端
这个实例应该是学习线程的一个经典例子,生产者和消费者模式。代码写的很好,详细请看内容。
  1. /*@author shijin  
  2. * 生产者与消费者模型中,要保证以下几点:  
  3. * 1 同一时间内只能有一个生产者生产     生产方法加锁sychronized  
  4. * 2 同一时间内只能有一个消费者消费     消费方法加锁sychronized  
  5. * 3 生产者生产的同时消费者不能消费     生产方法加锁sychronized  
  6. * 4 消费者消费的同时生产者不能生产     消费方法加锁sychronized  
  7. * 5 共享空间空时消费者不能继续消费     消费前循环判断是否为空,空的话将该线程wait,释放锁允许其他同步方法执行  
  8. * 6 共享空间满时生产者不能继续生产     生产前循环判断是否为满,满的话将该线程wait,释放锁允许其他同步方法执行     
  9. */ 
  10.  
  11. //主类  
  12. class  ProducerConsumer  
  13. {  
  14.     public static void main(String[] args)   
  15.     {  
  16.         StackBasket s = new StackBasket();  
  17.         Producer p = new Producer(s);  
  18.         Consumer c = new Consumer(s);  
  19.         Thread tp = new Thread(p);  
  20.         Thread tc = new Thread(c);  
  21.         tp.start();  
  22.         tc.start();  
  23.     }  
  24. }  
  25.  
  26. //  
  27. class Mantou  
  28. {  
  29.     private int id;  
  30.       
  31.     Mantou(int id){  
  32.         this.id = id;  
  33.     }  
  34.  
  35.     public String toString(){  
  36.         return "Mantou :" + id;  
  37.     }  
  38. }  
  39.  
  40. //共享栈空间  
  41. class StackBasket  
  42. {  
  43.     Mantou sm[] = new Mantou[6];  
  44.     int index = 0;  
  45.       
  46.     /**   
  47.     * show 生产方法.  
  48.     * show 该方法为同步方法,持有方法锁;  
  49.     * show 首先循环判断满否,满的话使该线程等待,释放同步方法锁,允许消费;  
  50.     * show 当不满时首先唤醒正在等待的消费方法,但是也只能让其进入就绪状态,  
  51.     * show 等生产结束释放同步方法锁后消费才能持有该锁进行消费  
  52.     * @param m 元素  
  53.     * @return 没有返回值   
  54.     */   
  55.  
  56.     public synchronized void push(Mantou m){  
  57.         try{  
  58.             while(index == sm.length){  
  59.                 System.out.println("!!!!!!!!!生产满了!!!!!!!!!");  
  60.                 this.wait();  
  61.             }  
  62.             this.notify();  
  63.         }catch(InterruptedException e){  
  64.             e.printStackTrace();  
  65.         }catch(IllegalMonitorStateException e){  
  66.             e.printStackTrace();  
  67.         }  
  68.           
  69.         sm[index] = m;  
  70.         index++;  
  71.         System.out.println("生产了:" + m + " 共" + index + "个馒头");  
  72.     }  
  73.  
  74.     /**   
  75.     * show 消费方法  
  76.     * show 该方法为同步方法,持有方法锁  
  77.     * show 首先循环判断空否,空的话使该线程等待,释放同步方法锁,允许生产;  
  78.     * show 当不空时首先唤醒正在等待的生产方法,但是也只能让其进入就绪状态  
  79.     * show 等消费结束释放同步方法锁后生产才能持有该锁进行生产  
  80.     * @param b true 表示显示,false 表示隐藏   
  81.     * @return 没有返回值   
  82.     */   
  83.     public synchronized Mantou pop(){  
  84.         try{  
  85.             while(index == 0){  
  86.                 System.out.println("!!!!!!!!!消费光了!!!!!!!!!");  
  87.                 this.wait();  
  88.             }  
  89.             this.notify();  
  90.         }catch(InterruptedException e){  
  91.             e.printStackTrace();  
  92.         }catch(IllegalMonitorStateException e){  
  93.             e.printStackTrace();  
  94.         }  
  95.         index--;  
  96.         System.out.println("消费了:---------" + sm[index] + " 共" + index + "个馒头");  
  97.         return sm[index];  
  98.     }  
  99. }  
  100.  
  101. class Producer implements Runnable  
  102. {  
  103.     StackBasket ss = new StackBasket();  
  104.     Producer(StackBasket ss){  
  105.         this.ss = ss;  
  106.     }  
  107.  
  108.     /**   
  109.     * show 生产进程.   
  110.     */   
  111.     public void run(){  
  112.         for(int i = 0;i < 20;i++){  
  113.             Mantou m = new Mantou(i);  
  114.             ss.push(m);  
  115. //          System.out.println("生产了:" + m + " 共" + ss.index + "个馒头");  
  116. //          在上面一行进行测试是不妥的,对index的访问应该在原子操作里,因为可能在push之后此输出之前又消费了,会产生输出混乱  
  117.             try{  
  118.                 Thread.sleep((int)(Math.random()*500));  
  119.             }catch(InterruptedException e){  
  120.                 e.printStackTrace();  
  121.             }  
  122.         }  
  123.     }  
  124. }  
  125.  
  126. class Consumer implements Runnable  
  127. {  
  128.     StackBasket ss = new StackBasket();  
  129.     Consumer(StackBasket ss){  
  130.         this.ss = ss;  
  131.     }  
  132.  
  133.     /**   
  134.     * show 消费进程.  
  135.     */   
  136.     public void run(){  
  137.         for(int i = 0;i < 20;i++){  
  138.             Mantou m = ss.pop();  
  139. //          System.out.println("消费了:---------" + m + " 共" + ss.index + "个馒头");  
  140. //  同上  在上面一行进行测试也是不妥的,对index的访问应该在原子操作里,因为可能在pop之后此输出之前又生产了,会产生输出混乱  
  141.             try{  
  142.                 Thread.sleep((int)(Math.random()*1000));  
  143.             }catch(InterruptedException e){  
  144.                 e.printStackTrace();  
  145.             }  
  146.         }  
  147.     }  

 原文链接:http://blog.csdn.net/shijinupc/article/details/7250407

【编辑推荐】

  1. 深入理解Java对象序列化
  2. 菜鸟入门Java语言学习的要点
  3. 如何优化Java程序设计和编码提高性能
  4. Java自定义范型的应用技巧
  5. 深入注解:在Java中设计和使用自己的注解
责任编辑:林师授 来源: shijinupc的博客
相关推荐

2017-05-16 12:30:21

Python多线程生产者消费者模式

2015-08-26 09:39:30

java消费者

2009-08-13 13:14:31

C#生产者和消费者

2021-12-22 11:00:05

模型Golang语言

2020-09-14 08:45:58

多线程模型面试

2024-03-14 11:58:43

2021-08-31 10:26:24

存储

2021-04-20 08:32:51

消息MQ队列

2021-12-28 12:01:59

Kafka 消费者机制

2023-06-01 08:08:38

kafka消费者分区策略

2015-08-05 09:33:21

Javawaitnotify

2015-06-15 11:29:34

数据中心绿色数据中心

2011-08-05 16:21:24

2011-07-22 16:25:38

CA TechnoloIT消费化

2022-07-07 09:00:49

RocketMQ消费者消息消费

2010-03-15 19:21:37

Java多线程

2011-11-15 10:05:29

Kindle Fire平板市场

2014-12-10 21:50:44

AdMaster

2015-06-29 15:00:20

云端数据消费者

2009-04-15 11:17:23

点赞
收藏

51CTO技术栈公众号