这里系统是怎么知道c1为消费者c2为生产者的，我并没有看到Condition 和线程之间的联系，求解答
private Lock lock = new ReentrantLock();
Condition c1 = lock.newCondition();
Condition c2 = lock.newCondition();

1. package heima;
   
2. 
   
3. 
   
4. import java.io.PrintStream;
   
5. import java.util.concurrent.locks.Condition;
   
6. import java.util.concurrent.locks.Lock;
   
7. import java.util.concurrent.locks.ReentrantLock;
   
8. 
   
9. public class IntputOutputDome2 {
   
10. 
    
11.         /**
    
12.          * @param args
    
13.          */
    
14.         public static void main(String[] args) {
    
15.                
    
16.                 Res2 r = new Res2();
    
17.                 Thread t1 = new Thread(new Input2(r));
    
18.                 Thread t2 = new Thread(new Input2(r));
    
19.                 Thread t3 = new Thread(new Output2(r));
    
20.                 Thread t4 = new Thread(new Output2(r));
    
21.                
    
22.                 t1.start();
    
23.                 t2.start();
    
24.                 t3.start();
    
25.                 t4.start();
    
26.         }
    
27. 
    
28. }
    
29. 
    
30. class Res2{
    
31.         private String name;
    
32.         private String sex;
    
33.         private boolean b = false;
    
34.         private Lock lock = new ReentrantLock();
    
35.         Condition c1 = lock.newCondition();
    
36.         Condition c2 = lock.newCondition();
    
37.         PrintStream out = null;
    
38.         public void set(String name,String sex){
    
39.                
    
40.                 System.out.println("当前状态："+b);
    
41.                 lock.lock();//上锁
    
42.                 try {
    
43.                        
    
44.                         while(b){
    
45.                                
    
46.                                 c2.await();
    
47.                                 System.out.println("生产："+Thread.currentThread().getName()+"进入等待");
    
48.                         }
    
49.                         this.name=name;
    
50.                         this.sex=sex;
    
51.                         System.out.println(Thread.currentThread().getName()+"......生产......"+name+"----"+sex);
    
52.                         b = true;
    
53.                         c1.signal();//唤醒其他线程
    
54.                 } catch (Exception e) {
    
55.                        
    
56.                 }
    
57.                 finally{
    
58.                         lock.unlock();//解锁
    
59.                 }
    
60.                
    
61.         }
    
62.        
    
63.         public void out(){
    
64.                
    
65.                 System.out.println("out当前状态："+b);
    
66.                 lock.lock();
    
67.                 try {
    
68.                         while(!b){
    
69.                                 c1.await();
    
70.                                 System.out.println(Thread.currentThread().getName()+"进入等待");
    
71.                         }
    
72.                         System.out.println(Thread.currentThread().getName()+"......消费................."+name +"----"+sex);
    
73.                         b = false;
    
74.                         c2.signal();
    
75.                 } catch (InterruptedException e) {
    
76.                         // TODO Auto-generated catch block
    
77.                         e.printStackTrace();
    
78.                 }
    
79.                
    
80.                 finally{
    
81.                         lock.unlock();
    
82.                        
    
83.                 }
    
84.         }
    
85. }
    
86. 
    
87. class Input2 implements Runnable{
    
88. 
    
89.        
    
90.         Res2 r;
    
91.         public Input2(Res2 r){
    
92.                 this.r=r;
    
93.         }
    
94.         public void run() {
    
95.                 int x = 0;
    
96.                 while(true){
    
97.                         if(x==0){
    
98.                                 r.set("张三", "男");
    
99.                         }
    
100.                         else{
     
101.                                
     
102.                                 r.set("李四", "女");
     
103.                         }
     
104.                         x = (x+1)%2;
     
105.                 }
     
106.                
     
107.         }
     
108.        
     
109.        
     
110.        
     
111. }
     
112. 
     
113. class Output2 implements Runnable{
     
114. 
     
115.         Res2 r;
     
116.         public Output2(Res2 r){
     
117.                 this.r=r;
     
118.         }
     
119.         public void run() {
     
120.                
     
121.                 while(true){
     
122.                        
     
123.                         r.out();
     
124.                        
     
125.                 }
     
126.                
     
127.         }
     
128.        
     
129.        
     
130.        
     
131. }
     
132. 
     
133. 
     
134. 
     

复制代码

Condition对c1、c2和生产者、消费者线程没有什么必然的联系。从程序的运行过程来看，当每个生产者运行通过，就唤醒进入睡眠的消费者线程。当每个消费者运行通过，就唤醒进入睡眠的生产者线程。这及防治了所有线程进入睡眠，又可以唤醒在程序运行过程中，想要唤醒的线程！

zhaozhao 发表于 2014-12-18 22:20
Condition对c1、c2和生产者、消费者线程没有什么必然的联系。从程序的运行过程来看，当每个生产者运行通过 ...

当每个生产者运行通过

什么意思？我把c1,c2对换一下，但是不影响结果，就是这里没明白，程序怎么判断出c1和c2的是属于消费者和生产者的

可以理解为一个标记，线程1执行c1.await()时，就好像给线程1挂了个c1的标签，同时进入冻结状态，当其他线程执行c1.signal()时，就唤醒了线程1。这样就可以实现有针对性的唤醒，而不是像notifyAll()那样必须唤醒全部。

李天富 发表于 2014-12-18 23:24
可以理解为一个标记，线程1执行c1.await()时，就好像给线程1挂了个c1的标签，同时进入冻结状态，当其他线程 ...

我之前也这么想过，就是不知道对不对