写的代码输出和期望 的刚好相反，分析了半天也没看出哪里错了 求高手分析一下

1. import java.util.concurrent.locks.*;
   
2. class ThreadDemo5
   
3. {
   
4. public static void main(String[] args)
   
5. {
   
6. Resource r=new Resource();
   
7. Producer p=new Producer(r);
   
8. Customer c=new Customer(r);
   
9. new Thread(p,"生产者NO.1").start();
   
10. new Thread(p,"生产者NO.2").start();
    
11. new Thread(c,"消费者NO.1").start();
    
12. new Thread(c,"消费者NO.2").start();
    
13. }
    
14. }
    
15. class Resource
    
16. {
    
17. private String name;
    
18. private int count=1;
    
19. private boolean flags=false;
    
20. private Lock lock=new ReentrantLock();
    
21. private Condition condition_Pro =lock.newCondition();
    
22. private Condition condition_Cus=lock.newCondition();
    
23. public void set(String name)throws InterruptedException
    
24. {
    
25. lock.lock();
    
26. this.name=name+"----"+count++;
    
27. try
    
28. {
    
29. while(flags)
    
30. condition_Pro.await();
    
31. System.out.println(Thread.currentThread().getName()+"...生产了..."+this.name);
    
32. flags=true;
    
33. condition_Cus.signal();
    
34. }
    
35. finally
    
36. {
    
37. lock.unlock();
    
38. }
    
39. 
    
40. }
    
41. public void get()throws InterruptedException
    
42. {
    
43. lock.lock();
    
44. try
    
45. {
    
46. while(!flags)
    
47. condition_Cus.await();
    
48. System.out.println(Thread.currentThread().getName()+"......消费了......"+this.name);
    
49. flags=false;
    
50. condition_Pro.signal();
    
51. }
    
52. finally
    
53. {
    
54. lock.unlock();
    
55. }
    
56. 
    
57. }
    
58. }
    
59. class Producer implements Runnable
    
60. {
    
61. private Resource r;
    
62. Producer(Resource r)
    
63. {
    
64. this.r=r;
    
65. }
    
66. public void run()
    
67. {
    
68. while (true)
    
69. {
    
70. try
    
71. {
    
72. r.set("商品");
    
73. }
    
74. catch (InterruptedException e)
    
75. {
    
76. e.printStackTrace();
    
77. }
    
78. }
    
79. }
    
80. 
    
81. }
    
82. class Customer implements Runnable
    
83. {
    
84. private Resource r;
    
85. Customer(Resource r)
    
86. {
    
87. this.r=r;
    
88. }
    
89. public void run()
    
90. {
    
91. while(true)
    
92. {
    
93. try
    
94. {
    
95. r.get();
    
96. }
    
97. catch (InterruptedException e)
    
98. {
    
99. e.printStackTrace();
    
100. }
     
101. }
     
102. 
     
103. }
     
104. }

复制代码

我在上面的代码中做了修改和添加了注释说明！问题应该就清楚。

1. import java.util.concurrent.locks.*;
   
2. 
   
3. class ThreadDemo5 {
   
4.         public static void main(String[] args) {
   
5.                 Resource r = new Resource();
   
6.                 Producer p = new Producer(r);
   
7.                 Customer c = new Customer(r);
   
8.                 new Thread(p, "生产者NO.1").start();
   
9.                 new Thread(p, "生产者NO.2").start();
   
10.                 new Thread(c, "消费者NO.1").start();
    
11.                 new Thread(c, "消费者NO.2").start();
    
12.         }
    
13. }
    
14. 
    
15. class Resource {
    
16.         private String name;
    
17.         private int count = 1;
    
18.         private boolean flags = false;//false 没有商品   true 有商品
    
19.                                                                                
    
20.         private Lock lock = new ReentrantLock();
    
21.         private Condition condition_Pro = lock.newCondition();
    
22.         private Condition condition_Cus = lock.newCondition();
    
23.        
    
24.         public void set(String name) throws InterruptedException {
    
25.                 lock.lock();
    
26. //                this.name = name + "----" + count++;
    
27.                 try {
    
28.                         while (flags) // 有商品就等待
    
29.                                 condition_Pro.await();
    
30.                         // 应该等到没有商品再做生产，而不是在上面没有判断有没有商品前就生产了
    
31.                         this.name = name + "----" + count++;
    
32.                        
    
33.                         System.out.println(Thread.currentThread().getName() + "...生产了..."
    
34.                                         + this.name);
    
35.                         flags = true;// 设置成有商品就等待
    
36.                         condition_Cus.signal();
    
37.                 } finally {
    
38.                         lock.unlock();
    
39.                 }
    
40. 
    
41.         }
    
42. 
    
43.         public void get() throws InterruptedException {
    
44.                 lock.lock();
    
45.                 try {
    
46.                         while (!flags) // 没有商品就等待
    
47.                                 condition_Cus.await();
    
48.                         System.out.println(Thread.currentThread().getName()
    
49.                                         + "......消费了......" + this.name);
    
50.                         flags = false; // 消费完成
    
51.                         condition_Pro.signal();
    
52.                 } finally {
    
53.                         lock.unlock();
    
54.                 }
    
55. 
    
56.         }
    
57. }
    
