/** The queued items **/
  final Object[] items;
  /** items index for next take, poll, peek or remove **/
  int takeIndex;
  /** items index for next put, offer, or add **/
  int putIndex;
  /** Number of elements in the queue **/
  int count;
  /**
   * Concurrency control uses the classic two-condition algorithm
   * found in any textbook.
   **/
  /** Main lock guarding all access **/
  final ReentrantLock lock;
  /** Condition for waiting takes **/
  private final Condition notEmpty;
  /** Condition for waiting puts **/
  private final Condition notFull;
  /**
   * Shared state for currently active iterators, or null if there
   * are known not to be any. Allows queue operations to update
   * iterator state.
   **/
  transient Itrs itrs = null;

  /**
   * Inserts the specified element at the tail of this queue, waiting
   * for space to become available if the queue is full.
   * @throws InterruptedException {@inheritDoc}
   * @throws NullPointerException {@inheritDoc}
   **/
  public void put(E e) throws InterruptedException {
    checkNotNull(e);
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
      while (count == items.length)
        notFull.await();
      enqueue(e);
    } finally {
      lock.unlock();
    }
  }
  /**
   * Inserts element at current put position, advances, and signals.
   * Call only when holding lock.
   **/
  private void enqueue(E x) {
    // assert lock.getHoldCount() == 1;
    // assert items[putIndex] == null;
    final Object[] items = this.items;
    items[putIndex] = x;
    if (++putIndex == items.length)
      putIndex = 0;
    count++;
    notEmpty.signal();
  }

  /**
   * Inserts the specified element at the tail of this queue if it is
   * possible to do so immediately without exceeding the queue's capacity,
   * returning {@code true} upon success and {@code false} if this queue
   * is full. This method is generally preferable to method {@link #add},
   * which can fail to insert an element only by throwing an exception.
   * @throws NullPointerException if the specified element is null
   **/
  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();
    }
  }

  public E take() throws InterruptedException {
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
      while (count == 0)
        notEmpty.await();
      return dequeue();
    } finally {
      lock.unlock();
    }
  }