public class ArrayBlockingQueue<E>
        extends AbstractQueue<E>
        implements BlockingQueue<E>, java.io.Serializable {


    /**
     * 用來存放數據的數組
     */
    final Object[] items;

    /**
     * 下次取數據的數組下標位置
     */
    int takeIndex;

    /**
     * 下次放數據的數組下標位置
     */
    int putIndex;

    /**
     * 元素個數
     */
    int count;

    /**
     * 獨占鎖，用來保證存取數據安全
     */
    final ReentrantLock lock;

    /**
     * 取數據的條件
     */
    private final Condition notEmpty;

    /**
     * 放數據的條件
     */
    private final Condition notFull;

}

/**
 * 指定容量大小的構造方法
 */
BlockingQueue<Integer> blockingDeque1 = new ArrayBlockingQueue<>(1);
/**
 * 指定容量大小、公平鎖的構造方法
 */
BlockingQueue<Integer> blockingDeque1 = new ArrayBlockingQueue<>(1, true);

/**
 * 指定容量大小的構造方法（默認是非公平鎖）
 */
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();
}

/**
 * offer方法入口
 *
 * @param e 元素
 * @return 是否插入成功
 */
public boolean offer(E e) {
    // 1. 判空，傳參不允許為null
    checkNotNull(e);
    // 2. 加鎖
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        // 3. 判斷數組是否已滿，如果滿了就直接返回false結束
        if (count == items.length) {
            return false;
        } else {
            // 4. 否則就插入
            enqueue(e);
            return true;
        }
    } finally {
        // 5. 釋放鎖
        lock.unlock();
    }
}

/**
 * 入隊
 *
 * @param x 元素
 */
private void enqueue(E x) {
    // 1. 獲取數組
    final Object[] items = this.items;
    // 2. 直接放入數組
    items[putIndex] = x;
    // 3. 移動putIndex位置，如果到達數組的末尾就從頭開始
    if (++putIndex == items.length) {
        putIndex = 0;
    }
    // 4. 計數
    count++;
    // 5. 喚醒因為隊列為空，等待取數據的線程
    notEmpty.signal();
}

/**
 * add方法入口
 *
 * @param e 元素
 * @return 是否添加成功
 */
public boolean add(E e) {
    if (offer(e)) {
        return true;
    } else {
        throw new IllegalStateException("Queue full");
    }
}

/**
 * put方法入口
 *
 * @param e 元素
 */
public void put(E e) throws InterruptedException {
    // 1. 判空，傳參不允許為null
    checkNotNull(e);
    // 2. 加可中斷的鎖，防止一直阻塞
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        // 3. 如果隊列已滿，就一直阻塞，直到被喚醒
        while (count == items.length) {
            notFull.await();
        }
        // 4. 如果隊列未滿，直接入隊
        enqueue(e);
    } finally {
        // 5. 釋放鎖
        lock.unlock();
    }
}

/**
 * offer方法入口
 *
 * @param e       元素
 * @param timeout 超時時間
 * @param unit    時間單位
 * @return 是否添加成功
 */
public boolean offer(E e, long timeout, TimeUnit unit) throws InterruptedException {
    // 1. 判空，傳參不允許為null
    checkNotNull(e);
    // 2. 把超時時間轉換為納秒
    long nanos = unit.toNanos(timeout);
    // 3. 加可中斷的鎖，防止一直阻塞
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        // 4. 循環判斷隊列是否已滿
        while (count == items.length) {
            if (nanos <= 0) {
                // 6. 如果隊列已滿，且超時時間已過，則返回false
                return false;
            }
            // 5. 如果隊列已滿，則等待指定時間
            nanos = notFull.awaitNanos(nanos);
        }
        // 7. 如果隊列未滿，則入隊
        enqueue(e);
        return true;
    } finally {
        // 8. 釋放鎖
        lock.unlock();
    }
}

/**
 * poll方法入口
 */
public E poll() {
    // 1. 加鎖
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        // 2. 如果數組為空，則返回null，否則返回隊列頭部元素
        return (count == 0) ? null : dequeue();
    } finally {
        // 3. 釋放鎖
        lock.unlock();
    }
}

/**
 * 出列
 */
private E dequeue() {
    // 1. 取出隊列頭部元素
    final Object[] items = this.items;
    E x = (E) items[takeIndex];
    // 2. 取出元素后，把該位置置空
    items[takeIndex] = null;
    // 3. 移動takeIndex位置，如果到達數組的末尾就從頭開始
    if (++takeIndex == items.length) {
        takeIndex = 0;
    }
    // 4. 元素個數減一
    count--;
    if (itrs != null) {
        itrs.elementDequeued();
    }
    // 5. 喚醒因為隊列已滿，等待放數據的線程
    notFull.signal();
    return x;
}

/**
 * remove方法入口
 */
public E remove() {
    // 1. 直接調用poll方法
    E x = poll();
    // 2. 如果取到數據，直接返回，否則拋出異常
    if (x != null) {
        return x;
    } else {
        throw new NoSuchElementException();
    }
}

/**
 * take方法入口
 */
public E take() throws InterruptedException {
    // 1. 加可中斷的鎖，防止一直阻塞
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        // 2. 如果數組為空，就一直阻塞，直到被喚醒
        while (count == 0) {
            notEmpty.await();
        }
        // 3. 如果數組不為空，就從數組中取數據
        return dequeue();
    } finally {
        // 4. 釋放鎖
        lock.unlock();
    }
}

/**
 * poll方法入口
 *
 * @param timeout 超時時間
 * @param unit    時間單位
 * @return 元素
 */
public E poll(long timeout, TimeUnit unit) throws InterruptedException {
    // 1. 把超時時間轉換成納秒
    long nanos = unit.toNanos(timeout);
    // 2. 加可中斷的鎖，防止一直阻塞
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        // 3. 如果數組為空，就開始阻塞
        while (count == 0) {
            if (nanos <= 0) {
                // 5. 如果數組為空，且超時時間已過，則返回null
                return null;
            }
            // 4. 阻塞到到指定時間
            nanos = notEmpty.awaitNanos(nanos);
        }
        // 6. 如果數組不為空，則出列
        return dequeue();
    } finally {
        // 7. 釋放鎖
        lock.unlock();
    }
}

/**
 * peek方法入口
 */
public E peek() {
    // 1. 加鎖
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        // 2. 返回數組頭部元素，如果數組為空，則返回null
        return itemAt(takeIndex);
    } finally {
        // 3. 釋放鎖
        lock.unlock();
    }
}

/**
 * 返回當前位置元素
 */
final E itemAt(int i) {
    return (E) items[i];
}

/**
 * element方法入口
 */
public E element() {
    // 1. 調用peek方法查詢數據
    E x = peek();
    // 2. 如果查到數據，直接返回
    if (x != null) {
        return x;
    } else {
        // 3. 如果沒找到，則拋出異常
        throw new NoSuchElementException();
    }
}