ArrayBlockingQueue详解

//存放元素的数组
  final Object[] items;

  //出队操作的下标
  int takeIndex;
  
  //入队操作的下标
  int putIndex;

  //元素个数
  int count;

  //入队操作和出队操作的独占锁
  final ReentrantLock lock;

  //当队列为空时，进行出队操作的线程会被放进这个条件队列等待
  private final Condition notEmpty;

  //当队列已满，进行入队操作的线程会被放进该这个条件队列等待
  private final Condition notFull;

public ArrayBlockingQueue(int capacity) {
       this(capacity, false);
  }
  
  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 ArrayBlockingQueue(int capacity, boolean fair,
                             Collection<? extends E> c) {
       this(capacity, fair);

       final ReentrantLock lock = this.lock;
       lock.lock(); // Lock only for visibility, not mutual exclusion//上锁
       try {
           int i = 0;
           try {
               for (E e : c) {
                   checkNotNull(e);//判空
                   items[i++] = e;
               }
           } catch (ArrayIndexOutOfBoundsException ex) {
               throw new IllegalArgumentException();
           }
           count = i;
           putIndex = (i == capacity) ? 0 : i;
       } finally {
           lock.unlock();
       }
  }

public boolean offer(E e) {
    checkNotNull(e);//判空
    final ReentrantLock lock = this.lock;
    lock.lock();//上锁
    try {
        if (count == items.length)//如果队列已满直接返回false
            return false;
        else {
            enqueue(e);//把值添加到队列尾部
            return true;
        }
    } finally {
        lock.unlock();
    }
}

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)//如果入队下标等于队列边界则把入队下标设置为0
        putIndex = 0;
    count++;
    notEmpty.signal();
}

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 poll() {
    final ReentrantLock lock = this.lock;
    lock.lock();//上锁
    try {
        return (count == 0) ? null : dequeue();//如果队列个数为空则直接返回null否则调用dequeue()
    } finally {
        lock.unlock();
    }
}

private E dequeue() {
    final Object[] items = this.items;
    E x = (E) items[takeIndex];//根据出队下标获得值
    items[takeIndex] = null;
    if (++takeIndex == items.length)//计算出队下标的值，如果等于队列长度则设置为0
        takeIndex = 0;
    count--;
    if (itrs != null)
        itrs.elementDequeued();
    notFull.signal();
    return x;
}

public E take() throws InterruptedException {
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();//获得可以被中断的独占锁
    try {
        while (count == 0)//如果队列为空则休眠
            notEmpty.await();
        return dequeue();//进行出队操作
    } finally {
        lock.unlock();
    }
}