生产者--消费者模式

1、示例：

1. package unit18;
   
2. 
   
3. class Resource{
   
4.         private String name;
   
5.         private int count = 1;
   
6.         private Boolean flag = false;
   
7.        
   
8.         public synchronized void set(String name){
   
9.                 while(flag){  //while 的巧妙使用：当wait后的线程唤醒时，判断标标记
   
10.                         try {
    
11.                                 this.wait();//this代表调用函数线程
    
12.                         } catch (InterruptedException e) {}
    
13.                 }
    
14.                        
    
15.                 this.name = name+"__ " + count++;
    
16.                 System.out.println(Thread.currentThread().getName()+ "......生产者" + this.name);
    
17.                 flag = true;
    
18.                 this.notifyAll();
    
19.         }
    
20.        
    
21.         public synchronized void show(){
    
22.                 while(!flag){
    
23.                         try {
    
24.                                 this.wait();
    
25.                         } catch (InterruptedException e) {
    
26.                         }
    
27.                 }
    
28.                        
    
29.                
    
30.                 System.out.println(Thread.currentThread().getName()+"消费者"+ this.name);
    
31.                 flag = false;
    
32.                 this.notifyAll();
    
33.         }
    
34. }
    
35. 
    
36. //定义生产类Producter，生产商品
    
37. 
    
38. class Producter implements Runnable{
    
39.         private Resource r;
    
40.         Producter(Resource r){
    
41.                 this.r = r;
    
42.         }
    
43.         public void run(){
    
44.                 while(true){
    
45.                         r.set("商品");
    
46.                 }
    
47.         }
    
48. }
    
49. 
    
50. //定义消费者类Customer，消费商品
    
51. class Customer implements Runnable{
    
52.         private Resource r;
    
53.         Customer(Resource r){
    
54.                 this.r = r;
    
55.         }
    
56.         public void run(){
    
57.                 while(true){
    
58.                         r.show();
    
59.                 }
    
60.         }
    
61. }
    
62. 
    
63. 
    
64. public class ProductercustomerTest {
    
65. 
    
66.         public static void main(String[] args) {
    
67.                 Resource r = new Resource();
    
68.                 Producter pro = new Producter(r);
    
69.                 Customer cus = new Customer(r);
    
70.                 Thread t1 = new Thread(pro);
    
71.                 Thread t2 = new Thread(pro);
    
72.                 Thread t3 = new Thread(cus);
    
73.                 Thread t4 = new Thread(cus);
    
74.                 t1.start();
    
75.                 t2.start();
    
76.                 t3.start();
    
77.                 t4.start();
    
78.         }
    
79. 
    
80. }
    

复制代码

分析：

• 多个生产者、消费者定义使用while判断标记
  

　　　　原因：让被唤醒的线程再次判断标记

• 定义中使用notifyAll
  

　　　　原因： 因为需要唤醒对方线程，如果使用notify容易出现值唤醒本方线程的情况，导致线程中所有线程都处于等待状态

呵呵呵呵 。。。