Lock lock = new ReentrantLock();
 Condition condition = lock.newCondition();
 public void conditionWait() throws InterruptedException {
  lock.lock();
  try {
   condition.await();
  } finally {
   lock.unlock();
  }
 }
 public void conditionSignal() throws InterruptedException {
  lock.lock();
  try {
   condition.signal();
  } finally {
   lock.unlock();
  }
 }

 /**
  * 當(dāng)前線程進入等待狀態(tài)直到被通知(signal)或中斷，當(dāng)前線程進入后臺運行狀態(tài)且從await()方法返回
  * 其他線程調(diào)用該Condition的signal或者signalAll方法，而當(dāng)前線程被選中喚醒
  * 1、其他線程（interrupt）中斷當(dāng)前線程
  * 2、如果當(dāng)前等待線程從await方法返回，那么表明當(dāng)前線程已經(jīng)獲取了Condition對象的鎖
  */
 void await() throws InterruptedException;

 /**
  * 當(dāng)前線程進入等待狀態(tài)直到被通知，對中斷不響應(yīng)
  */
 void awaitUninterruptibly();

 /**
  * <pre> {@code
  * boolean aMethod(long timeout, TimeUnit unit) {
  * long nanos = unit.toNanos(timeout);
  * lock.lock();
  * try {
  *  while (!conditionBeingWaitedFor()) {
  *  if (nanos <= 0L)
  *   return false;
  *  nanos = theCondition.awaitNanos(nanos);
  *  }
  *  // ...
  * } finally {
  *  lock.unlock();
  * }
  * }}</pre>
  * 當(dāng)前線程進入等待狀態(tài)直到被通知、中斷或超時。返回值表示剩余時間，如果在nanosTimeout納秒之前被喚醒，那么返回值就是nanosTimeout-實際耗時
  * 返回值<=0說明超時
  * 
  */
 long awaitNanos(long nanosTimeout) throws InterruptedException;

 /**
  * 當(dāng)前線程進入等待狀態(tài)直到被通知、中斷或超時，如果沒有到指定時間被通知返回true，否則返回false
  */
 boolean await(long time, TimeUnit unit) throws InterruptedException;

 /**
  * 喚醒一個等待在Condition上的線程，該線程從等待方法返回之前必須獲得與Condition相關(guān)聯(lián)的鎖
  */
 void signal();

public class BoundedQueue<T> {
 private Object[] items;

 // 添加的下標(biāo)，刪除的下標(biāo)和數(shù)組當(dāng)前數(shù)量
 private int addIndex,removeIndex,count;
 private Lock lock = new ReentrantLock();
 private Condition notEmpty = lock.newCondition();
 private Condition notFull = lock.newCondition();
 public BoundedQueue(int size){
  items = new Object[size];
 }

 /**
  * 添加一個元素，如果數(shù)組滿，則添加線程進入等待狀態(tài)，直到有"空位"
  * @author fuyuwei
  * 2017年5月21日 下午6:14:55
  * @param t
  * @throws InterruptedException
  */
 public void add(T t) throws InterruptedException{
  lock.lock();
  try{
   while(count == items.length){
    notFull.await();
   }
   items[addIndex] = t;
   if(++addIndex == items.length)
    addIndex = 0;
   ++count;
   notEmpty.signal();
  }finally{
   lock.unlock();
  }
 }

 /**
  * 由頭部刪除一個元素，如果數(shù)組空，則刪除線程進入等待狀態(tài)，直到有新添加元素
  * @author fuyuwei
  * 2017年5月21日 下午6:20:54
  * @return
  * @throws InterruptedException
  */
 @SuppressWarnings("unchecked")
 public T remove() throws InterruptedException{
  lock.lock();
  try{
   while(count == 0)
    notEmpty.await();
   Object x = items[removeIndex];
   if(++removeIndex == items.length)
    removeIndex = 0;
   --count;
   notFull.signal();
   return (T)x;
  }finally{
   lock.unlock();
  }
 }
}

public final void await() throws InterruptedException {
  if (Thread.interrupted())
   throw new InterruptedException();
  // 當(dāng)前線程加入等待隊列
  Node node = addConditionWaiter();
  // 釋放同步狀態(tài)，也就是釋放鎖
  int savedState = fullyRelease(node);
  int interruptMode = 0;
  while (!isOnSyncQueue(node)) {
   LockSupport.park(this);
   if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
    break;
  }
  if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
   interruptMode = REINTERRUPT;
  if (node.nextWaiter != null)
   unlinkCancelledWaiters();
  if (interruptMode != 0)
   reportInterruptAfterWait(interruptMode);
 }

public final void signal() {
  if (!isHeldExclusively())
   throw new IllegalMonitorStateException();
  Node first = firstWaiter;
  if (first != null)
   doSignal(first);
 }