1. 疑问代码中注释。
   
2. import java.util.concurrent.locks.*;
   
3. 
   
4. class ProducerConsumerDemo2
   
5. {
   
6.         public static void main(String[] args)
   
7.         {
   
8.                 Resource r = new Resource();
   
9. 
   
10.                 Producer pro = new Producer(r);
    
11.                 Consumer con = new Consumer(r);
    
12. 
    
13.                 Thread t1 = new Thread(pro);
    
14.                 Thread t2 = new Thread(pro);
    
15.                 Thread t3 = new Thread(con);
    
16.                 Thread t4 = new Thread(con);
    
17. 
    
18.                 t1.start();
    
19.                 t2.start();
    
20.                 t3.start();
    
21.                 t4.start();
    
22. 
    
23.         }
    
24. }
    
25. 
    
26. class Resource
    
27. {
    
28.         private String name;
    
29.         private int count = 1;
    
30.         private boolean flag = false;
    
31.                         //  t1    t2
    
32.         private Lock lock = new ReentrantLock();//Lock是接口，类ReentrantLock 实现接口Lock ，接口不是不能创建对象吗？？
    
33. 
    
34.         private Condition condition_pro = lock.newCondition();//这两句话不明白，请各位解释一下？？？
    
35.         private Condition condition_con = lock.newCondition();
    
36. 
    
37. 
    
38. 
    
39.         public  void set(String name)throws InterruptedException
    
40.         {
    
41.                 lock.lock();
    
42.                 try
    
43.                 {
    
44.                         while(flag)
    
45.                                 condition_pro.await();//凭什么说condition_pro.await()就指定的是让生产者等待？？？有什么依据？？？
    
46.                         this.name = name+"--"+count++;
    
47. 
    
48.                         System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
    
49.                         flag = true;
    
50.                         condition_con.signal();//凭什么说condition_con.signal() 就指定的是唤醒消费者？？？有什么依据？？？
    
51.                 }
    
52.                 finally
    
53.                 {
    
54.                         lock.unlock();//释放锁的动作一定要执行。
    
55.                 }
    
56.         }
    
57. 
    
58. 
    
59.         //  t3   t4  
    
60.         public  void out()throws InterruptedException
    
61.         {
    
62.                 lock.lock();
    
63.                 try
    
64.                 {
    
65.                         while(!flag)
    
66.                                 condition_con.await();
    
67.                         System.out.println(Thread.currentThread().getName()+"...消费者........."+this.name);
    
68.                         flag = false;
    
69.                         condition_pro.signal();
    
70.                 }
    
71.                 finally
    
72.                 {
    
73.                         lock.unlock();
    
74.                 }
    
75.                
    
76.         }
    
77. }
    
78. 
    
79. class Producer implements Runnable
    
80. {
    
81.         private Resource res;
    
82. 
    
83.         Producer(Resource res)
    
84.         {
    
85.                 this.res = res;
    
86.         }
    
87.         public void run()
    
88.         {
    
89.                 while(true)
    
90.                 {
    
91.                         try
    
92.                         {
    
93.                                 res.set("+商品+");
    
94.                         }
    
95.                         catch (InterruptedException e)
    
96.                         {
    
97.                         }
    
98.                         
    
99.                 }
    
100.         }
     
101. }
     
102. 
     
103. class Consumer implements Runnable
     
104. {
     
105.         private Resource res;
     
106. 
     
107.         Consumer(Resource res)
     
108.         {
     
109.                 this.res = res;
     
110.         }
     
111.         public void run()
     
112.         {
     
113.                 while(true)
     
114.                 {
     
115.                         try
     
116.                         {
     
117.                                 res.out();
     
118.                         }
     
119.                         catch (InterruptedException e)
     
120.                         {
     
121.                         }
     
122.                 }
     
123.         }
     
124. }
     
125. 
     
126. 
     

复制代码

1. class Resource
   
