请问下面的代码为什么只有2个线程在打印其它线程怎么都停在那里不输出了呢
public class ProducerConsumerDemo2
{
public static void main(String[] args)
{
  Resource r=new Resource();

  Producer pro=new Producer(r);
  Consumer con=new Consumer(r);

  Thread t1=new Thread(pro);
  Thread t2=new Thread(pro);
  Thread t3=new Thread(con);
  Thread t4=new Thread(con);

  t1.start();
  t2.start();
  t3.start();
  t4.start();
}
}

class Resource
{
private String name;
private int count=1;
private boolean flag;

//创建锁
Lock lock=new ReentrantLock();

//通过锁对象创建2组监视器对象，分别用于监视生产者和消费者
Condition producer_con=lock.newCondition();
Condition consumer_con=lock.newCondition();

public synchronized void set(String name)
{
  lock.lock();
  try
  {
   while(flag)
    try{producer_con.await();}catch(InterruptedException e){}

   this.name=name+(count++);
   System.out.println(Thread.currentThread().getName()+"....生产"+this.name);
   flag=true;

   consumer_con.signal();
  }
  finally
  {
   lock.unlock();
  }
}

public synchronized void out()
{
  lock.lock();
  try
  {
   while(!flag)
    try{consumer_con.await();}catch(InterruptedException e){}
   
   System.out.println(Thread.currentThread().getName()+"*************消费"+this.name);
   flag=false;
   producer_con.signal();
  }
  finally
  {
   lock.unlock();
  }
}
}

class Producer implements Runnable
{
private Resource r;
Producer(Resource r)
{
  this.r=r;
}

public void run()
{
  while(true)
  {
   r.set("商品");
  }
}
}

class Consumer implements Runnable
{
private Resource r;
Consumer(Resource r)
{
  this.r=r;
}

public void run()
{
  while(true)
  {
   r.out();
  }
}
}

真心纠结的问题啊，不过找到问题了：

Resource类中，public synchronized void set(String name) 方法中：
producer_con.await();//这一句。

当线程Thread-0执行到这一句时，此线程拿着此方法的锁this，处于等待状态。
（API文档：
void await()
           throws InterruptedException造成当前线程在接到信号或被中断之前一直处于等待状态。）

此时如果Thread-1执行到public synchronized void set(String name) 方法。
this锁被Thread-0拿着，没有线程执行consumer_con.signal();语句。Thread-0冻结状态，Thread-1进不来方法。。。

同样的Thread-2、Thread-3也发生这种情况，造成死锁，所以程序就卡在这里了。

以下是测试代码：

1. 
   
2. import java.util.concurrent.locks.Condition;
   
3. import java.util.concurrent.locks.Lock;
   
4. import java.util.concurrent.locks.ReentrantLock;
   
5. 
   
6. //请问下面的代码为什么只有2个线程在打印其它线程怎么都停在那里不输出了呢
   
7. public class ProducerConsumerDemo2 {
   
8.         public static void main(String[] args) {
   
9.                 Resource r = new Resource();
   
10. 
    
11.                 Producer pro = new Producer(r);
    
12.                 Consumer con = new Consumer(r);
    
13. 
    
14.                 //只测试t1、t2构成的死锁。也可以同时测t3、t4.
    
15.                 Thread t1 = new Thread(pro);
    
16.                 Thread t2 = new Thread(pro);
    
17.                 //Thread t3 = new Thread(con);
    
18.                 //Thread t4 = new Thread(con);
    
19. 
    
20.                 t1.start();
    
21.                 t2.start();
    
22.                 //t3.start();
    
23.         //        t4.start();
    
24.         }
    
25. }
    
26. 
    
