Java并发——BlockingQueue阻塞队列(九)

public interface BlockingQueue<E> extends Queue<E> 

public interface BlockingQueue<E> extends Queue<E> {
   /**
     * 入队一个元素，如果有空间则直接插入，并返回true；
     * 如果没有空间则抛出IllegalStateException
     */
    boolean add(E e);

    /**
     * 入队一个元素，如果有空间则直接插入，并返回true；
     * 如果没有空间返回false
     */
    boolean offer(E e);

    /**
     * 入队一个元素，如果有空间则直接插入，如果没有空间则一直阻塞等待
     */
    void put(E e) throws InterruptedException;

    /**
     * 入队一个元素，如果有空间则直接插入，并返回true；
     * 如果没有空间则等待timeout时间，插入失败则返回false
     */
    boolean offer(E e, long timeout, TimeUnit unit)
        throws InterruptedException;

    /**
     * 出队一个元素，如果存在则直接出队，如果没有空间则一直阻塞等待
     */
    E take() throws InterruptedException;

    /**
     * 出队一个元素，如果存在则直接出队，如果没有空间则等待timeout时间，无元素则返回null
     */
    E poll(long timeout, TimeUnit unit)
        throws InterruptedException;
    
    /**
     * 返回该队列剩余的容量（如果没有限制则返回Integer.MAX_VALUE）
     */
    int remainingCapacity();

    /**
     * 如果元素o在队列中存在，则从队列中删除
     */
    boolean remove(Object o);

    /**
     * 判断队列中是否存在元素o
     */
    public boolean contains(Object o);
    
    /**
     * 将队列中的所有元素出队，并添加到给定的集合c中，返回出队的元素数量
     */
    int drainTo(Collection<? super E> c);

    /**
     * 将队列中的元素出队，限制数量maxElements个，并添加到给定的集合c中，返回出队的元素数量
     */
    int drainTo(Collection<? super E> c, int maxElements);
}

   final ReentrantLock lock;

    /** Condition for waiting takes */
    private final Condition notEmpty;

    /** Condition for waiting puts */
    private final Condition notFull;

    /**
     * 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 {
            //count 等于数组的长度,代表已经满了，进行阻塞等待
            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();
    }

 public E take() throws InterruptedException {
     //加锁（可响应中断）
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            //队列为空则阻塞
            while (count == 0)
                notEmpty.await();
            //出队
            return dequeue();
        } finally {
            lock.unlock();
        }
    }

public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

    /**
     * Inserts the specified element at the tail of this queue.
     * As the queue is unbounded, this method will never return {@code false}.
     *
     * @return {@code true} (as specified by {@link Queue#offer})
     * @throws NullPointerException if the specified element is null
     */
    public boolean offer(E e) {
        checkNotNull(e);
        final Node<E> newNode = new Node<E>(e);
        //循环
        for (Node<E> t = tail, p = t;;) {
            Node<E> q = p.next;
            if (q == null) {
                // p is last node
                if (p.casNext(null, newNode)) {
                    // Successful CAS is the linearization point
                    // for e to become an element of this queue,
                    // and for newNode to become "live".
                    if (p != t) // hop two nodes at a time
                        casTail(t, newNode);  // Failure is OK.
                    return true;
                }
                // Lost CAS race to another thread; re-read next
            }
            else if (p == q)
                // We have fallen off list.  If tail is unchanged, it
                // will also be off-list, in which case we need to
                // jump to head, from which all live nodes are always
                // reachable.  Else the new tail is a better bet.
                p = (t != (t = tail)) ? t : head;
            else
                // Check for tail updates after two hops.
                p = (p != t && t != (t = tail)) ? t : q;
        }
    }

     boolean casNext(Node<E> cmp, Node<E> val) {
            return UNSAFE.compareAndSwapObject(this, nextOffset, cmp, val);
        }