2. {
   
3.         private String name;
   
4.         private int count = 1;
   
5.         private boolean flag = false;
   
6.                         //  t1    t2//类ReentrantLock这个不是接口，可以new
   
7.         private Lock lock = new ReentrantLock();//Lock是接口，类ReentrantLock 实现接口Lock ，接口不是不能创建对象吗？？
   
8.        //把 Condition 对象绑定到一个叫lock锁对象上,API解释：
   
9.     Condition 将 Object 监视器方法（wait、notify 和 notifyAll）分解成截然不同的对象，以便通过将这些对象与任意 Lock 实现组合使用，
   
10.       为每个对象提供多个等待 set（wait-set）。其中，Lock 替代了 synchronized 方法和语句的使用，Condition 替代了 Object 监视器方法的使用。
    
11.       个人理解：当线程在某个condition.await下等待的，他必须由其他线程执行同一个condition的notify,notifyAll才能才唤醒。
    
12.         private Condition condition_pro = lock.newCondition();//这两句话不明白，请各位解释一下？？？
    
13.         private Condition condition_con = lock.newCondition();
    
14. 
    
15. 
    
16. 
    
17.         public  void set(String name)throws InterruptedException
    
18.         {
    
19.                 lock.lock();
    
20.                 try
    
21.                 {
    
22.                         while(flag)//因为这段代码只有生者才执行的啊！消费都好像没有执行这部分代码吧！消费都执行的是下面的那部分代码啊
    
23.                                 condition_pro.await();//凭什么说condition_pro.await()就指定的是让生产者等待？？？有什么依据？？？
    
24.                         this.name = name+"--"+count++;
    
25. 
    
26.                         System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
    
27.                         flag = true;//因为费消都执行了condition_con.await()了，下看面消费者所执行的代码，也就是说消者是在同一个锁condition_con这个条件下等待的
    
28.                         condition_con.signal();//凭什么说condition_con.signal() 就指定的是唤醒消费者？？？有什么依据？？？
    
29.                 }
    
30.                 finally
    
31.                 {
    
32.                         lock.unlock();//释放锁的动作一定要执行。
    
33.                 }
    
34.         }
    
35. 
    
36. 
    
37.         //  t3   t4  
    
38.         public  void out()throws InterruptedException

复制代码

1.Lock是接口，类ReentrantLock实现接口Lock ，接口不是不能创建对象吗？？
答：Lock是接口，不能实例化，但经过实现的话就可以了。既然你知道"类ReentrantLock实现接口Lock" ，就应该明白ReentrantLock是Lock接口的实现类，它实现了接口中那些方法的方法体，而这条语句实例化的是这个实现类，而不是接口本身啦。。

2.

1. private Condition condition_pro = lock.newCondition();     //这两句话不明白，请各位解释一下？？？
   
2.        private Condition condition_con = lock.newCondition();
   
3. /*
   
4. 答：Condition实例实质上是被绑定到一个锁上，要为特定Lock实例获得Condition实例，就需要使用其newCondition()方法。
   
5. 所以就有这样两条语句，意思是创建名为condition_pro和condition_con的Condition实例，并用private声明使其私有化。
   
6. */
   

复制代码

3.

1. try
   
2.                 {
   
3.                         while(flag)
   
4.                                 condition_pro.await();//凭什么说condition_pro.await()就指定的是让生产者等待？？？有什么依据？？？
   
5.                         this.name = name+"--"+count++;
   
6. 
   
7.                         System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
   
8.                         flag = true;
   
9.                         condition_con.signal();//凭什么说condition_con.signal() 就指定的是唤醒消费者？？？有什么依据？？？
   
10.                 }
    
11. /*
    
12. 答：await()方法是这么一个功能：令当前线程在接到信号或被中断之前一直处于等待状态。
    
13.     而signal()方法则是这样的功能：唤醒一个等待线程。
    
14.     这都是Condition接口定义的方法，真要问为什么。。其实我也不知道。。
    
15. */
    

复制代码

这个是貌似是JDK1.5添加的内容，其实就是Synchronized换成Lock，将Object中的wait,notify,notifyAll这些方法换成了Condition里头的await,signal,signalAll.

1、Lock是接口，类ReentrantLock 实现接口Lock ，接口不是不能创建对象吗？
接口不能用于创建实例，但接口可以用于声明引用类型的变量。当使用接口来声明引用类型的变量时，这个引用类型的变量必须是其实现类的对象。也因此有面向接口编程来降低程序的耦合。
private Condition condition_pro = lock.newCondition();
程序不使用synchronized关键字来保证线程同步而使用Lock对象来保证同步，则系统中就不存在隐式的同步监视器对象，也就不能使用wait、notify等方法来协调进程的运行。所以提供了一个Condition类来保持协调。Condition可以代替了同步监视器的功能。此处之所以定义两个是为了更好的协调。如果只定义一个Condition 这样唤醒线程的时候就可能唤醒和自己同类的线程。如当只有一个生产者1运行时其余三者都等待。

1.     {                   while(flag)            
   
2.                                        condition.await();  
   
3.                       this.name = name+"--"+count++;      
   
4. *                    System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);  
   
5.                       flag = true;                     
   
6.                        condition.signal();生产者1此时唤醒生产者2，1循环判断flag是等待，这是2执行判断flag也为true也等待这样四个线程就都等待了。   
   
7. *           }

复制代码

2、而定义两个Condition：condition_pro、condition_con这样生产者1在唤醒其他线程时唤醒的肯定是消费者线程而不是生产者线程。

3、condition_pro.await();凭什么说condition_pro.await()就指定的是让生产者等待？？？有什么依据？？？                     
ondition_con.signal();//凭什么说condition_con.signal() 就指定的是唤醒消费者？？？有什么依据？？？
这就相当于定义了两个数组condition_pro和ondition_con.。
当生产者判断Flag为true时执行condition_pro.await();就相当于把该生产者放入名为condition_pro的数组。当消费者执行condition_pro.signal();时就相当于从名为condition_pro数组中取出生产者。condition_pro和ondition_con.只是一个名字或标签，只是看你在执行await时把该线程存在那个数组中等待或打上相同的标签，这样signal时就可以根据名或者标签来唤醒线程

这个问题在基础视频中应该讲到了，具体是那一天的课程我忘了。你可以再看看。

楼主：如果还有问题，请追问，如果无问题，请结贴，谢谢合作。

猫腻 发表于 2013-3-14 09:38
楼主：如果还有问题，请追问，如果无问题，请结贴，谢谢合作。

回答的加分，怎么提问的没分？？？？唉。。。。