刚才在论坛里跟他们有了不同意见，
我看的是毕向东的视频里面讲的是随机唤醒一条冻结的线程，
其他童鞋都说是唤醒等待最久的一条，我觉得不是，
求大神解答

1. 
   
2. /*
   
3. 生产者，消费者。
   
4. 
   
5. 多生产者，多消费者的问题。
   
6. if判断标记，只有一次，会导致不该运行的线程运行了。出现了数据错误的情况。
   
7. while判断标记，解决了线程获取执行权后，是否要运行！
   
8. 
   
9. notify:只能唤醒一个线程，如果本方唤醒了本方，没有意义。而且while判断标记+notify会导致死锁。
   
10. notifyAll解决了本方线程一定会唤醒对方线程的问题。
    
11. 
    
12. 
    
13. */
    
14. 
    
15. class Resource
    
16. {
    
17.         private String name;
    
18.         private int count = 1;
    
19.         private boolean flag = false;
    
20.         public synchronized void set(String name)//  
    
21.         {
    
22.                 while(flag)
    
23.                         try{this.wait();}catch(InterruptedException e){}//   t1    t0
    
24.                
    
25.                 this.name = name + count;//烤鸭1  烤鸭2  烤鸭3
    
26.                 count++;//2 3 4
    
27.                 System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);//生产烤鸭1 生产烤鸭2 生产烤鸭3
    
28.                 flag = true;
    
29.                 notify();
    
30.         }
    
31. 
    
32.         public synchronized void out()//  t3
    
33.         {
    
34.                 while(!flag)
    
35.                         try{this.wait();}catch(InterruptedException e){}        //t2  t3
    
36.                 System.out.println(Thread.currentThread().getName()+"...消费者........"+this.name);//消费烤鸭1
    
37.                 flag = false;
    
38.                 notify();
    
39.         }
    
40. }
    
41. 
    
42. class Producer implements Runnable
    
43. {
    
44.         private Resource r;
    
45.         Producer(Resource r)
    
46.         {
    
47.                 this.r = r;
    
48.         }
    
49.         public void run()
    
50.         {
    
51.                 while(true)
    
52.                 {
    
53.                         r.set("烤鸭");
    
54.                 }
    
55.         }
    
56. }
    
57. 
    
58. class Consumer implements Runnable
    
59. {
    
60.         private Resource r;
    
61.         Consumer(Resource r)
    
62.         {
    
63.                 this.r = r;
    
64.         }
    
65.         public void run()
    
66.         {
    
67.                 while(true)
    
68.                 {
    
69.                         r.out();
    
70.                 }
    
71.         }
    
72. }
    
73. 
    
74. 
    
75. 
    
76. class  ProducerConsumerDemo
    
77. {
    
78.         public static void main(String[] args)
    
79.         {
    
80.                 Resource r = new Resource();
    
81.                 Producer pro = new Producer(r);
    
82.                 Consumer con = new Consumer(r);
    
83. 
    
84.                 Thread t0 = new Thread(pro);
    
85.                 Thread t1 = new Thread(pro);
    
86.                 Thread t2 = new Thread(con);
    
87.                 Thread t3 = new Thread(con);
    
88.                 t0.start();
    
89.                 t1.start();
    
90.                 t2.start();
    
91.                 t3.start();
    
92. 
    
93.         }
    
94. }
    

复制代码

先按照运行0、3、1、3、0结果分析唤醒冻结最久的那条：

0线程运行==》生产烤鸭1==》0线程冻结
下面有两种可能
一种可能是1线程运行，第二种可能是3线程运行，分别说：
可能一：
1线程运行==》判断flog为true==》1线程冻结==》并没有打印任何结果也没唤醒。
3线程运行==》消费烤鸭1==》唤醒冻结最久的0线程==》3线程冻结。
然后下面一个是1线程消费，说明这个可能被否定了。

那么必然是可能二，重新来走一遍
0线程运行==》生产烤鸭1==》0线程冻结
3线程运行==》消费烤鸭1==》唤醒冻结最久的0线程==》3线程冻结。
下面又分两种可能①、2线程运行被冻结；②、1线程运行，2线程未运行，：
①、2线程运行==》2线程判断flog==》2线程冻结（此时未冻结线程只有0、1,根据打印结果，下次运行的是1；冻结的线程按时间算是3>2）
      1线程运行==》1线程生产烤鸭2==》1线程唤醒3线程==》1线程冻结。（此时冻结的线程为2>1）
      3线程运行==》3线程消费烤鸭2==》3线程唤醒2线程==》3线程冻结。（此时冻结线程为1>3)
      0线程运行==》0线程生产烤鸭3==》0线程唤醒1线程==》0线程冻结。（此时冻结线程为3>0)
至此2线程还未被冻结，如果按照此推断，这时应该是2线程消费烤鸭3。

而另一种可能：
②  0线程运行==》生产烤鸭1==》0线程冻结
     3线程运行==》消费烤鸭1==》唤醒冻结最久的0线程==》3线程冻结。
     1线程运行==》生产烤鸭2==》唤醒3线程==》1线程冻结
然后又有两种：2线程运行被冻结；2线程未运行，3线程运行

     3线程运行==》消费烤鸭2==》唤醒1线程==》3线程冻结    0线程运行==》生产烤鸭3==》唤醒3线程==》0线程冻结
可以看到此时3线程未被冻结， 按此理论应该消费烤鸭3！
至此不再判断另一种可能了，因为结果都一样。
所以我坚信！是随机唤醒的。

楼上分析得很详细

而再按照随机的方式，就能解释通了
由于随机唤醒分步太多，就不逐一分析了，下面说具体步骤：
03130
0线程运行==》生产烤鸭1==》0线程冻结
3线程运行==》消费烤鸭1==》唤醒0线程==》3线程冻结。（未冻结线程：0、1、2）
      （此步未打印结果）2线程运行==》2线程判断flog==》2线程冻结（未冻结线程：0、1）
1线程运行==》1线程生产烤鸭2==》1线程唤醒3线程==》1线程冻结。（未冻结线程：0、3）
       （此步未打印结果） 0线程运行==》0线程判断flog==》0线程冻结（未冻结线程：3）
3线程运行==》消费烤鸭2==》唤醒0线程==》3线程冻结（未冻结线程：0）
0线程运行==》生产烤鸭3==》唤醒1线程==》0线程冻结（未冻结线程：1）
       （此步未打印结果）1线程运行==》1线程判断flog==》1线程冻结（全部冻结，死锁）

总结完毕，说的不对请指正。写blog去了~~

两木三水 发表于 2015-8-12 21:43
楼上分析得很详细

淼淼兄，看童鞋的名字就是会水的，
不知道童鞋是什么看法啊

看不懂      

哎  ，折腾死人