我写的代码，运行后先有消费，再有生产，哪出问题了？看了半天没找出来

1. import java.util.concurrent.locks.Condition;
   
2. import java.util.concurrent.locks.Lock;
   
3. import java.util.concurrent.locks.ReentrantLock;
   
4. 
   
5. public class TestEveryDay {
   
6.         public static void main(String[] args) {
   
7.                 Res r=new Res();
   
8.                 Producer pro=new Producer(r);
   
9.                 Consume com=new Consume(r);
   
10.                
    
11.                 new Thread(pro).start();
    
12.                 new Thread(com).start();
    
13.         }
    
14. }
    
15. class Res{
    
16.         private String name;
    
17.         private int num=1;
    
18.         private boolean flag=false;
    
19.         private Lock lock=new ReentrantLock();
    
20.         private Condition condition_pro=lock.newCondition();
    
21.         private Condition condition_con=lock.newCondition();
    
22.         
    
23.         public void set(String name) throws InterruptedException{
    
24.                 lock.lock();               
    
25.                 try {
    
26.                         while(flag)
    
27.                                 condition_pro.await();
    
28.                         this.name=name;
    
29.                         System.out.println(Thread.currentThread().getName()+":生产者："+name+num++);
    
30.                         flag=true;
    
31.                         condition_con.signal();
    
32.                 } finally{
    
33.                         lock.unlock();
    
34.                 }               
    
35.         }
    
36.         public void out() throws InterruptedException{
    
37.                 lock.lock();
    
38.                 try{
    
39.                         while(!flag)
    
40.                                 condition_con.await();
    
41.                         System.out.println(Thread.currentThread().getName()+":消费者...."+name+num);
    
42.                         flag=false;
    
43.                         condition_pro.signal();
    
44.                 }finally{
    
45.                         lock.unlock();
    
46.                 }        
    
47.         }
    
48.         
    
49. }
    
50. class Producer implements Runnable{
    
51.         private Res r;
    
52.         public Producer(Res r){
    
53.                 this.r=r;
    
54.         }
    
55.         public void run() {
    
56.                 while(true){
    
57.                         try {
    
58.                                 r.set("商品");
    
59.                         } catch (InterruptedException e) {
    
60.                                 e.printStackTrace();
    
61.                         }
    
62.                 }
    
63.         }        
    
64. }
    
65. 
    
66. class Consume implements Runnable{
    
67.         private Res r;
    
68.         public Consume(Res r){
    
69.                 this.r=r;
    
70.         }
    
71.         public void run() {
    
72.                 while(true){
    
73.                         try {
    
74.                                 r.out();
    
75.                         } catch (InterruptedException e) {
    
76.                                 e.printStackTrace();
    
77.                         }
    
78.                 }
    
79.         }        
    
80. }
    
81. 
    
82. 
    

复制代码

运行结果：
Thread-1:消费者....商品52831
Thread-0:生产者：商品52831
Thread-1:消费者....商品52832
Thread-0:生产者：商品52832

错在这里，你应该先让num生产完了再打印，这样的话就是先打印，再执行++，就是这样，要么把num++放到输出语句前面，要么改成++num

问题已找到。。。
num++ 放在打印里了
所以生产的时候打印是num,
消费的时候打印num+1了。

天黑偷牛 发表于 2014-8-27 20:46
错在这里，你应该先让num生产完了再打印，这样的话就是先打印，再执行++，就是这样，要么把num++放到输出 ...

嗯，你还看得真快。

地狱天堂 发表于 2014-8-27 20:50
嗯，你还看得真快。

碰巧看到，嘿嘿