public void testArrayBlockingQueue() throws InterruptedException {
  // 创建ArrayBlockingQueue实例，设置队列大小为10
  BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);
  boolean r1 = queue.add(1);          // 使用add方法入队元素，如果无空间则抛出异常
  boolean r2 = queue.offer(2);       // 使用offer方法入队元素
  queue.put(3);                      // 使用put方法入队元素；如果无空间则会一直阻塞
  boolean r3 = queue.offer(4, 30, TimeUnit.SECONDS);  // 使用offer方法入队元素；如果无空间则会等待30s

  Integer o1 = queue.remove();        // 使用remove方法出队元素，如果无元素则抛出异常
  Integer o2 = queue.poll();          // 使用poll方法出队元素 
  Integer o3 = queue.take();          // 使用take方法出队元素；如果无元素则一直阻塞
  Integer o4 = queue.poll(10, TimeUnit.SECONDS);       // 使用poll方法出队元素； 如果无空间则等待10s
}

public class ArrayBlockingQueue<E> extends AbstractQueue<E>
        implements BlockingQueue<E>, java.io.Serializable {
  /** 使用数组存储队列中的元素 */
  final Object[] items;
  /** 下一个出队元素在items数组中的索引 */
  int takeIndex;
  /** 下一个出队元素需要存放在items数组中的索引 */
  int putIndex;
  /** 队列中的元素数量 */
  int count;
  /** 使用在许多教科书中能找到的经典的`双Condition算法`进行并发控制 */
  /** 使用独占锁ReetrantLock */
  final ReentrantLock lock;
  /** 等待出队的条件 */
  private final Condition notEmpty;
  /** 等待入队的条件 */
  private final Condition notFull;
}

/** 指定队列元素数量capacity，并使用非公平锁进行并发控制 */
public ArrayBlockingQueue(int capacity) {
  this(capacity, false);
}

/** 指定队列元素数量capacity，并通过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(); // 初始化入队条件
}

/**
     * 在当前位置插入元素，并修改索引值，并唤醒非空队列的线程
     * 只有在获取锁的情况才会调用
     */
    private void enqueue(E x) {
        final Object[] items = this.items;
        // 将元素插入到putIndex处
        items[putIndex] = x;
        // 修改putIndex索引
        if (++putIndex == items.length)
            // 如果修改后putIndex超出items数组最大索引，则指向索引0处
            putIndex = 0;
        // 元素数量+1
        count++;
        // 唤醒一个非空队列中的线程
        notEmpty.signal();
    }

/**
     * 在当前位置获取一个元素，并修改索引值，并唤醒非满队列的线程
     * 只有在获取锁的情况下才会调用
     */
    private E dequeue() {
        final Object[] items = this.items;
        // 获取当前索引处元素
        E x = (E) items[takeIndex];
        // 将当前索引处置为空
        items[takeIndex] = null;
        // 修改takeIndex索引
        if (++takeIndex == items.length)
            // 如果修改后takeIndex超出items数组最大索引，则指向索引0处
            takeIndex = 0;
        // 元素数量-1
        count--;
        if (itrs != null)
            itrs.elementDequeued();
       // 唤醒一个非满队列中的线程
        notFull.signal();
        return x;
    }

public void put(E e) throws InterruptedException {
        checkNotNull(e);
        final ReentrantLock lock = this.lock;
        // 加锁
        lock.lockInterruptibly();
        try {
            while (count == items.length) {
              // 如果队列已满，线程阻塞，并添加到notFull条件队列中等待唤醒
              notFull.await();
            }
            // 如果队列未满，则调用enqueue方法进行入队操作
            enqueue(e);
        } finally {
            // 释放锁
            lock.unlock();
        }
    }

public E take() throws InterruptedException {
        final ReentrantLock lock = this.lock;
        // 加锁
        lock.lockInterruptibly();
        try {
            while (count == 0)
                // 判断队列是否为空，如果为空则线程阻塞，添加到notEmpty条件队列等待
                notEmpty.await();
            // 队列不为空，进行出队操作
            return dequeue();
        } finally {
            // 释放锁
            lock.unlock();
        }
    }

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)
                    // 入队队列满，等待时间为0，则入队失败，返回false
                    return false;
                // 如果队列满，等待时间大于0，且未到等待时间，则继续等待nanos
                nanos = notFull.awaitNanos(nanos);
            }
            // 队列不满，进行入队操作
            enqueue(e);
            return true;
        } finally {
            // 释放锁
            lock.unlock();
        }
    }