31

以下代码取自 的JavaDocCondition：

class BoundedBuffer {
  final Lock lock = new ReentrantLock();
  final Condition notFull  = lock.newCondition(); 
  final Condition notEmpty = lock.newCondition(); 

  final Object[] items = new Object[100];
  int putptr, takeptr, count;

  public void put(Object x) throws InterruptedException {
    lock.lock();
    try {
      while (count == items.length) 
        notFull.await();
      items[putptr] = x; 
      if (++putptr == items.length) putptr = 0;
      ++count;
      notEmpty.signal();
    } finally {
      lock.unlock();
    }
  }

  public Object take() throws InterruptedException {
    lock.lock();
    try {
      while (count == 0) 
        notEmpty.await();
      Object x = items[takeptr]; 
      if (++takeptr == items.length) takeptr = 0;
      --count;
      notFull.signal();
      return x;
    } finally {
      lock.unlock();
    }
  } 
}

想象一下 2 个线程，Consumer和Producer，一个使用take，一个put在BoundedBuffer.

假设Consumer首先运行take()，在其中他锁定了lock并且现在循环运行notEmpty.await();。

现在Producer怎么可能进入put()锁定lock已经由Consumer持有的方法？

我在这里想念什么？lock线程等待其条件之一时是否“临时释放” ？锁的可重入性究竟意味着什么？

4

3 回答 3

29

两者都Lock允许synchronized一个线程在等待时放弃锁而另一个线程可以获得锁。要停止等待，线程必须重新获取锁。

注意：它们不会完全释放它，如果您进行堆栈跟踪，您可能会有多个线程似乎同时持有锁，但最多有一个线程将运行（其余线程将阻塞）

从Condition.await()

与此 Condition 关联的锁被自动释放，并且当前线程出于线程调度目的而被禁用并处于休眠状态，直到发生以下四种情况之一：

  • 其他一些线程为此 Condition 调用 signal() 方法，当前线程恰好被选为要唤醒的线程；或者
  • 其他一些线程为此条件调用 signalAll() 方法；或者
  • 其他一些线程中断当前线程，支持中断线程挂起；或者
  • 发生“虚假唤醒”。

在所有情况下，在此方法可以返回之前，当前线程必须重新获取与此条件关联的锁。当线程返回时，它保证持有这个锁

于 2012-09-25T08:09:52.230 回答
6

就重入而言，这意味着持有某个锁的线程可以再次重新获取同一个锁。如果不是这样，一个synchronized方法就不能调用synchronized同一个对象的另一个方法。

重新进入不涉及对您的问题的理解。

于 2012-09-25T08:17:08.433 回答
-1

我用单显示器测试了下面的代码，下面的代码总是表现更好 - 在 2 核机器上测试，条件性能平均低于 10-15%

 final Object sync = new Object();
  AtomicInteger add=new AtomicInteger();
  AtomicInteger remove=new AtomicInteger();
   final Object[] items = new Object[1];
   int putptr, takeptr, count;        

 public void add(Object x) throws InterruptedException {
       add.incrementAndGet();

     synchronized (sync) {

       while (count == items.length)
         sync.wait();
       items[putptr] = x;
       if (++putptr == items.length) putptr = 0;
       ++count;
       sync.notify();
        }
   }

   public Object remove() throws InterruptedException {
       remove.incrementAndGet();

     synchronized (sync) {

       while (count == 0)
         sync.wait();
       Object x = items[takeptr];
       if (++takeptr == items.length) takeptr = 0;
       --count;
       sync.notify();
       return x;

       }
   }


  public static void main(String[] args) {
    final BoundedBuffer bf=new BoundedBuffer();

    Thread put =new Thread(){
        public void run(){
        try {
            while(true)
            bf.add(new Object());
        } catch (InterruptedException e) {

        }
        }

    };
    put.start();

    Thread take= new Thread(){
        public void run(){
        try {
        while(true)
            bf.remove();
        } catch (InterruptedException e) {

        }
        }

    };
    take.start();

    try {
        Thread.sleep(1000L);
        put.interrupt();
        take.interrupt();
    } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }


    System.out.println("add:"+bf.add);
    System.out.println("remove:"+bf.remove);
于 2014-04-28T19:06:58.713 回答