/** 儲(chǔ)存隊(duì)列的中元素 */
  final Object[] items;

  /** 隊(duì)列頭的位置 */
  int takeIndex;

  /** 隊(duì)列尾的位置 */
  int putIndex;

  /** 當(dāng)前隊(duì)列擁有的元素個(gè)數(shù) */
  int count;

  /** 用來(lái)保證多線程操作共享變量的安全問(wèn)題 */
  final ReentrantLock lock;

  /** 當(dāng)隊(duì)列為空時(shí)，就會(huì)調(diào)用notEmpty的wait方法，讓當(dāng)前線程等待 */
  private final Condition notEmpty;

  /** 當(dāng)隊(duì)列為滿時(shí)，就會(huì)調(diào)用notFull的wait方法，讓當(dāng)前線程等待 */
  private final Condition notFull;

  // 調(diào)用AbstractQueue父類中的方法。
  public boolean add(E e) {
    // 通過(guò)調(diào)用offer來(lái)時(shí)實(shí)現(xiàn)
    if (offer(e))
      return true;
    else
      throw new IllegalStateException("Queue full");
  }

  //向隊(duì)列末尾新添加元素。返回true表示添加成功，false表示添加失敗，不會(huì)拋出異常
  public boolean offer(E e) {
    checkNotNull(e);
    final ReentrantLock lock = this.lock;
    // 使用lock來(lái)保證，多線程修改成員屬性的安全
    lock.lock();
    try {
      // 隊(duì)列已滿，添加元素失敗，返回false。
      if (count == items.length)
        return false;
      else {
        // 調(diào)用enqueue方法將元素插入隊(duì)列中
        enqueue(e);
        return true;
      }
    } finally {
      lock.unlock();
    }
  }

  // 向隊(duì)列末尾新添加元素，如果隊(duì)列已滿，當(dāng)前線程就等待。響應(yīng)中斷異常
  public void put(E e) throws InterruptedException {
    checkNotNull(e);
    final ReentrantLock lock = this.lock;
    // 使用lock來(lái)保證，多線程修改成員屬性的安全
    lock.lockInterruptibly();
    try {
      // 隊(duì)列已滿，則調(diào)用notFull.await()方法，讓當(dāng)前線程等待，直到隊(duì)列不是滿的
      while (count == items.length)
        notFull.await();
      // 調(diào)用enqueue方法將元素插入隊(duì)列中
      enqueue(e);
    } finally {
      lock.unlock();
    }
  }

/**
   * 向隊(duì)列末尾新添加元素，如果隊(duì)列中沒(méi)有可用空間，當(dāng)前線程就等待，
   * 如果等待時(shí)間超過(guò)timeout了，那么返回false，表示添加失敗
   */
  public boolean offer(E e, long timeout, TimeUnit unit)
    throws InterruptedException {

    checkNotNull(e);
    // 計(jì)算一共最多等待的時(shí)間值nanos
    long nanos = unit.toNanos(timeout);
    final ReentrantLock lock = this.lock;
    // 使用lock來(lái)保證，多線程修改成員屬性的安全
    lock.lockInterruptibly();
    try {
      // 隊(duì)列已滿
      while (count == items.length) {
        // nanos <= 0表示最大等待時(shí)間已到，那么不用再等待了，返回false，表示添加失敗。
        if (nanos <= 0)
          return false;
        // 調(diào)用notFull.awaitNanos(nanos)方法,超時(shí)nanos時(shí)間會(huì)被自動(dòng)喚醒，
        // 如果被提前喚醒，那么返回剩余的時(shí)間
        nanos = notFull.awaitNanos(nanos);
      }
      // 調(diào)用enqueue方法將元素插入隊(duì)列中
      enqueue(e);
      return true;
    } finally {
      lock.unlock();
    }
  }

  // 調(diào)用AbstractQueue父類中的方法。
  public E remove() {
    // 通過(guò)調(diào)用poll來(lái)時(shí)實(shí)現(xiàn)
    E x = poll();
    if (x != null)
      return x;
    else
      throw new NoSuchElementException();
  }

