现在是只有t2有执行资格其他三个都是wait状态, 毕老师说if只能判断一次,要改成while,但是t2已经进入while循环体里面了,为什么唤醒后还要回去判断一次呢?

罗会涛 发表于 2013-1-13 11:23
不知道在while后面加个括号把循环体括起来，你理解会不会容易些。
while被唤醒，但是唤醒时它任然在循环体 ...

ok , 懂了

1. import java.util.concurrent.locks.*;
   
2. class ProducterConsumerDemo2
   
3. {
   
4. public static void main(String[] args)
   
5. {
   
6. Resource r = new Resource(); //定义商品资源
   
7. Producter pro = new Producter(r);//创建生产者对象
   
8. Consumer son = new Consumer(r); //创建消费者对象
   
9. 
   
10. //创建两个生产者即两个线程
    
11. Thread t1 = new Thread(pro);
    
12. Thread t2 = new Thread(pro);
    
13. 
    
14. //创建两个消费者即两个线程
    
15. Thread t3 = new Thread(son);
    
16. Thread t4 = new Thread(son);
    
17. 
    
18. //启动四个线程并执行相应的run方法
    
19. t1.start();
    
20. t2.start();
    
21. t3.start();
    
22. t4.start();
    
23. 
    
24. }
    
25. }
    
26. 
    
27. class Resource
    
28. {
    
29. private String name; //商品的名字
    
30. private int count =1; //商品的编号
    
31. private boolean flag = false;
    
32. 
    
33. private Lock lock = new ReentrantLock();
    
34. 
    
35. private Condition condition_pro = lock.newCondition();
    
36. private Condition condition_con = lock.newCondition();
    
37. 
    
38. public void set(String name)throws InterruptedException
    
39. {
    
40. lock.lock();
    
41. try
    
42. {
    
43. while(flag)
    
44. condition_pro.await();
    
45. this.name = name + "--" + count++;//
    
46. 
    
47. System.out.println(Thread.currentThread().getName() + "...生产者 " + this.name);
    
48. flag = true;
    
49. condition_con.signal();
    
50. }
    
51. finally{
    
52. lock.unlock();//释放锁的操作一定要执行
    
53. }
    
54. }
    
55. public void out()throws InterruptedException
    
56. {
    
57. lock.lock();
    
58. try
    
59. {
    
60. while(!flag)
    
61. condition_con.await();
    
62. System.out.println(Thread.currentThread().getName() + "...消费者————" + this.name);
    
63. flag = false;
    
64. condition_pro.signal();
    
65. }finally{
    
66. lock.unlock();
    
67. }
    
68. }
    
69. }
    
70. // 商品的生产者
    
71. class Producter implements Runnable
    
72. {
    
73. private Resource res;
    
74. 
    
75. Producter(Resource res)
    
76. {
    
77. this.res = res;
    
78. }
    
79. public void run()
    
80. {
    
81. while(true)
    
82. {
    
83. try
    
84. {
    
85. res.set("商品+");
    
86. }
    
87. catch (InterruptedException e)
    
88. {
    
89. }
    
90. 
    
91. }
    
92. }
    
93. }
    
94. //商品的消费者
    
95. class Consumer implements Runnable
    
96. {
    
97. private Resource res;
    
98. 
    
99. Consumer(Resource res)
    
100. {
     
101. this.res = res;
     
102. }
     
103. public void run()
     
104. {
     
105. while(true)
     
106. {
     
107. try
     
108. {
     
109. res.out();
     
110. }
     
111. catch (InterruptedException e)
     
112. {
     
113. 
     
114. }
     
115. }
     
116. }
     
117. }
     

复制代码

这样是正确的写法！你看看吧！

不知道在while后面加个括号把循环体括起来，你理解会不会容易些。
while被唤醒，但是唤醒时它任然在循环体中，如果条件（即flag）不改变，这个循环是个死循环，相当于while（true）｛｝，大括号中的代码会不断执行，当然线程会再次wait。如果是if没有这个问题，它只判断一次。

t2已经进入while循环体里面了，但是苏醒后还要判断
是的
因为 t2 抢到线程时，可能没有执行权，还在线程池里缓冲，这时把这个线程等待了，当然是还没有判断。
你再次唤醒时，肯定是先判断，再走程序嘛。

while会跳出当前循环，重新循环，而if只会接着往下走，确保同步