下面的代码中有两个对象
Condition con1=lo.newCondition();//con1是指哪些线程？  如何区分？
Condition con2=lo.newCondition();//con2是指哪些线程？  如何区分？
如注释所示，  如何进行区分？con1.await()到底停下的是哪些线程？
con1.signal()到底开启的是哪些线程？

1. import java.util.concurrent.locks.*;
   
2. class Start
   
3. {
   
4.         boolean flag=true;
   
5.         int x;
   
6.         Lock lo=new ReentrantLock();
   
7.         Condition con1=lo.newCondition();//con1是指哪些线程？  如何区分？
   
8.         Condition con2=lo.newCondition();//con2是指哪些线程？  如何区分？
   
9.         public void kaishi()
   
10.         {
    
11.                 while(true)
    
12.                 {
    
13.                         lo.lock();
    
14.                         while(!flag)
    
15.                         {
    
16.                                 try {con1.await();} catch (InterruptedException e) {e.printStackTrace();}
    
17.                         }
    
18.                         System.out.println("开始  " +x++);
    
19.                         flag=false;
    
20.                         con2.signal();
    
21.                         lo.unlock();
    
22.                 }
    
23.         }
    
24.         public void jieshu()
    
25.         {
    
26.                 while (true)
    
27.                 {
    
28.                         
    
29.                         lo.lock();
    
30.                         while(flag)
    
31.                         {
    
32.                                 try {con2.await();} catch (InterruptedException e) {e.printStackTrace();}
    
33.                         }
    
34.                         System.out.println("结束----" +x);
    
35.                         flag=true;
    
36.                         con1.signal();
    
37.                         lo.unlock();
    
38.                 }
    
39.                
    
40.         }
    
41. }
    
42. class A implements Runnable
    
43. {
    
44.         Start huan;
    
45.         A(Start a)
    
46.         {
    
47.                 this.huan=a;
    
48.         }
    
49.         public void run()
    
50.         {
    
51.                 huan.kaishi();
    
52.         }
    
53. }
    
54. class B implements Runnable
    
55. {
    
56.         Start huan;
    
57.         B(Start a)
    
58.         {
    
59.                 this.huan=a;
    
60.         }
    
61.         public void run()
    
62.         {
    
63.                 huan.jieshu();
    
64.         }
    
65. }
    
66. 
    
67. 
    
68. 
    
69. class Demo2
    
70. {
    
71.         public static void main(String args[])
    
72.         {
    
73.                 Start s=new Start();
    
74.                 new Thread(new A(s)).start();
    
75.                 new Thread(new A(s)).start();
    
76.                 new Thread(new B(s)).start();
    
77.                 new Thread(new B(s)).start();
    
78.         }
    
79. }
    

复制代码

Condition con1=lo.newCondition();//con1是指哪些线程？  如何区分？
Condition con2=lo.newCondition();//con2是指哪些线程？  如何区分？
con1  con2 这个都是可以自己指定的。但是，con1 指定的是买票的，那么con2 就是卖票的线程。
假若用con2.await()指定买票线程等待，那么con1.single就是唤醒 con1 买票线程。
假若用con1.await 指定卖票线程等待，那么con2.single 就是唤醒con2 买票线程。

skill20 发表于 2014-4-29 17:38
Condition con1=lo.newCondition();//con1是指哪些线程？  如何区分？
Condition con2=lo.newCondition();/ ...

我没有在程序中指定吧？  还是不怎么明白。。。能告诉我con1和con2分别是代表哪些线程吗？

张然龙 发表于 2014-4-29 17:45
我没有在程序中指定吧？  还是不怎么明白。。。能告诉我con1和con2分别是代表哪些线程吗？ ...

没代表啊，只是对同时操作买票或卖票的线程用相同的而已，不然会出现买错票的情况。

skill20 发表于 2014-4-29 17:52
没代表啊，只是对同时操作买票或卖票的线程用相同的而已，不然会出现买错票的情况。 ...

  con1 和con2没有指定？不能把   那我为什么写反了就锁上了？  既然锁上了，就肯定有指定的啊？。。疑惑中。。还望大哥解答下。。。

哎 。。。就没人告诉我答案么。。。要对程序有一种探索精神和钻研精神。。多么好的研究课题。。大家都来研究下啊。。。

