黑马程序员技术交流社区

标题: 求解决一个问题 [打印本页]
作者: Ezreal    时间: 2014-8-2 23:48
标题: 求解决一个问题
谁能帮我看下下面的异常是什么意思，谢谢了
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
锁计数太多了，你这是递归过多还是死循环了？
作者: Ezreal    时间: 2014-8-2 23:58
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;


  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();

  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.         }

  108. }
复制代码
作者: s_gd    时间: 2014-8-3 00:12
表示看不懂的路过
作者: fantacyleo    时间: 2014-8-3 00:22
Ezreal 发表于 2014-8-2 23:58

明白了，set和out方法中的while条件设置出了问题。比如set方法中你while(flag)，结果生产完了flag又设为true，那不就死循环了？
作者: Ezreal    时间: 2014-8-3 00:37
fantacyleo 发表于 2014-8-3 00:22
明白了，set和out方法中的while条件设置出了问题。比如set方法中你while(flag)，结果生产完了flag又设为t ...

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

可你的while循环把生产也包括进来了，如果flag=flase，那么while循环根本就不执行，什么都不生产，
作者: fantacyleo    时间: 2014-8-3 00:54
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。。。最后就是锁计数溢出
作者: fantacyleo    时间: 2014-8-3 01:01
把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();

  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.                  }

  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();

  30.                  }
  31.                  finally
  32.                  {
  33.                          lock.unlock();
  34.                  }
  35.                
  36.                
  37.          }
复制代码
作者: niushicha    时间: 2014-8-3 01:31
看起有点晕哦！
作者: Joemi    时间: 2014-8-3 08:19
路过，帮顶~
作者: Ezreal    时间: 2014-8-3 09:05
fantacyleo 发表于 2014-8-3 00:54
你的程序现在的执行逻辑是这样的：

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

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



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2