27. class Resource {
    
28.         static int p=0;//此静态变量用于监视执行顺序。
    
29.         private String name;
    
30.         private int count = 1;
    
31.         private boolean flag;
    
32. 
    
33.         // 创建锁
    
34.         Lock lock = new ReentrantLock();
    
35. 
    
36.         // 通过锁对象创建2组监视器对象，分别用于监视生产者和消费者
    
37.         Condition producer_con = lock.newCondition();
    
38.         Condition consumer_con = lock.newCondition();
    
39. 
    
40.         public synchronized void set(String name) {
    
41.                 lock.lock();
    
42.                 System.out.println(Thread.currentThread().getName() +"---set-上--"+Resource.p+++"---"+flag);//监视
    
43.                 try {
    
44.                         while (flag)
    
45.                                 try {
    
46.                                         System.out.println(Thread.currentThread().getName() +"---set---"+Resource.p+++"---"+flag);//监视
    
47.                                         producer_con.await();
    
48.                                         System.out.println(Thread.currentThread().getName() +"---set-await--"+Resource.p+++"---"+flag);//监视
    
49.                                 } catch (InterruptedException e) {
    
50.                                 }
    
51. 
    
52.                         this.name = name + (count++);
    
53.                         System.out.println(Thread.currentThread().getName() + "....生产"
    
54.                                         + this.name);
    
55.                         flag = true;
    
56.                         System.out.println(Thread.currentThread().getName() +"---set-下--"+Resource.p+++"---"+flag);//监视
    
57.                         consumer_con.signal();
    
58.                 } finally {
    
59.                         lock.unlock();
    
60.                 }
    
61.         }
    
62. 
    
63.         public synchronized void out() {
    
64.                 //System.out.println(Thread.currentThread().getName() +"---out()-上--"+Resource.p+++"---"+flag);
    
65.                 lock.lock();
    
66.                 try {
    
67.                         while (!flag)
    
68.                                 try {
    
69.                                         consumer_con.await();
    
70.                                 } catch (InterruptedException e) {
    
71.                                 }
    
72. 
    
73.                         System.out.println(Thread.currentThread().getName()
    
74.                                         + "*************消费" + this.name);
    
75.                         flag = false;
    
76.                         //System.out.println(Thread.currentThread().getName() +"---out()-下--"+Resource.p+++"---"+flag);
    
77.                         producer_con.signal();
    
78.                 } finally {
    
79.                         lock.unlock();
    
80.                 }
    
81.         }
    
82. }
    
83. 
    
84. class Producer implements Runnable {
    
85.         private Resource r;
    
86. 
    
87.         Producer(Resource r) {
    
88.                 this.r = r;
    
89.         }
    
90. 
    
91.         public void run() {
    
92.                 while (true) {
    
93.                         System.out.println(Thread.currentThread().getName() +"--Producer-run()---"+Resource.p+++"---");//监视
    
94.                         r.set("商品");
    
95.                 }
    
96.         }
    
97. }
    
98. 
    
99. class Consumer implements Runnable {
    
100.         private Resource r;
     
101. 
     
102.         Consumer(Resource r) {
     
103.                 this.r = r;
     
104.         }
     
105. 
     
106.         public void run() {
     
107.                 while (true) {
     
108.                         //System.out.println(Thread.currentThread().getName() +"--Consumer-run()---"+Resource.p+++"---");
     
109.                         r.out();
     
110.                 }
     
111.         }
     
112. }
     

复制代码

我只发现了这个情况，如果有其他的情况和我说说啊。

多谢你的提醒，把synchronized去掉之后就正常了

treecolor166 发表于 2013-12-29 00:35
多谢你的提醒，把synchronized去掉之后就正常了

我第一次回答有一点错误：
“
producer_con.await();//这一句。
当线程Thread-0执行到这一句时，此线程拿着此方法的锁this，处于等待状态。
”
这两句，我当时理解为没有释放锁，其实释放锁了。希望对你不要产生错误的引导。

await方法：与此 Condition 相关的锁以原子方式释放，并且出于线程调度的目的，将禁用当前线程。

同步方法的锁是this，就是此方法的调用者。执行await后， Condition 相关的锁被释放，this锁却没有释放。