1. <p>这位同学，你好。愿意跟你交流一下，首先如果我没有看错的话，这部分的代码应该是毕老师多线程中“生产者与消费者小例子”一样效果的。</p><p>首先这部分代码的功能应该是：</p><p>（1）创建了四个线程对start类中的x元素进行+1和打印的效果。两个线程一块+1，两个线程一块打印。</p><p>（2）con1，con2并不是指的线程，给你纠正一下。</p><p>（3）你的代码运行结果出现了混乱，截图如下，我给你修改了一下。见下面，效果截图如下。</p><p>（4）Lock:替代了Synchronized  : lock (),unlock() ,newCondition()
   
2. Condition：替代了Object wait notify notifyAll  await();signal();signalAll();
   
3. 我们可以这样理解：首先 .当程序跑起来后程序中建立了四个线程。比如是线程1，线程2，线程3，线程4，前两个线程要执行+1的功能实现，后两个线程要执行打印x功能的实现。同时，你给+1功能和打印x功能各上了锁，就是你用的lock。在各自的lock中为两个lock分别绑定了两个condition，它们是con1,con2。这样子就可以保证线程1，线程2进入第一个lock后，也就是你的KAISHI功能模块中后它们共同拥有了con1,线程3和线程4进入第二个锁之后，也就是你的JIESHU功能模块中，给它们两个分配了con2.这么做的目的主要就是Condition的功能所要实现的意义，它可以保证实现不同功能的多个线程分组。在await()和signal()时更明确，而不至于引起混乱。这是我的理解。下面我把运行截图给你发上。
   
4. 
   
5. import java.util.concurrent.locks.*;
   
6. class Start
   
7. {      String x_name;
   
8.         boolean flag=true;
   
9.         int x=1;
   
10.         Lock lo=new ReentrantLock();
    
11.         Condition con1=lo.newCondition();//con1是指哪些线程？  如何区分？
    
12.         Condition con2=lo.newCondition();//con2是指哪些线程？  如何区分？
    
13.         public void kaishi(String name)
    
14.         {
    
15.                 while(true)
    
16.                 {
    
17.                         lo.lock();
    
18.                         while(!flag)
    
19.                         {
    
20.                                 try {con1.await();} catch (InterruptedException e) {e.printStackTrace();}
    
21.                         }
    
22.                         this.x_name=name+"--"+x++;
    
23.                         System.out.println("开始  " +this.x_name);
    
24.                         flag=false;
    
25.                         con2.signal();
    
26.                         lo.unlock();
    
27.                 }
    
28.         }
    
29.         public void jieshu()
    
30.         {
    
31.                 while (true)
    
32.                 {
    
33.                         
    
34.                         lo.lock();
    
35.                         while(flag)
    
36.                         {
    
37.                                 try {con2.await();} catch (InterruptedException e) {e.printStackTrace();}
    
38.                         }
    
39.                         System.out.println("结束----" +this.x_name);
    
40.                         flag=true;
    
41.                         con1.signal();
    
42.                         lo.unlock();
    
43.                 }
    
44.                
    
45.         }
    
46. }
    
47. class A implements Runnable
    
48. {
    
49.         Start huan;
    
50.         A(Start a)
    
51.         {
    
52.                 this.huan=a;
    
53.         }
    
54.         public void run()
    
55.         {
    
56.                 huan.kaishi("X 的值是");
    
57.         }
    
58. }
    
59. class B implements Runnable
    
60. {
    
61.         Start huan;
    
62.         B(Start a)
    
63.         {
    
64.                 this.huan=a;
    
65.         }
    
66.         public void run()
    
67.         {
    
68.                 huan.jieshu();
    
69.         }
    
70. }
    
71. class Demo2
    
72. {
    
73.         public static void main(String args[])
    
74.         {
    
75.                 Start s=new Start();
    
76.                 new Thread(new A(s)).start();
    
77.                 new Thread(new A(s)).start();
    
78.                 new Thread(new B(s)).start();
    
79.                 new Thread(new B(s)).start();
    
80.         }
    
81. }
    
82. </p></p></p>

复制代码

好好好好好好好

昨天我又把视频看了两遍 貌似有那么一点了解了。。Condition是不指定具体哪个方法的。大家看看我说得对不对↓
因为有四个线程，当第一个线程挂在con1.await();时挂起释放执行权进入冻结状态 ，如果其他线程读到con1.signal();自动将挂在con1.await();的线程唤醒。


如果有多个同时挂起在con1.await();的线程，则随机唤醒一个。同理 con2的对象也是一样。上边的线程生产商品冻结con1，唤醒con2，下边的的线程生产商品冻结con2，唤醒con1，正好实现了互相交替、互不影响的局面！