眼看下面这段不起眼的小程序，很简单，很单纯。似曾相识，却又不太一样。吃透它，细心体会其中的每一个细节。废话不多说。上代码！
记录每一天，先来一段插曲描述一下，程序后还有分析与思考：
用四个线程实现，两个生产者生产产品后，另两个消费者消费。要求生产一个产品必须先消费才能再生产下一个商品。
分析：生产者与消费者之前有共享资源（产品）；且有多个线程（两个生产者与两个消费者）参与其中；生产者生产过程和消费过程都会使用到产品。以上三点，可以判断整个过程会引发安全隐患。我只需将双方使用产品的过程进行同步实现即可解决这个问题，这个安全隐患。
来吧，程序代码如下：

1. class  ProduceConsumerDemo
   
2. 
   
3. {
   
4. 
   
5.          public static void main(String[] args)
   
6. 
   
7.          {
   
8. 
   
9.                    Resource r = new Resource();
   
10. 
    
11.                    Thread t1 = new Thread(newProduce(r));
    
12. 
    
13.                    Thread t2 = new Thread(newConsumer(r));
    
14. 
    
15.                    Thread t3 = new Thread(newProduce(r));
    
16. 
    
17.                    Thread t4 = new Thread(newConsumer(r));
    
18. 
    
19.                   
    
20. 
    
21.                    t1.start();
    
22. 
    
23.                    t2.start();
    
24. 
    
25.                    t3.start();
    
26. 
    
27.                    t4.start();
    
28. 
    
29. 
    
30. 
    
31.                    /*
    
32. 
    
33.                    new Thread(newProduce(r)).start();
    
34. 
    
35.                    new Thread(newConsumer(r)).start();
    
36. 
    
37.                    new Thread(newProduce(r)).start();
    
38. 
    
39.                    new Thread(newConsumer(r)).start();
    
40. 
    
41.                    */
    
42. 
    
43.          }
    
44. 
    
45. }
    
46. 
    
47. 
    
48. 
    
49. classResource
    
50. 
    
51. {
    
52. 
    
53.          private String name;
    
54. 
    
55.          private int count = 1;
    
56. 
    
57.          private boolean flag;
    
58. 
    
59.          //t1和t2拥有不同的锁（Produce和Consumer对像），因此能够进入set函数内
    
60. 
    
61.          public synchronized void set(Stringname)//同步函数的锁是this,在这里this代表它所在类Resource的引用（即调用都是对象）
    
62. 
    
63.          {
    
64. 
    
65.                    //if(flag)  //换while,那么问题就来了，程序会停住。这时，唤醒方式改成notifyAll就可以解决。                                                
    
66. 
    
67.                                                         //考虑如何处理？想到反复判断flag不就解决了，因此用while(flag)替换if(flag)
    
68. 
    
69.                                                //  t1放弃资格 t2获取资格//当t2获取资格后就不再判断flag，这样会出现还没消费掉t1生产的商品他t2就紧接着生产。
    
70. 
    
71.                    while(flag)try{this.wait();}catch(Exception e){}
    
72. 
    
73.                    this.name =name+"----"+count++;
    
74. 
    
75.                    System.out.println(Thread.currentThread().getName()+"--生产者--"+this.name);
    
76. 
    
77.                    flag = true;
    
78. 
    
79.                    //this.notify();//notify唤醒的是池中的第一个等待中的线程 notifyAll唤醒池中所有等待中的进程
    
80. 
    
81.                    this.notifyAll();
    
82. 
    
83.          }
    
84. 
    
85. 
    
86. 
    
87.          //t1和t2拥有不同的锁（Produce和Consumer对像），因此能够进入out函数内
    
88. 
    
89.          public synchronized void out()//同步函数的锁是this,在这里this代表它所在类Resource的引用（即调用都是对象）
    
90. 
    
91.          {
    
92. 
    
93.                    /*if(!flag)*/
    
94. 
    
95.                                                ////  t1放弃资格 t2获取资格
    
96. 
    
97.                    while(!flag)       try{this.wait();}catch(Exception e){}
    
98. 
    
99.                    System.out.println(Thread.currentThread().getName()+"--消费者--------"+name);
    
100. 
     
101.                    flag = false;
     
102. 
     
103.                    //this.notify();
     
104. 
     
105.                    this.notifyAll();
     
106. 
     
107.          }
     
108. 
     
109. }
     
110. 
     
111. 
     
112. 
     
113. classProduce implements Runnable
     
114. 
     
115. {
     
116. 
     
117.          Resource r = new Resource();
     
118. 
     
119.          Produce(Resource r)
     
120. 
     
121.          {
     
122. 
     
123.                    this.r = r;
     
124. 
     
125.          }
     
126. 
     
127.          public void run()
     
128. 
     
129.          {
     
130. 
     
131.                    while(true)
     
132. 
     
133.                    {
     
134. 
     
135.                             r.set("商品");
     
136. 
     
137.                    }
     
138. 
     
139.          }
     
140. 
     
141.         
     
142. 
     
143. }
     
144. 
     
145. classConsumer implements Runnable
     
146. 
     
147. {
     
148. 
     
149.          Resource r = new Resource();
     
150. 
     
151.          Consumer(Resource r)
     
152. 
     
153.          {
     
154. 
     
155.                    this.r = r;
     
156. 
     
157.          }
     
158. 
     
159.          public void run()
     
160. 
     
161.          {
     
162. 
     
163.                    while(true)
     
164. 
     
165.                    {
     
166. 
     
167.                             r.out();
     
168. 
     
169.                    }
     
170. 
     
171.          }
     
172. 
     
173.         
     
174. 
     
175. }
     
176. 
     

复制代码

为实现同步，加入同步函数后发现。程序并达到没有预期的要求（产品必须先消费才能再生产下一个商品）。为达到这个目的，首先分析问题所在。经验证发现在使用产品过程中，同步函数监视器（锁）只能监视共同使用一个监视器的进程才有效，即无法监视具有不同监视器的对象。所以会导致程序中t1和t2对象判断语句判断后停留在那里，这样还会带来安全隐患。因此，为了达到多次判断，我们选择使用while循环语句。当然，引入while循环语句会带来程序停留的问题，不过使用Objec中的唤醒机制中的notifyAll完美解决了这个问。其中，一定要注意使用notify唤醒为什么会程序停留，因为其唤醒的只是池中的第一个进程。这样不难分析，其中生产者与消费者会多次使用产品的问题，而不是目标所要求的。


小小总结：要是有时间用思维导图体现，那就很Nice了。每天只24个小时，加油！

不错的例子

排版太差  不容易看懂。

谢谢分享！

谢谢分享~思维导图推荐imindmap~