java中阻塞队列详细介绍

public class ArrayBlockingQueue extends AbstractQueue
 implements BlockingQueue, java.io.Serializable {
 
 /** The queued items */
 //以数组的结构存储队列的元素，采用的是循环数组
 final Object[] items;

 /** items index for next take, poll, peek or remove */
 //队列的队头索引
 int takeIndex;

 /** items index for next put, offer, or add */
 //队列的队尾索引
 int putIndex;

 /** Number of elements in the queue */
 //队列中元素的个数
 int count;

 /** Main lock guarding all access */
 //对于ArrayBlockingQueue所有的操作都需要加锁，
 final ReentrantLock lock;

 /** Condition for waiting takes */
 //条件队列，当队列为空时阻塞消费者并在生产者生产后唤醒消费者
 private final Condition notEmpty;

 /** Condition for waiting puts */
 //条件队列，当队列满时阻塞生产者，并在消费者消费队列后唤醒生产者
 private final Condition notFull;
}

 /**
 * 向队列中添加元素
 * 当队列已满时需要阻塞当前线程
 * 放入元素后唤醒因队列为空阻塞的消费者
 */
 public void put(E e) throws InterruptedException {
 checkNotNull(e);
 final ReentrantLock lock = this.lock;
 lock.lockInterruptibly();
 try {
  //当队列已满时需要notFull.await()阻塞当前线程
  //offer(e,time,unit)方法就是阻塞的时候加了超时设定
  while (count == items.length)
  notFull.await();
  //放入元素的过程
  enqueue(e);
 } finally {
  lock.unlock();
 }
 }
 
 /**enqueue实际添加元素的方法*/
 private void enqueue(E x) {
 // assert lock.getHoldCount() == 1;
 // assert items[putIndex] == null;
 final Object[] items = this.items;
 items[putIndex] = x;
 if (++putIndex == items.length)
  putIndex = 0;
 count++;
 //如果条件队列中存在等待的线程
 //唤醒
 notEmpty.signal();
 }

 /**
 * 从队列中获取元素
 * 当队列已空时阻塞当前线程
 * 从队列中消费元素后唤醒等待的生产线程
 */
 public E take() throws InterruptedException {
 final ReentrantLock lock = this.lock;
 lock.lockInterruptibly();
 try {
  //队列为空需要阻塞当前线程
  while (count == 0)
  notEmpty.await();
  //获取元素的过程
  return dequeue();
 } finally {
  lock.unlock();
 }
 }
 
 /**dequeue实际消费元素的方法*/
 private E dequeue() {
 // assert lock.getHoldCount() == 1;
 // assert items[takeIndex] != null;
 final Object[] items = this.items;
 @SuppressWarnings("unchecked")
 E x = (E) items[takeIndex];
 items[takeIndex] = null;
 if (++takeIndex == items.length)
  takeIndex = 0;
 count--;
 if (itrs != null)
  itrs.elementDequeued();
 //消费元素后从唤醒阻塞的生产者线程
 notFull.signal();
 return x;
 }