// 存放元素的數(shù)組
final Object[] items;
// 用來(lái)記錄取元素的下標(biāo)，用于下一次在take，poll,remove，peek方法中使用
int takeIndex;
// 用來(lái)記錄添加元素的下標(biāo)，用于下一次put,offer,add等方法使用
int putIndex;
// 記錄隊(duì)列中元素?cái)?shù)量
int count;
// 用于控制并發(fā)訪問(wèn)時(shí)保證線程安全的鎖
final ReentrantLock lock;
// 用于隊(duì)列空時(shí)阻塞和喚醒等待線程的條件
private final Condition notEmpty;
// 用于隊(duì)列滿時(shí)阻塞和喚醒等待線程的條件
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) {
    // 先創(chuàng)建一個(gè)ArrayBlockingQueue實(shí)例
    this(capacity, fair);
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        int i = 0;
        try {
            // 循環(huán)將collection中的元素放入queue中
            for (E e : c) {
                checkNotNull(e);
                items[i++] = e;
            }
        } catch (ArrayIndexOutOfBoundsException ex) {
            // 如果collection的元素個(gè)數(shù)超出queue的容量大小，會(huì)拋出異常
            throw new IllegalArgumentException();
        }
        count = i;
        putIndex = (i == capacity) ? 0 : i;
    } finally {
        lock.unlock();
    }
}

public boolean add(E e) {
    // 調(diào)用父類中的add(e)方法
    return super.add(e);
}
public boolean add(E e) {
    // 這里會(huì)直接調(diào)用offer(e)方法，如果offer方法返回false,則直接拋出異常
    if (offer(e))
        return true;
    else
        throw new IllegalStateException("Queue full");
}

public boolean offer(E e) {
    // 這里先判斷空，如果e為空會(huì)拋出空指針異常
    checkNotNull(e);
    final ReentrantLock lock = this.lock;
	// 加鎖，保證入隊(duì)操作的原子性
    lock.lock();
    try {
        // 隊(duì)列滿時(shí)直接返回false
        if (count == items.length)
            return false;
        else {
            // 元素入隊(duì)
            enqueue(e);
            return true;
        }
    } finally {
        lock.unlock();
    }
}

public void put(E e) throws InterruptedException {
    checkNotNull(e);
    final ReentrantLock lock = this.lock;
	// 可被中斷方式獲取鎖
    lock.lockInterruptibly();
    try {
        while (count == items.length)
            // 隊(duì)列滿時(shí)會(huì)阻塞
            notFull.await();
        // 入隊(duì)
        enqueue(e);
    } finally {
        lock.unlock();
    }
}

private void enqueue(E x) {
    final Object[] items = this.items;
    items[putIndex] = x;
    if (++putIndex == items.length)
        putIndex = 0;
    count++;
    // 入隊(duì)成功，喚醒等待的移除元素操作線程
    notEmpty.signal();
}

public boolean offer(E e, long timeout, TimeUnit unit)
        throws InterruptedException {
    checkNotNull(e);
    // 加鎖之前先獲取需要等待的時(shí)間值
    long nanos = unit.toNanos(timeout);
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        while (count == items.length) {
            // 時(shí)間小于等于0時(shí)，返回false
            if (nanos <= 0)
                return false;
            // 阻塞等待指定時(shí)間
            nanos = notFull.awaitNanos(nanos);
        }
        enqueue(e);
        return true;
    } finally {
        lock.unlock();
    }
}

public E take() throws InterruptedException {
    final ReentrantLock lock = this.lock;
	// 加鎖
    lock.lockInterruptibly();
    try {
        while (count == 0)
            // 如果元素?cái)?shù)量==0，表示隊(duì)列中為空，則阻塞等待
            notEmpty.await();
        return dequeue();
    } finally {
        lock.unlock();
    }
}

private E dequeue() {
    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;
}

// 內(nèi)部類Node節(jié)點(diǎn)，用來(lái)存放鏈表中的元素
static class Node<E> {
    // 節(jié)點(diǎn)元素
	E item;
	// 當(dāng)前節(jié)點(diǎn)的下一個(gè)節(jié)點(diǎn)，如果為空表示沒(méi)有下一個(gè)節(jié)點(diǎn)
	Node<E> next;
	Node(E x) { item = x; }
}
// 隊(duì)列的容量
private final int capacity;
// 隊(duì)列中元素的數(shù)量
private final AtomicInteger count = new AtomicInteger();
// 頭節(jié)點(diǎn)
transient Node<E> head;
// 最后一個(gè)節(jié)點(diǎn)
private transient Node<E> last;
// 獲取元素時(shí)控制線程安全的鎖
private final ReentrantLock takeLock = new ReentrantLock();
// 添加元素時(shí)控制線程安全的鎖
private final ReentrantLock putLock = new ReentrantLock();
// 控制消費(fèi)者的條件
private final Condition notEmpty = takeLock.newCondition();
// 控制生產(chǎn)者的條件
private final Condition notFull = putLock.newCondition();

