1. /*
   
2. 生产者和消费者的升级版
   
3. java新特性
   
4. 
   
5. 问题是:
   
6.         private Condition condition_in=lock.newCondition();
   
7.         private Condition condition_out=lock.newCondition();
   
8. 
   
9. 上面两个Condition怎么知道是属于那个线程的呢?好像程序也没有标记那个Condition是属于生产者还是消费者的啊?
   
10. 到底是怎么区分的呢兄弟?
    
11. 
    
12. condition_in.await();等待的是生产者的线程
    
13. condition_out.signal();唤醒消费者的线程
    
14. 
    
15. condition_out.await();等待的是消费者的线程
    
16. condition_in.await();唤醒生产者的线程
    
17. */
    
18. 
    
19. import java.util.concurrent.locks.*;
    
20. class Res3
    
21. {
    
22.         private String name;
    
23.         private String sex;
    
24.         private boolean flag=false;
    
25.         private Lock lock=new ReentrantLock();
    
26. 
    
27.         private Condition condition_in=lock.newCondition();
    
28.         private Condition condition_out=lock.newCondition();
    
29. 
    
30.         public void setRes(String name,String sex)throws InterruptedException
    
31.         {
    
32. 
    
33.                 lock.lock();
    
34. 
    
35.                 //这里写try{}finally{}是为了避免当发生异常的时候,保证可以线程释放锁
    
36.                 try
    
37.                 {
    
38.                 while(flag)
    
39. 
    
40.                 //让生产者wait
    
41.                    condition_in.await();
    
42.                 this.name=name;
    
43.                 this.sex=sex;
    
44.                 System.out.println(Thread.currentThread().getName()+"生产者"+name+"..."+sex);
    
45. 
    
46.                 flag=true;
    
47.                 //这里用notifyAll唤醒所有线程,避免唤醒的是本方线程,注意如果用notify,它唤醒的是进入线程       
    
48. 
    
49.         池中的第一个线程,有可能唤醒的是本方线程,造成所有的线程都在等待               
    
50. 
    
51.                 //叫醒消费者
    
52.                 condition_out.signal();
    
53.                 }
    
54. 
    
55.                 finally
    
56.                 {
    
57.                         lock.unlock();
    
58.                 }
    
59.         }
    
60. 
    
61.         public void getRes()throws InterruptedException
    
62.         {
    
63. 
    
64.                 lock.lock();
    
65.                 try
    
66.                 {
    
67.                 //当flag为false时消费者就等待,否则就消费
    
68.                 while(!flag)
    
69.                   condition_out.await();
    
70. 
    
71.                 System.out.println(Thread.currentThread().getName()+"消费者"+name+"-----"+sex);
    
72.                 flag=false;
    
73.                 condition_in.signal();
    
74.                 }
    
75. 
    
76.                 finally
    
77.                 {
    
78.                         lock.unlock();
    
79.                 }
    
80.         }
    
81. }
    
82. 
    
83. class Input3 implements Runnable
    
84. {
    
85. 
    
86.         private Res3 r;
    
87.         Input3(Res3 r)
    
88.         {
    
89.                 this.r=r;
    
90.         }
    
91. 
    
92.         public void run()
    
93.         {
    
94.                 int x=0;
    
95.                 while(true)
    
96.                 {
    
97.                         if(x==0)
    
98.                         {
    
99.                                
    
100.                                 try{r.setRes("mike","man");}catch(Exception e){}
     
101.                         }
     
102. 
     
103.                         try{r.setRes("丽丽","女");}catch(Exception e){}
     
104.                         x=(x+1)%2;
     
105.                 }
     
106.         }       
     
107. }
     
108. 
     
109. class Output3 implements Runnable
     
110. {
     
111.         private Res3 r;
     
112.         Output3(Res3 r)
     
113.         {
     
114.                 this.r=r;
     
115.         }
     
116. 
     
117.         public void run()
     
118.         {
     
119.                 while(true)
     
120.                 try{r.getRes();}catch(Exception e){}
     
121.         }
     
122. }
     
123. 
     
124. class InputOutputDemo3
     
125. {
     
126.         public static void main(String[] args)
     
127.         {
     
128.                 Res3 r=new Res3();
     
129.                 Input3 in=new Input3(r);
     
130.                 Output3 out=new Output3(r);
     
131. 
     
132.                 Thread t1=new Thread(in);
     
133.                 Thread t2=new Thread(in);
     
134. 
     
135.                 Thread t3=new Thread(out);
     
136.                 Thread t4=new Thread(out);
     
137. 
     
138.                 t1.start();
     
139.                 t2.start();
     
140.                 t3.start();
     
141.                 t4.start();
     
142.         }
     
143. }

复制代码

这个不用标记的 就是两个变量
生产者中用condition_out.signal();唤醒消费者，是因为消费者中用condition_out.await();等待的
同理 ：消费者中用condition_in.signal();唤醒生产者，是因为生产者中是用condition_in.await();等待的

在变量定义的时候我们事先指定哪一个要在生产者里面用哪一个要在消费者中用，所以起个名字。如果你两两进行交换一样可以的

"上面两个Condition怎么知道是属于那个线程的呢?"
个人理解：其实应该说是哪个线程属于某个condition，
condition 处于哪个线程中，则该线程就属于哪个condition；
例如：某一线程执行到condition_xx.await();则该线程就属于condition_xx

condition_in.await();  这个地方就是监视器特有的方法。满足条件，线程就冻结（相当于一个监视器设定了一个线程池，一个监视器冻结的方法只放在对应的线程池中）
   condition_in.signal();
condition_out.signal();
这两个唤醒的肯定不是一个线程。

上面两个Condition怎么知道是属于那个线程的呢?"
这个是在你创建线程的时候自己传给线程的
定义的线程应该是这样的Threa t=new Thread(out）;
Threa t=new Thread（in）;这样就这道了哪个线程该等待，哪个该唤醒了。。。。

郭军亮 发表于 2013-5-17 22:42
上面两个Condition怎么知道是属于那个线程的呢?"
这个是在你创建线程的时候自己传给线程的
定义的线程应该 ...

如果没有传进去,该怎么区分呢哥们,视频里没有传进去的