大家帮我看下，我这个为什么一运行什么也不出呢，死循环了吗？
另外我这个  之前用synchronized 的时候 也没看到 生产1个 消费2个的情况啊？跟电脑配置有关么？
已解决，谢谢大家了，已经改完了的代码贴出来了

1. package day11;
   
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 Resource2{
   
8.         private String name;
   
9.         private int count = 1;
   
10.         private boolean flag = false;
    
11.         private final Lock lock = new ReentrantLock();
    
12.         private final Condition condition_pro = lock.newCondition();
    
13.         private final Condition condition_con = lock.newCondition();
    
14.        
    
15.         public void set(String name) throws InterruptedException{
    
16.                 lock.lock();
    
17.                 try{
    
18.                         while(flag)
    
19.                                 condition_pro.await();
    
20.                                 this.name = name+"--"+count++;
    
21.                                 System.out.println(Thread.currentThread().getName()+"......生产者....."+this.name);
    
22.                                 flag = true;
    
23.                                 condition_con.signal();
    
24.                         }       
    
25.                         finally{
    
26.                         lock.unlock();
    
27.                 }
    
28.                
    
29.         }
    
30.         public void out() throws InterruptedException{
    
31.                 lock.lock();
    
32.                 try {
    
33.                                 while(!flag)
    
34.                                         condition_con.await();
    
35.                                         System.out.println(Thread.currentThread().getName()+"消费者--"+this.name);
    
36.                                         flag = false;
    
37.                                         condition_pro.signal();
    
38.                         }
    
39.                 finally{
    
40.                         lock.unlock();
    
41.                 }
    
42.                
    
43.         }
    
44. }
    
45. class Producer2 implements Runnable{
    
46.         private Resource2 res;
    
47.         Producer2(Resource2 res){
    
48.                 this.res = res;
    
49.         }
    
50.         public void run(){
    
51.                 while(true){
    
52.                         try{
    
53.                                 res.set("商品");
    
54.                         }
    
55.                         catch (Exception e) {
    
56.                        
    
57.                         }
    
58.                 }
    
59.         }
    
60. }
    
61. class Consumer2 implements Runnable{
    
62.         private Resource2 res;
    
63.         Consumer2(Resource2 res){
    
64.                 this.res = res;
    
65.         }
    
66.         public void run(){
    
67.                 while(true){
    
68.                        
    
69.                         try{
    
70.                                 res.out();
    
71.                         }
    
72.                         catch(Exception e){
    
73.                                
    
74.                         }
    
75.                         }
    
76.         }
    
77. }
    
78. public class ProducerConsumerDemo2 {
    
79. 
    
80.         /**
    
81.          * @param args
    
82.          */
    
83.         public static void main(String[] args) {
    
84.                 // TODO Auto-generated method stub
    
85.                 Resource2 res = new Resource2();
    
86.                
    
87.                 Producer2 pro = new Producer2(res);
    
88.                 Consumer2 con = new Consumer2(res);
    
89.                
    
90.                 Thread t1 = new Thread(pro);
    
91.                 Thread t2 = new Thread(pro);
    
92.                 Thread t3 = new Thread(con);
    
93.                 Thread t4 = new Thread(con);
    
94.                
    
95.                 t1.start();
    
96.                 t2.start();
    
97.                 t3.start();
    
98.                 t4.start();
    
99.         }
    
100. 
     
101. }
     

复制代码

你把其中的while(flag) 换成if就会出现
生产一个 消费两次 或者 生产两次消费一次

public synchronized void set(String name) throws InterruptedException{    //去掉 synchronized

你这个是用jdk1.5以后的锁来解决的，所以不能再在方法上写synchronized 。去掉set方法和out方法上的synchronized 关键字。
还有   condition_con.signalAll(); 应该是   condition_con.signal(); 你只要对方的监视器唤醒一个线程就行了。不需要全部唤醒。消费者线程上的一样也要改

你那个condition_con.signalAll();和condition_pro.signalAll();中只需要唤醒对方就行了，唤醒全部的话就可能是你的那种情况了。你再试试吧
建议楼主把代码添加入代码框中。方便赋值和阅读

沈浩 发表于 2013-4-17 16:49
public synchronized void set(String name) throws InterruptedException{    //去掉 synchronized

兄弟你说的太对了

谭威 发表于 2013-4-17 23:49
你这个是用jdk1.5以后的锁来解决的，所以不能再在方法上写synchronized 。去掉set方法和out方法上的synchro ...

收到，谢谢

黄玉昆 发表于 2013-4-18 08:34
你那个condition_con.signalAll();和condition_pro.signalAll();中只需要唤醒对方就行了，唤醒全部的话就可 ...

收到老师，我一定注意