1. package cn.thread;
   
2. 
   
3. import java.util.concurrent.locks.Condition;
   
4. import java.util.concurrent.locks.Lock;
   
5. import java.util.concurrent.locks.ReentrantLock;
   
6. 
   
7. class Res{
   
8.         public String name;
   
9.         public int count = 1;
   
10.         boolean flag = false;
    
11.         Lock lock = new ReentrantLock();
    
12.         Condition conIn = lock.newCondition();
    
13.         Condition conOut = lock.newCondition();
    
14.         public void in(String name){
    
15.                 lock.lock();
    
16.                 try{
    
17.                         while(flag)
    
18.                                 try {
    
19.                                         conIn.await();
    
20.                                 } catch (InterruptedException e) {
    
21.                                         // TODO Auto-generated catch block
    
22.                                         e.printStackTrace();
    
23.                                 }
    
24.                                 this.name = name + count;
    
25.                                 System.out.println(Thread.currentThread().getName()+"生产..."+ this.name);
    
26.                                 count++;
    
27.                                 flag = true;
    
28.                                 conOut.signal();
    
29.                        
    
30.                 }finally{
    
31.                         lock.unlock();
    
32.                 }
    
33.         }
    
34.        
    
35.         public void out(){
    
36.                 lock.lock();
    
37.                 try{
    
38.                         while(!flag)
    
39.                                 try {
    
40.                                         conOut.await();
    
41.                                 } catch (InterruptedException e) {
    
42.                                         // TODO Auto-generated catch block
    
43.                                         e.printStackTrace();
    
44.                                 }
    
45.                                 System.out.println(Thread.currentThread().getName()+"出售......"+this.name);
    
46.                                 flag = false;
    
47.                                 conIn.signal();
    
48.                        
    
49.                 }finally{
    
50.                         lock.unlock();
    
51.                 }
    
52.                
    
53.         }
    
54. }
    
55. 
    
56. class Producer implements Runnable{
    
57.         Res r;
    
58.         public Producer(Res r){
    
59.                 this.r = r;
    
60.         }
    
61.         public void run(){
    
62.                 while(true){
    
63.                         r.in("CX-5-->");
    
64.                 }
    
65.         }
    
66. }
    
67. 
    
68. class Consumer implements Runnable{
    
69.         Res r;
    
70.         public Consumer(Res r){
    
71.                 this.r = r;
    
72.         }
    
73.         public void run(){
    
74.                 while(true){
    
75.                         r.out();
    
76.                 }
    
77.         }
    
78.        
    
79. }
    
80. public class ProducerConsumer {
    
81.         public static void main(String[] args) {
    
82.                 Res r = new Res();
    
83.                 Producer p = new Producer(r);
    
84.                 Consumer c = new Consumer(r);
    
85.                 Thread t1 = new Thread(p);
    
86.                 Thread t2 = new Thread(p);
    
87.                 Thread t3 = new Thread(c);
    
88.                 Thread t4 = new Thread(c);
    
89.                 t1.start();
    
90.                 t2.start();
    
91.                 t3.start();
    
92.                 t4.start();
    
93.         }
    
94. 
    
95. }
    

复制代码

在while中的标记位flag是怎么判断的?
我的理解是:flag的默认是false的,这个时候没有东西在,这个时候生产东西,生产好了就false变ture,说明有东西了
然后到消费,while中的!flag是false,那这样不就是下面消费的代码执行不到了?这里我卡住了,求解答

1. ①while(!flag)
   
2.                                 try {
   
3.                                         conOut.await();
   
4.                                 } catch (InterruptedException e) {
   
5.                                         // TODO Auto-generated catch block
   
6.                                         e.printStackTrace();
   
7.                                 }
   
8. ②System.out.println(Thread.currentThread().getName()+"出售......"+this.name);
   
9.                                 flag = false;
   
10.                                 conIn.signal();

复制代码

我有截取部分代码，请注意我标注的两个地方，当①处为false,while循环不执行，但是会接着执行下面的语句，如我②处标示的位置，
因为上面有生产，生产后flag变TRUE，这个时候就只能消费（在代码中是以输出体现的），所以，要跳过while循环，直接读输出语句。
消费后（输出后）flag会变成FALSE，这个时候，如果还是此线程继续执行，就会读到while（！flag）循环，此时，！flag为TRUE，则会
运行循环中的代码，让此线程await（）。这样楼主能明白了吧:)

到消费,while中的!flag是false,那这样不就是下面消费的代码执行不到了?
不是的,while后面没有花括号,while循环范围只有try catch,正是因为不try await,才执行到了下面的消费代码

楼上正解，注意while后面没有括号，while的循环体只有try catch 部分

尘埃落定 发表于 2014-8-4 08:57
我有截取部分代码，请注意我标注的两个地方，当①处为false,while循环不执行，但是会接着执行下面的语句 ...

binggo,我在while循环中,哪部分是循环体,没有弄明白,这下明白了,谢谢哈

多线程还没学到，。。。。。