// 刪除隊(duì)列第一個(gè)元素(即隊(duì)列頭)，并返回它。如果隊(duì)列是空的，它不會(huì)拋出異常，而是會(huì)返回null。
  public E poll() {
    final ReentrantLock lock = this.lock;
    // 使用lock來(lái)保證，多線程修改成員屬性的安全
    lock.lock();
    try {
      // 如果count == 0，列表為空，就返回null，否則調(diào)用dequeue方法，返回列表頭元素
      return (count == 0) ? null : dequeue();
    } finally {
      lock.unlock();
    }
  }

  /**
   * 返回并移除隊(duì)列第一個(gè)元素，如果隊(duì)列是空的，就前線程就等待。響應(yīng)中斷異常
   */
  public E take() throws InterruptedException {
    final ReentrantLock lock = this.lock;
    // 使用lock來(lái)保證，多線程修改成員屬性的安全
    lock.lockInterruptibly();
    try {
      // 如果隊(duì)列為空，就調(diào)用notEmpty.await()方法，讓當(dāng)前線程等待。
      // 直到有別的線程向隊(duì)列中插入元素，那么這個(gè)線程會(huì)被喚醒。
      while (count == 0)
        notEmpty.await();
      // 調(diào)用dequeue方法，返回列表頭元素
      return dequeue();
    } finally {
      lock.unlock();
    }
  }

  /**
   * 返回并移除隊(duì)列第一個(gè)元素，如果隊(duì)列是空的，就前線程就等待。
   * 如果等待時(shí)間超過(guò)timeout了，那么返回false，表示獲取元素失敗
   */
  public E poll(long timeout, TimeUnit unit) throws InterruptedException {
    // 計(jì)算一共最多等待的時(shí)間值nanos
    long nanos = unit.toNanos(timeout);
    final ReentrantLock lock = this.lock;
    // 使用lock來(lái)保證，多線程修改成員屬性的安全
    lock.lockInterruptibly();
    try {
      // 隊(duì)列為空
      while (count == 0) {
        // nanos <= 0表示最大等待時(shí)間已到，那么不用再等待了，返回null。
        if (nanos <= 0)
          return null;
        // 調(diào)用notEmpty.awaitNanos(nanos)方法讓檔期線程等待，并設(shè)置超時(shí)時(shí)間。
        nanos = notEmpty.awaitNanos(nanos);
      }
      // 調(diào)用dequeue方法，返回列表頭元素
      return dequeue();
    } finally {
      lock.unlock();
    }
  }

  // 調(diào)用AbstractQueue父類中的方法。
  public E element() {
    E x = peek();
    if (x != null)
      return x;
    else
      throw new NoSuchElementException();
  }

  // 查看隊(duì)列頭元素
  public E peek() {
    final ReentrantLock lock = this.lock;
    // 使用lock來(lái)保證，多線程修改成員屬性的安全
    lock.lock();
    try {
      // 返回當(dāng)前隊(duì)列頭的元素
      return itemAt(takeIndex); // null when queue is empty
    } finally {
      lock.unlock();
    }
  }

  // 將元素x插入隊(duì)列尾
  private void enqueue(E x) {
    // assert lock.getHoldCount() == 1;
    // assert items[putIndex] == null; //當(dāng)前putIndex位置元素一定是null
    final Object[] items = this.items;
    items[putIndex] = x;
    // 如果putIndex等于items.length，那么將putIndex重新設(shè)置為0
    if (++putIndex == items.length)
      putIndex = 0;
    // 隊(duì)列數(shù)量加一
    count++;
    // 因?yàn)椴迦胍粋€(gè)元素，那么當(dāng)前隊(duì)列肯定不為空，那么喚醒在notEmpty條件下等待的一個(gè)線程
    notEmpty.signal();
  }

  // 刪除隊(duì)列頭的元素，返回它
  private E dequeue() {
    // assert lock.getHoldCount() == 1;
    // assert items[takeIndex] != null;

    final Object[] items = this.items;
    // 得到當(dāng)前隊(duì)列頭的元素
    @SuppressWarnings("unchecked")
    E x = (E) items[takeIndex];
    // 將當(dāng)前隊(duì)列頭位置設(shè)置為null
    items[takeIndex] = null;
    if (++takeIndex == items.length)
      takeIndex = 0;
    // 隊(duì)列數(shù)量減一
    count--;
    if (itrs != null)
      itrs.elementDequeued();
    // 因?yàn)閯h除了一個(gè)元素，那么隊(duì)列肯定不滿了，那么喚醒在notFull條件下等待的一個(gè)線程
    notFull.signal();
    return x;
  }

  // 刪除隊(duì)列中對(duì)象o元素，最多刪除一條
  public boolean remove(Object o) {
    if (o == null) return false;
    final Object[] items = this.items;
    // 使用lock來(lái)保證，多線程修改成員屬性的安全
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
      // 當(dāng)隊(duì)列中有值的時(shí)候，才進(jìn)行刪除。
      if (count > 0) {
        // 隊(duì)列尾下一個(gè)位置
        final int putIndex = this.putIndex;
        // 隊(duì)列頭的位置
        int i = takeIndex;
        do {
          // 當(dāng)前位置元素與被刪除元素相同
          if (o.equals(items[i])) {
            // 刪除i位置元素
            removeAt(i);
            // 返回true
            return true;
          }
          if (++i == items.length)
            i = 0;
          // 當(dāng)i==putIndex表示遍歷完所有元素
        } while (i != putIndex);
      }
      return false;
    } finally {
      lock.unlock();
    }
  }

  // 刪除隊(duì)列removeIndex位置的元素
  void removeAt(final int removeIndex) {
    // assert lock.getHoldCount() == 1;
    // assert items[removeIndex] != null;
    // assert removeIndex >= 0 && removeIndex < items.length;
    final Object[] items = this.items;
    // 表示刪除元素是列表頭，就容易多了，與dequeue方法流程差不多
    if (removeIndex == takeIndex) {
      // 移除removeIndex位置元素
      items[takeIndex] = null;
      // 到了數(shù)組末尾，就要轉(zhuǎn)到數(shù)組頭位置
      if (++takeIndex == items.length)
        takeIndex = 0;
      // 隊(duì)列數(shù)量減一
      count--;
      if (itrs != null)
        itrs.elementDequeued();
    } else {
      // an "interior" remove

      final int putIndex = this.putIndex;
      for (int i = removeIndex;;) {
        int next = i + 1;
        if (next == items.length)
          next = 0;
        // 還沒(méi)有到隊(duì)列尾，那么就將后一個(gè)位置元素覆蓋前一個(gè)位置的元素
        if (next != putIndex) {
          items[i] = items[next];
          i = next;
        } else {
          // 將隊(duì)列尾元素置位null
          items[i] = null;
          // 重新設(shè)置putIndex的值
          this.putIndex = i;
          break;
        }
      }
      // 隊(duì)列數(shù)量減一
      count--;
      if (itrs != null)
        itrs.removedAt(removeIndex);
    }
    // 因?yàn)閯h除了一個(gè)元素，那么隊(duì)列肯定不滿了，那么喚醒在notFull條件下等待的一個(gè)線程
    notFull.signal();
  }