一、demo

public class ArrayBlockingQueueTest {
    public static void main(String[] args) throws Exception{
        ArrayBlockingQueue linkedBlockingQueue = new ArrayBlockingQueue(10);
        linkedBlockingQueue.put("今天头条");
        System.out.println(linkedBlockingQueue.take());
        Iterator iterator = linkedBlockingQueue.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

二、构造方法

public ArrayBlockingQueue(int capacity) {
    this(capacity, false);
}

 /** 
 	* @param capacity 队列数组大小
	* @param fair 是否是公平锁
  */
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();
}

三、put方法

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();
    }
}

private void enqueue(E x) {
    // assert lock.getHoldCount() == 1;
    // assert items[putIndex] == null;
    final Object[] items = this.items;
  	/** 将数据放入数组下标位置 */
    items[putIndex] = x;
  	/** putIndex判断是否等于数组长度，并且加一 */
    if (++putIndex == items.length)
        putIndex = 0;
  	/** count数组存放数量加一 */
    count++;
  	/** 唤醒阻塞住的消费线程 */
    notEmpty.signal();
}

四、take方法

public E take() throws InterruptedException {
  /** 获取锁，加一个可以被中断的锁，保证同一时间只有一个线程可以添加数据
    * 如果加锁线程被中断了，此时加锁会失败，抛出一个线程中断的异常出来
    */
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
      	/** 如果队列没有数据则将消费线程阻塞住 */
        while (count == 0)
            notEmpty.await();
        return dequeue();
    } finally {
      	/** 释放锁 */
        lock.unlock();
    }
}

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;
  	/** 如果是数组最后一位，则将takeIndex初始化置0 */
    if (++takeIndex == items.length)
        takeIndex = 0;
  	/** 队列数量减一 */
    count--;
    if (itrs != null)
        itrs.elementDequeued();
  	/** 唤醒阻塞住的数据生产线程 */
    notFull.signal();
    return x;
}

五、size方法

public int size() {
  	/** 获取锁进行加锁操作 */
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
      	/** 直接返回count队列元素数量 */
        return count;
    } finally {
      	/** 释放锁 */
        lock.unlock();
    }
}

六、iterator方法

public Iterator<E> iterator() {
    return new Itr();
}

Itr() {
    // assert lock.getHoldCount() == 0;
    lastRet = NONE;
  	/** 获取ArrayBlockingQueue锁进行加锁操作 */
    final ReentrantLock lock = ArrayBlockingQueue.this.lock;
    lock.lock();
    try {
        if (count == 0) {
            // assert itrs == null;
            cursor = NONE;
            nextIndex = NONE;
            prevTakeIndex = DETACHED;
        } else {
            final int takeIndex = ArrayBlockingQueue.this.takeIndex;
            prevTakeIndex = takeIndex;
            nextItem = itemAt(nextIndex = takeIndex);
            cursor = incCursor(takeIndex);
            if (itrs == null) {
                itrs = new Itrs(this);
            } else {
                itrs.register(this); // in this order
                itrs.doSomeSweeping(false);
            }
            prevCycles = itrs.cycles;
            // assert takeIndex >= 0;
            // assert prevTakeIndex == takeIndex;
            // assert nextIndex >= 0;
            // assert nextItem != null;
        }
    } finally {
      	/** 释放锁 */
        lock.unlock();
    }
}

public E next() {
    // assert lock.getHoldCount() == 0;
  	/** 获取当前迭代元素 */
    final E x = nextItem;
    if (x == null)
        throw new NoSuchElementException();
  	/** 加锁 */
    final ReentrantLock lock = ArrayBlockingQueue.this.lock;
    lock.lock();
    try {
        if (!isDetached())
            incorporateDequeues();
        // assert nextIndex != NONE;
        // assert lastItem == null;
        lastRet = nextIndex;
        final int cursor = this.cursor;
        if (cursor >= 0) {
          	/** nextItem执行下一个元素 */
            nextItem = itemAt(nextIndex = cursor);
            // assert nextItem != null;
            this.cursor = incCursor(cursor);
        } else {
            nextIndex = NONE;
            nextItem = null;
        }
    } finally {
      	/** 释放锁 */
        lock.unlock();
    }
  	/** 返回元素 */
    return x;
}