谁能帮我看下下面的异常是什么意思，谢谢了
Exception in thread "Thread-1" java.lang.Error: Maximum lock count exceeded
        at java.util.concurrent.locks.ReentrantLock$Sync.nonfairTryAcquire(ReentrantLock.java:141)
        at java.util.concurrent.locks.ReentrantLock$NonfairSync.tryAcquire(ReentrantLock.java:213)
        at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquire(AbstractQueuedSynchronizer.java:1198)
        at java.util.concurrent.locks.ReentrantLock$NonfairSync.lock(ReentrantLock.java:209)
        at java.util.concurrent.locks.ReentrantLock.lock(ReentrantLock.java:285)
        at cn.program.thread.Goods.set(Producer.java:30)
        at cn.program.thread.Producer.run(Producer.java:96)
        at java.lang.Thread.run(Thread.java:745)

锁计数太多了，你这是递归过多还是死循环了？

fantacyleo 发表于 2014-8-2 23:50
锁计数太多了，你这是递归过多还是死循环了？

1. 这是源码，大神帮忙看一下
   
2. import java.util.concurrent.locks.Condition;
   
3. import java.util.concurrent.locks.Lock;
   
4. import java.util.concurrent.locks.ReentrantLock;
   
5. 
   
6. 
   
7. class Goods{
   
8.          private String name;
   
9.          private int num = 1;
   
10.          private boolean flag = false;
    
11.          private Lock lock = new ReentrantLock();
    
12.          private Condition condition_pro = lock.newCondition();
    
13.          private Condition condition_con = lock.newCondition();       
    
14.          
    
15.          public void set(String name) throws InterruptedException
    
16.          {
    
17.                  lock.lock();
    
18.                  while(flag)
    
19.                          try
    
20.                  {
    
21.                      condition_pro.await();
    
22.                          this.name  = name+"..."+num++;
    
23.                      System.out.println(Thread.currentThread().getName()+"---生产者"+this.name);
    
24.                      flag = true;
    
25.                      condition_con.signal();
    
26.                  }
    
27.                      finally
    
28.                      {
    
29.                              lock.unlock();
    
30.                      }
    
31.                  
    
32.          }
    
33.        
    
34.          public void out() throws InterruptedException
    
35.          {
    
36.                  lock.lock();
    
37.                  while(!flag)
    
38.                          try
    
39.                  {
    
40.                                  condition_con.await();
    
41.                                  System.out.println(Thread.currentThread().getName()+"------消费者"+this.name);
    
42.                                  flag = false;
    
43.                                  condition_pro.signal();
    
44. 
    
45.                  }
    
46.                  finally
    
47.                  {
    
48.                           lock.unlock();
    
49.                  }
    
50.                
    
51.                
    
52.          }
    
53. }
    
54. class Producer implements Runnable {
    
55.          private Goods g;
    
56.          Producer(Goods g)
    
57.          {
    
58.                 this.g = g;
    
59.          }
    
60.          public void run()
    
61.          {
    
62.                 while(true)
    
63.                 {
    
64.                         try
    
65.                         {
    
66.                                 g.set("+商品+");
    
67.                         }
    
68.                         catch(InterruptedException e){}
    
69.                 }
    
70.          }
    
71. }
    
72. class Consumer implements Runnable{
    
73.          private Goods g;
    
74.         Consumer(Goods g)
    
75.          {
    
76.                 this.g = g;
    
77.          }
    
78.         public void run()
    
79.         {
    
80.                 while(true)
    
81.                 {
    
82.                         try
    
83.                         {
    
84.                                 g.out();
    
85.                         }
    
86.                         catch(InterruptedException e){}
    
87.                 }
    
88.         }
    
89. }
    
90. public class ProducerConsumerDemo {
    
91.         public static void main(String[] args)
    
92.         {
    
93.                 Goods g = new Goods();
    
94.                 //new Thread(new Producer(g)).start();
    
95.                 //new Thread(new Consumer(g)).start();
    
96.                 Producer pro = new Producer(g);
    
97.                 Consumer con = new Consumer(g);
    
98.                 Thread t1 = new Thread(pro);
    
99.                 Thread t2 = new Thread(pro);
    
100.                 Thread t3 = new Thread(con);
     
101.                 Thread t4 = new Thread(con);
     
102.                 t1.start();
     
103.                 t2.start();
     
104.                 t3.start();
     
105.                 t4.start();
     
106.         }
     
107. 
     
108. }
     

复制代码

表示看不懂的路过

Ezreal 发表于 2014-8-2 23:58

明白了，set和out方法中的while条件设置出了问题。比如set方法中你while(flag)，结果生产完了flag又设为true，那不就死循环了？

fantacyleo 发表于 2014-8-3 00:22
明白了，set和out方法中的while条件设置出了问题。比如set方法中你while(flag)，结果生产完了flag又设为t ...

set方法中while为true是进入等待，为false就生产，生产完成设置为true就不再生产，唤醒消费者进行消费。这样没错吧。。

Ezreal 发表于 2014-8-3 00:37
set方法中while为true是进入等待，为false就生产，生产完成设置为true就不再生产，唤醒消费者进行消费。 ...

可你的while循环把生产也包括进来了，如果flag=flase，那么while循环根本就不执行，什么都不生产，

Ezreal 发表于 2014-8-3 00:37
set方法中while为true是进入等待，为false就生产，生产完成设置为true就不再生产，唤醒消费者进行消费。 ...

你的程序现在的执行逻辑是这样的：

一开始flag为false，消费者进out，上锁，判断while为真，进入循环，然后马上等待，释放锁。接着生产者进set，上锁，判断while为假，不执行，而且由于没有进入try/catch，finally也不会执行，锁没释放，也没唤醒消费者。由于run方法设置了while(true)，于是又回来set拿一次锁，锁计数+1，判断while为假，不执行，而且由于没有进入try/catch，finally也不会执行，锁没释放，也没唤醒消费者。由于run方法设置了while(true)，于是又回来set拿一次锁，锁计数+1。。。最后就是锁计数溢出

把get和set方法改成这样就好了。lock上锁之后的语句要立刻用try/finally包围起来，这样才能保证锁一定会被释放

1. public void set(String name) throws InterruptedException
   
2.          {
   
3.                  lock.lock();
   
4.                  try {
   
5.                  while(flag)
   
6.                      condition_pro.await();
   
7. 
   
8.                  this.name  = name+"..."+num++;
   
9.                  System.out.println(Thread.currentThread().getName()+"---生产者"+this.name);
   
10.                  flag = true;
    
11.                  condition_con.signal();
    
12.                  }
    
13.                  finally
    
14.                  {
    
15.                          lock.unlock();
    
16.                  }
    
17. 
    
18.          }
    
19.         
    
20.          public void out() throws InterruptedException
    
21.          {
    
22.                  lock.lock();
    
23.                  try {
    
24.                          while(!flag)
    
25.                                  condition_con.await();
    
26.                          System.out.println(Thread.currentThread().getName()+"------消费者"+this.name);
    
27.                          flag = false;
    
28.                          condition_pro.signal();
    
29. 
    
30.                  }
    
31.                  finally
    
32.                  {
    
33.                          lock.unlock();
    
34.                  }
    
35.                
    
36.                
    
37.          }

复制代码

看起有点晕哦！

路过，帮顶~

fantacyleo 发表于 2014-8-3 00:54
你的程序现在的执行逻辑是这样的：

一开始flag为false，消费者进out，上锁，判断while为真，进入循环， ...

明白了，谢谢这么耐心的回答