[Java] Java源码解析阻塞队列ArrayBlockingQueue介绍

/** main lock guarding all access **/
  final reentrantlock lock;​
  /** condition for waiting takes **/
  private final condition notempty;​
  /** condition for waiting puts **/
  private final condition notfull;

public arrayblockingqueue(int capacity, boolean fair) {
  if (capacity <= 0)
    throw new illegalargumentexception();
  this.items = new object[capacity];
  lock = new reentrantlock(fair);
  notempty = lock.newcondition();
  notfull = lock.newcondition();
  }

public void put(e e) throws interruptedexception {
  checknotnull(e);
  final reentrantlock lock = this.lock;
  lock.lockinterruptibly();
  try {
    while (count == items.length)
    notfull.await();
    enqueue(e);
  } finally {
    lock.unlock();
  }
  }

public e take() throws interruptedexception {
  final reentrantlock lock = this.lock;
  lock.lockinterruptibly();
  try {
    while (count == 0)
    notempty.await();
    return dequeue();
  } finally {
    lock.unlock();
  }
  }

• causes the current thread to wait until it is signalled or interrupted.
  
• the lock associated with this condition is atomically released and the current thread becomes disabled for thread scheduling purposes and lies dormant until one of four things happens......
  

• in all cases, before this method can return the current thread must re-acquire the lock associated with this condition. when the thread returns it is guaranteed to hold this lock.