java解决单缓冲生产者消费者问题示例

经典的生产者消费者问题模拟。此程序模拟最简单情形——单缓冲。为模拟实际情况，consume item和produce item时加了延时，可以通过修改延时模拟不同的生成消费速率。

1. /** 
2.  * single buffer consumer-producer problem. 
3.  * by xu([e-mail]). 
4.  * */ 
5. public class ConsumerProducer { 
6.  
7.  static Object buffer = null; 
8.  
9.  static Object mutex = new Object(); 
10.  
11.  static Object condConsumer = new Object();  
12.  
13.  static Object condProducer = new Object(); 
14.  
15.  public static void main(String[] args) { 
16.   Thread producer = new Thread() { 
17.    public void run() { 
18. //    for(int i=0; i<10; i++) { 
19.     for(int i=0; ; i++) { 
20.      // produce item. 
21.      try { 
22.       Thread.sleep(1000); 
23.      } catch (InterruptedException e) { 
24.       e.printStackTrace(); 
25.      } 
26.      String item = new String("item-" + i); 
27.      System.out.println("[producer] produced " + item); 
28.  
29.      // wait for buffer empty. 
30.      synchronized (condProducer) { 
31.       while(buffer != null) { 
32.        try { 
33.         condProducer.wait(); 
34.        } catch (InterruptedException e) { 
35.         e.printStackTrace(); 
36.        } 
37.       } 
38.      } 
39.  
40.      // put item to buffer.      
41.      synchronized (mutex) { 
42.       buffer = item; 
43.       System.out.println("[producer] put " + item + " to buffer."); 
44.      } 
45.  
46.      // notify consumers. 
47.      synchronized (condConsumer) { 
48.       condConsumer.notify(); 
49.      } 
50.     } 
51.    } 
52.   }; 
53.  
54.   Thread consumer = new Thread() { 
55.    public void run() { 
56. //    for(int i=0; i<10; i++) { 
57.     for( ; ; ) { 
58.      // wait for item come. 
59.      synchronized (condConsumer) { 
60.       while( buffer == null ) { 
61.        try { 
62.         condConsumer.wait(); 
63.        } catch (InterruptedException e) { 
64.         e.printStackTrace(); 
65.        } 
66.       } 
67.      } 
68.  
69.      // get item from buffer. 
70.      String item = null; 
71.      synchronized (mutex) { 
72.       item = (String)buffer; 
73.       buffer = null; 
74.       System.out.println("  [consumer] get " + item + " from buffer."); 
75.      } 
76.  
77.      // consume item. 
78.      try { 
79.       Thread.sleep(500); 
80.      } catch (InterruptedException e) { 
81.       e.printStackTrace(); 
82.      } 
83.      System.out.println("  [consumer] comsumed " + item); 
84.  
85.      // notify producers. 
86.      synchronized (condProducer) { 
87.       condProducer.notify(); 
88.      } 
89.     } 
90.    } 
91.   }; 
92.  
93.   consumer.start(); 
94.   producer.start(); 
95.  } 
96. }