public LinkedBlockingQueue() {
    this(Integer.MAX_VALUE);
}
public LinkedBlockingQueue(int capacity) {
    if (capacity <= 0) throw new IllegalArgumentException();
    this.capacity = capacity;
    // 創(chuàng)建一個(gè)不存放元素的Node對(duì)象賦值給head和last
    last = head = new Node<E>(null);
}
public LinkedBlockingQueue(Collection<? extends E> c) {
        this(Integer.MAX_VALUE);
        final ReentrantLock putLock = this.putLock;
        putLock.lock();
        try {
            int n = 0;
            for (E e : c) {
                if (e == null)
                    throw new NullPointerException();
                if (n == capacity)
                    throw new IllegalStateException("Queue full");
                // 入隊(duì)
                enqueue(new Node<E>(e));
                ++n;
            }
            count.set(n);
        } finally {
            putLock.unlock();
        }
    }

public boolean offer(E e) {
    if (e == null) throw new NullPointerException();
    final AtomicInteger count = this.count;
    if (count.get() == capacity)
        return false;
    int c = -1;
    Node<E> node = new Node<E>(e);
    // 使用putLock加鎖
    final ReentrantLock putLock = this.putLock;
    putLock.lock();
    try {
        if (count.get() < capacity) {
            // 入隊(duì)
            enqueue(node);
            // 數(shù)量+1
            c = count.getAndIncrement();
            if (c + 1 < capacity)
                // 喚醒一個(gè)生產(chǎn)者線程
                notFull.signal();
        }
    } finally {
        putLock.unlock();
    }
    if (c == 0)
        // 喚醒消費(fèi)者線程
        signalNotEmpty();
    // 入隊(duì)失敗情況會(huì)返回false
    return c >= 0;
}

private void enqueue(Node<E> node) {
    last = last.next = node;
}

public void put(E e) throws InterruptedException {
    if (e == null) throw new NullPointerException();
    int c = -1;
    Node<E> node = new Node<E>(e);
    // 使用putLock加鎖
    final ReentrantLock putLock = this.putLock;
    final AtomicInteger count = this.count;
    putLock.lockInterruptibly();
    try {
        while (count.get() == capacity) {
            // 如果隊(duì)列容量已使用完則阻塞
            notFull.await();
        }
        enqueue(node);
        c = count.getAndIncrement();
        if (c + 1 < capacity)
            notFull.signal();
    } finally {
        putLock.unlock();
    }
    if (c == 0)
        signalNotEmpty();
}

public E poll() {
        final AtomicInteger count = this.count;
        if (count.get() == 0)
            return null;
        E x = null;
        int c = -1;
    // 使用takeLock加鎖
        final ReentrantLock takeLock = this.takeLock;
        takeLock.lock();
        try {
            if (count.get() > 0) {
                x = dequeue();
                c = count.getAndDecrement();
                if (c > 1)
                    // 還有元素時(shí)喚醒一個(gè)生產(chǎn)者線程
                    notEmpty.signal();
            }
        } finally {
            takeLock.unlock();
        }
        if (c == capacity)
            // 喚醒生產(chǎn)者線程
            signalNotFull();
        return x;
    }

// 出隊(duì)方法
private E dequeue() {
    Node<E> h = head;
    Node<E> first = h.next;
    h.next = h; 
    head = first;
    E x = first.item;
    first.item = null;
    return x;
}

public E take() throws InterruptedException {
    E x;
    int c = -1;
    final AtomicInteger count = this.count;
    // 使用takeLock加鎖
    final ReentrantLock takeLock = this.takeLock;
    takeLock.lockInterruptibly();
    try {
        while (count.get() == 0) {
            //阻塞等待
            notEmpty.await();
        }
        x = dequeue();
        c = count.getAndDecrement();
        if (c > 1)
            // 還有元素時(shí)喚醒一個(gè)消費(fèi)者線程
            notEmpty.signal();
    } finally {
        takeLock.unlock();
    }
    if (c == capacity)
        // 喚醒生產(chǎn)者線程
        signalNotFull();
    return x;
}