1、ArrayBlockingQueue的成员变量

//存储结构是数组
final Object[] items;

//取数据指针
int takeIndex;

//存数据指针
int putIndex;

//数据最大长度
int count;

//存取数据用的锁
final ReentrantLock lock;

//队列为空的阻塞条件
private final Condition notEmpty;

//队列满的阻塞条件
private final Condition notFull;

2、ArrayBlockingQueue的构造器

//初始化固定大小的队列
public ArrayBlockingQueue(int capacity);
//fair代表ReentrantLock的公平锁与非公平锁
public ArrayBlockingQueue(int capacity, boolean fair);
//Collection<? extends E> c可以传入一个集合进行构造
public ArrayBlockingQueue(int capacity, boolean fair,Collection<? extends E> c)

3、put方法（添加数据，队列满则阻塞）

public void put(E e) throws InterruptedException {
    checkNotNull(e);
    final ReentrantLock lock = this.lock;
    //可中断的锁
    lock.lockInterruptibly();
    try {
        //如果队列总长度==items数组的长度，则需要进行阻塞
        while (count == items.length)
            notFull.await();
        //入队操作
        enqueue(e);
    } finally {
        lock.unlock();
    }
}

private void enqueue(E x) {
    final Object[] items = this.items;
    
    //赋值
    items[putIndex] = x;
    
    //这里会对putIndex进行++操作。
    //所以putIndex始终对应着应该插入元素的位置。
    //当++putIndex == items.length时，这里的putIndex会赋值0
    //由此可见，items应该是一个类似环形的数组。
    if (++putIndex == items.length)
        putIndex = 0;
    
    count++;
    
    //唤醒空队列的take阻塞。
    notEmpty.signal();
}

4、take方法（获取数据，队列空则阻塞）

public E take() throws InterruptedException {
    //由此可见，put和take操作都是用的同一个锁。是互斥的
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        //如果队列里没有数据，take方法阻塞
        while (count == 0)
            notEmpty.await();
        
        //出队操作
        return dequeue();
    } finally {
        lock.unlock();
    }
}


private E dequeue() {
    final Object[] items = this.items;
    
    //获取takeIndex的元素
    E x = (E) items[takeIndex];
    
    //takeIndex位置设置为null
    items[takeIndex] = null;
    
    //与入队操作相同，++takeIndex后==items.length，则从头继续取元素
    if (++takeIndex == items.length)
        takeIndex = 0;
    count--;
    if (itrs != null)
        //更新迭代器中数据
        itrs.elementDequeued();
    
    //唤醒满队列的阻塞。
    notFull.signal();
    return x;
}

5、add方法（调用父类的add）、offer方法

/**
 * ArrayBlockingQueue 的add方法，向队列添加元素
 */
public boolean add(E e) {
    //调用父类add.
    return super.add(e);
}

/**
 * 父类AbstractQueue 的add方法，向队列添加元素
 * 队列满了就抛异常。
 */
public boolean add(E e) {
    if (offer(e))
        return true;
    else
        throw new IllegalStateException("Queue full");
}


/**
 * ArrayBlockingQueue 的offer方法，向队列添加元素
 * 如果队列满了，就返回false。不满就入队操作。返回true
 */
public boolean offer(E e) {
    checkNotNull(e);
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        if (count == items.length)
            return false;
        else {
            enqueue(e);
            return true;
        }
    } finally {
        lock.unlock();
    }
}

6、offer(E e, long timeout, TimeUnit unit)方法

/**
 * ArrayBlockingQueue 的offer方法，向队列添加元素
 * 如果队列满了，就阻塞，添加超时时间。
 */
public boolean offer(E e, long timeout, TimeUnit unit)
    throws InterruptedException {
    checkNotNull(e);
    long nanos = unit.toNanos(timeout);
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        while (count == items.length) {
            if (nanos <= 0)
                return false;
            nanos = notFull.awaitNanos(nanos);
        }
        enqueue(e);
        return true;
    } finally {
        lock.unlock();
    }
}

7、peek方法

/**
 * 获取当前消费指针（takeIndex）位置上的元素
 * 但不移动takeIndex指针，不清空当前位置数据
 */
public E peek() {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        return itemAt(takeIndex); // null when queue is empty
    } finally {
        lock.unlock();
    }
}
final E itemAt(int i) {
    return (E) items[i];
}