58. 
    
59. class Producer implements Runnable {
    
60.         private Resource r;
    
61. 
    
62.         Producer(Resource r) {
    
63.                 this.r = r;
    
64.         }
    
65. 
    
66.         public void run() {
    
67.                 while (true) {
    
68.                         try {
    
69.                                 r.set("商品");
    
70.                         } catch (InterruptedException e) {
    
71.                                 e.printStackTrace();
    
72.                         }
    
73.                 }
    
74.         }
    
75. 
    
76. }
    
77. 
    
78. class Customer implements Runnable {
    
79.         private Resource r;
    
80. 
    
81.         Customer(Resource r) {
    
82.                 this.r = r;
    
83.         }
    
84. 
    
85.         public void run() {
    
86.                 while (true) {
    
87.                         try {
    
88.                                 r.get();
    
89.                         } catch (InterruptedException e) {
    
90.                                 e.printStackTrace();
    
91.                         }
    
92.                 }
    
93. 
    
94.         }
    
95. }
    

复制代码

孙峰 发表于 2012-6-16 12:41
你也自己运行下试试再往上放，这不还是原代码

刚才放错了，现在改过来了

李盼 发表于 2012-6-16 12:19
import java.util.concurrent.locks.*;
class ThreadDemo5{
        public static void main(String[] args)

你也自己运行下试试再往上放，这不还是原代码

import java.util.concurrent.locks.*;
class ThreadDemo5{
        public static void main(String[] args)
        {
                Resource r=new Resource();
                Producer p=new Producer(r);
                Customer c=new Customer(r);
                new Thread(p,"生产者NO.1").start();
                new Thread(p,"生产者NO.2").start();
                new Thread(c,"消费者NO.1").start();
                new Thread(c,"消费者NO.2").start();
        }
}

class Resource{
        private String name;
        private int count=1;
        private boolean flags=false;
        private Lock lock=new ReentrantLock();
        private Condition condition_Pro =lock.newCondition();
        private Condition condition_Cus=lock.newCondition();
        public void set(String name)throws InterruptedException
        {
                lock.lock();
                //       this.name=name+"----"+count++;  这句放在这里不妥，因为这次是真正的生成，下面只是打印。如果值为ture，下面执行到while语句，进程就会休息，
               //但是此时count已经增加了，this.name已经改变了，东西已经被生成出来了，只是没有打印，那么消费者拿到线程后，就把它打印出来了，然后消费者休息，这个线程苏
            //醒，是从上次停止的地方开始执行，那么就是下面直接打印了，这就造成了显示效果的错误
                try
                {
                        while(flags)
                        
                        condition_Pro.await();

                         this.name=name+"----"+count++;
                        System.out.println(Thread.currentThread().getName()+"...生产了..."+this.name);
                        
                        flags=true;
                        condition_Cus.signal();
                        
                }
                finally
                {
                        lock.unlock();
                }
        }
        public void get()throws InterruptedException{
                lock.lock();
                try
                {
                        while(!flags)
                        
                        condition_Cus.await();
                        System.out.println(Thread.currentThread().getName()+"......消费了......"+this.name);
                        
                        flags=false;
                        condition_Pro.signal();
                        
                }
                finally
                {
                        lock.unlock();
                }
        }
}

class Producer implements Runnable{
        private Resource r;         
        Producer(Resource r)         
        {         
                this.r=r;         
        }         
        public void run()         
        {         
                while (true)         
        {         
        try         
        {         
                r.set("商品");         
        }         
        catch (InterruptedException e)         
        {         
                e.printStackTrace();         
        }         
        }
         
        }
}

class Customer implements Runnable {
        private Resource r;
        Customer(Resource r)
        {
                this.r=r;
        }
        public void run()
        {
                while(true)
                {
                        try
                        {
                                r.get();
                        }
                        catch (InterruptedException e)
                        {
                                e.printStackTrace();
                        }
                }
        }
}


还有强烈鄙视楼主的代码不按格式来，读的太痛苦了！

Forever。 发表于 2012-6-16 11:48
您的意思是不是生产者1对应消费者1？？

消费者NO.1......消费了......商品----3495
生产者NO.2...生产了...商品----3495
消费者NO.2......消费了......商品----3496
生产者NO.1...生产了...商品----3496
消费者NO.1......消费了......商品----3497
生产者NO.2...生产了...商品----3497
消费者NO.2......消费了......商品----3498
生产者NO.1...生产了...商品----3498
消费者NO.1......消费了......商品----3499
生产者NO.2...生产了...商品----3499

先消费了 后生产

您的意思是不是生产者1对应消费者1？？