1. class Resource
   
2. {
   
3.         private String name;
   
4.         private int count=1;
   
5. 
   
6.         private boolean flag=false;
   
7. 
   
8.         //注释一
   
9.         public synchronized void set(String name)//①t1拥有执行权 t2等待->②执行到notify()唤醒t2,t1判断标识后执行wait(),等待->③t2开始执行
   
10.         {
    
11.                 if(flag)
    
12.                         try
    
13.                         {
    
14.                                 this.wait();
    
15.                         }
    
16.                         catch (InterruptedException e)
    
17.                         {
    
18.                         }
    
19.                         this.name=name+count;
    
20.                         count++;
    
21.                         System.out.println(Thread.currentThread().getName()+"...生产者"+this.name);
    
22.                         flag=true;
    
23.                         this.notify();
    
24.         }
    
25.         public synchronized void out()//t3等待 t4等待
    
26.         {
    
27.                 if(!flag)
    
28.                         try
    
29.                         {
    
30.                                 this.wati();
    
31.                         }
    
32.                         catch (InterruptedException e)
    
33.                         {
    
34.                         }
    
35.                 System.out.println(Thread.currentThread().getName+"...消费者"+this.name);
    
36.                 flag=false;
    
37.                 this.notify();
    
38.         }
    
39. }
    
40. 
    
41. class Producer implements Runnable
    
42. {
    
43.         private Resource r;
    
44.         producer(Resource r)
    
45.         {
    
46.                 this.r=r;
    
47.         }
    
48.         public void run()
    
49.         {
    
50.                 while(true)
    
51.                 {
    
52.                         r.set("面包");
    
53.                 }
    
54.         }
    
55. }
    
56. class Consumer implements Runnable
    
57. {
    
58.         private Resource r;
    
59.         consumer(Resource r)
    
60.         {
    
61.                 this.r=r;
    
62.         }
    
63.         public void run()
    
64.         {
    
65.                 while(true)
    
66.                 {
    
67.                         r.out();
    
68.                 }
    
69.         }
    
70. }
    
71. class  ThreadDemo
    
72. {
    
73.         public static void main(String[] args)
    
74.         {
    
75.                 Resource r=new Resource();
    
76.                 Producer pro=new Producer(r);
    
77.                 Consumer con=new Consumer(r);
    
78. 
    
79. 
    
80.                 Thread t1=new Thread(pro);
    
81.                 Thread t2=new Thread(pro);
    
82. 
    
83.                 Thread t3=new Thread(con);
    
84.                 Thread t4=new Thread(con);
    
85. 
    
86.                 t1.start();
    
87.                 t2.start();
    
88.                 t3.start();
    
89.                 t4.start();
    
90. 
    
91. 
    
92.         }
    
93. }
    

复制代码

毕老师讲解多生产多消费时的代码事例


如上述代码注释一：
①t1拥有执行权，t2等待，t1执行同步代码，输出：Thread-0......生产者....面包2499，更改flag=true，执行notify()唤醒t2；
②此时t1仍然持有锁对象以及执行权，t1继续执行同步代码，首先进行if判断，flag为true，执行wait()，t1释放锁对象，处于等待状态；
③t2持有锁，开始执行同步代码。
疑点：此时flag仍然为true，为什么t2不需要进行if判断，可以继续执行下面的代码，
         输出： Thread-1......生产者.....2500

等待之前不是已经执行过if语句了么，如果你想唤醒之后再判断一次，那就要把if改成while

fantacyleo 发表于 2014-8-2 21:52
等待之前不是已经执行过if语句了么，如果你想唤醒之后再判断一次，那就要把if改成while ...

t2获得执行权后，难道不是从同步代码块的起始位置开始执行么。多线程不是只是操作了共享资源，而操作共享资源的代码会被加载到单独每个线程栈里么。

tc庄稼汉 发表于 2014-8-2 22:02
t2获得执行权后，难道不是从同步代码块的起始位置开始执行么。多线程不是只是操作了共享资源，而操作共享 ...

第一次是，可你说的是t2等待后又被唤醒，那当然就是从等待处开始执行啦

fantacyleo 发表于 2014-8-2 22:05
第一次是，可你说的是t2等待后又被唤醒，那当然就是从等待处开始执行啦

恩 ，明白了！ 也就是说t2线程从上一次停止的地方开始执行。你的意思是这几个线程wait之后，再一次执行时都不需要进行判断了吧。

if一般指判断一次，while判断多次的