BlockingQueue接口的定义

Queue接口定义：[url]http://donald-draper.iteye.com/blog/2363491[/url]
AbstractQueue简介：[url]http://donald-draper.iteye.com/blog/2363608[/url]
ConcurrentLinkedQueue解析：[url]http://donald-draper.iteye.com/blog/2363874[/url]

/*
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 * Written by Doug Lea with assistance from members of JCP JSR-166
 * Expert Group and released to the public domain, as explained at
 * http://creativecommons.org/publicdomain/zero/1.0/
 */
package java.util.concurrent;

import java.util.Collection;
import java.util.Queue;

/**
 * A {@link java.util.Queue} that additionally supports operations
 * that wait for the queue to become non-empty when retrieving an
 * element, and wait for space to become available in the queue when
 * storing an element.
 *
BlockingQueue是一个支持消费队列元素，如果为空，则等待，生产元素到队列
，如果队列满，则等待操作的队列。
 * 
BlockingQueue methods come in four forms, with different ways
 * of handling operations that cannot be satisfied immediately, but may be
 * satisfied at some point in the future:
 * one throws an exception, the second returns a special value (either
 * null or false, depending on the operation), the third
 * blocks the current thread indefinitely until the operation can succeed,
 * and the fourth blocks for only a given maximum time limit before giving
 * up.  These methods are summarized in the following table:
 *
BlockingQueue有四种形式的操作，不同方式操作，当在处理过程中，操作不能满足，
也许会在将来的某个时刻满足：
一种抛出异常，第二种返回null或false，依赖于具体的操作，第三种非确定性阻塞当前线程，
直到操作成功，第四种，在取消操作之前，超时阻塞等待条件。四种形式总结如下：
一下是四种处理方法对应的方法
 * 

 * 
 *  
 *    
 *    
 *    
 *    
 *    
 *  
 *  生产
 *    
 *    
 *    
 *    阻塞
 *    超时阻塞
 *  
 *  消费
 *    
 *    
 *    
 *    阻塞
 *    超时阻塞
 *  
 *  
 *    
 *    
 *    
 *    
 *    
 *  
 * 
[i]Throws exception[/i]
[i]Special value[/i]
[i]Blocks[/i]
[i]Times out[/i]
Insert
{@link #add add(e)}
{@link #offer offer(e)}
{@link #put put(e)}
{@link #offer(Object, long, TimeUnit) offer(e, time, unit)}
Remove
{@link #remove remove()}
{@link #poll poll()}
{@link #take take()}
{@link #poll(long, TimeUnit) poll(time, unit)}
Examine
{@link #element element()}
{@link #peek peek()}
[i]not applicable[/i]
[i]not applicable[/i]
 *
 * 
A BlockingQueue does not accept null elements.
 * Implementations throw NullPointerException on attempts
 * to add, put or offer a null.  A
 * null is used as a sentinel value to indicate failure of
 * poll operations.
 *
BlockingQueue不允许null值元素，当add，put，offer为null时，则抛出空指针异常。
null最为poll失败的标识。
 * 
A BlockingQueue may be capacity bounded. At any given
 * time it may have a remainingCapacity beyond which no
 * additional elements can be put without blocking.
 * A BlockingQueue without any intrinsic capacity constraints always
 * reports a remaining capacity of Integer.MAX_VALUE.
 *
BlockingQueue也许是有界的。在任何时候，当要生产的元素大于队列的剩余空间，则阻塞。
BlockingQueue没有严格容量限制，总是报告Integer.MAX_VALUE的剩余容量。
 * 
 BlockingQueue implementations are designed to be used
 * primarily for producer-consumer queues, but additionally support
 * the {@link java.util.Collection} interface.  So, for example, it is
 * possible to remove an arbitrary element from a queue using
 * remove(x). However, such operations are in general
 * [i]not[/i] performed very efficiently, and are intended for only
 * occasional use, such as when a queued message is cancelled.
 *
BlockingQueue被设计用于生产消费者队列场景，同时支持Collection接口的相关操作。
BlockingQueue可能会用remove从队列移除一个元素。然而，这种操作在大部分情况下
，不会被执行，也许偶尔会用，不如当队列消息取消。
 * 
 BlockingQueue implementations are thread-safe.  All
 * queuing methods achieve their effects atomically using internal
 * locks or other forms of concurrency control. However, the
 * [i]bulk[/i] Collection operations addAll,
 * containsAll, retainAll and removeAll are
 * [i]not[/i] necessarily performed atomically unless specified
 * otherwise in an implementation. So it is possible, for example, for
 * addAll(c) to fail (throwing an exception) after adding
 * only some of the elements in c.
 *
BlockingQueue是线程安全的。队列的所有方法都是用内部锁或其他形式的同步控制，
实现高效的原子性操作。然而集合批量操作addAll，containsAll，retainAll，removeAll
是不需要原子性的操作，除非在特殊队列实现中。但是有一个可能，当批量插入时，
如果其中一个插入失败，则抛出异常。
 * 
A BlockingQueue does [i]not[/i] intrinsically support
 * any kind of "close" or "shutdown" operation to
 * indicate that no more items will be added.  The needs and usage of
 * such features tend to be implementation-dependent. For example, a
 * common tactic is for producers to insert special
 * [i]end-of-stream[/i] or [i]poison[/i] objects, that are
 * interpreted accordingly when taken by consumers.
 *
BlockingQueue本质上是不支持close和shutdown等操作表示，不允许生产元素。
这种需要我们可以用一种跟着特点单独实现。
 * 

 * Usage example, based on a typical producer-consumer scenario.
 * Note that a BlockingQueue can safely be used with multiple
 * producers and multiple consumers.
 典型的生产消费者模式，BlockingQueue可在多个生产者和消费者情况下，线程安全使用。
 * 

 * class Producer implements Runnable {
 *   private final BlockingQueue queue;
 *   Producer(BlockingQueue q) { queue = q; }
 *   public void run() {
 *     try {
 *       while (true) { queue.put(produce()); }
 *     } catch (InterruptedException ex) { ... handle ...}
 *   }
 *   Object produce() { ... }
 * }
 *
 * class Consumer implements Runnable {
 *   private final BlockingQueue queue;
 *   Consumer(BlockingQueue q) { queue = q; }
 *   public void run() {
 *     try {
 *       while (true) { consume(queue.take()); }
 *     } catch (InterruptedException ex) { ... handle ...}
 *   }
 *   void consume(Object x) { ... }
 * }
 *
 * class Setup {
 *   void main() {
 *     BlockingQueue q = new SomeQueueImplementation();
 *     Producer p = new Producer(q);
 *     Consumer c1 = new Consumer(q);
 *     Consumer c2 = new Consumer(q);
 *     new Thread(p).start();
 *     new Thread(c1).start();
 *     new Thread(c2).start();
 *   }
 * }
 * 
 *
 * 
Memory consistency effects: As with other concurrent
 * collections, actions in a thread prior to placing an object into a
 * {@code BlockingQueue}
 * [url=package-summary.html#MemoryVisibility]happen-before[/url]
 * actions subsequent to the access or removal of that element from
 * the {@code BlockingQueue} in another thread.
 *
 内存一致性，像其他并发集合一样，生产消息发生在另一个消费者消费消息之前。
 * 
This interface is a member of the
 * 
 * Java Collections Framework.
 *
 * @since 1.5
 * @author Doug Lea
 * @param  the type of elements held in this collection
 */
public interface BlockingQueue extends Queue {
    /**
     * Inserts the specified element into this queue if it is possible to do
     * so immediately without violating capacity restrictions, returning
     * true upon success and throwing an
     * IllegalStateException if no space is currently available.
     * When using a capacity-restricted queue, it is generally preferable to
     * use {@link #offer(Object) offer}.
     *
     如果在队列容量没满的情况下，添加元素，立即成功，并返回true，如果队列
     没有空间可利用，则抛出异常，一般情况下，最好用offer方法。
     * @param e the element to add
     * @return true (as specified by {@link Collection#add})
     * @throws IllegalStateException if the element cannot be added at this
     *         time due to capacity restrictions
     * @throws ClassCastException if the class of the specified element
     *         prevents it from being added to this queue
     * @throws NullPointerException if the specified element is null
     * @throws IllegalArgumentException if some property of the specified
     *         element prevents it from being added to this queue
     */
    boolean add(E e);

    /**
     * Inserts the specified element into this queue if it is possible to do
     * so immediately without violating capacity restrictions, returning
     * true upon success and false if no space is currently
     * available.  When using a capacity-restricted queue, this method is
     * generally preferable to {@link #add}, which can fail to insert an
     * element only by throwing an exception.
     *
     如果在队列容量没满的情况下，添加元素，立即成功，并返回true，如果队列
     没有空间可利用，则返回false。在队列有界的情况下，一般用add方法，失败则
     仅仅抛出异常。
     * @param e the element to add
     * @return true if the element was added to this queue, else
     *         false
     * @throws ClassCastException if the class of the specified element
     *         prevents it from being added to this queue
     * @throws NullPointerException if the specified element is null
     * @throws IllegalArgumentException if some property of the specified
     *         element prevents it from being added to this queue
     */
    boolean offer(E e);

    /**
     * Inserts the specified element into this queue, waiting if necessary
     * for space to become available.
     *
     插入元素到队列中，如果无空间可利用，则等待队列空间可用条件
     * @param e the element to add
     * @throws InterruptedException if interrupted while waiting
     * @throws ClassCastException if the class of the specified element
     *         prevents it from being added to this queue
     * @throws NullPointerException if the specified element is null
     * @throws IllegalArgumentException if some property of the specified
     *         element prevents it from being added to this queue
     */
    void put(E e) throws InterruptedException;

    /**
     * Inserts the specified element into this queue, waiting up to the
     * specified wait time if necessary for space to become available.
     *
     插入元素到队列中，如果无空间可利用，则超时等待队列空间可用条件
     * @param e the element to add
     * @param timeout how long to wait before giving up, in units of
     *        unit
     * @param unit a TimeUnit determining how to interpret the
     *        timeout parameter
     * @return true if successful, or false if
     *         the specified waiting time elapses before space is available
     * @throws InterruptedException if interrupted while waiting
     * @throws ClassCastException if the class of the specified element
     *         prevents it from being added to this queue
     * @throws NullPointerException if the specified element is null
     * @throws IllegalArgumentException if some property of the specified
     *         element prevents it from being added to this queue
     */
    boolean offer(E e, long timeout, TimeUnit unit)
        throws InterruptedException;

    /**
     * Retrieves and removes the head of this queue, waiting if necessary
     * until an element becomes available.
     *
    从队列头部消费一个元素，如果队列为空，则等待队列不为空条件
     * @return the head of this queue
     * @throws InterruptedException if interrupted while waiting
     */
    E take() throws InterruptedException;

    /**
     * Retrieves and removes the head of this queue, waiting up to the
     * specified wait time if necessary for an element to become available.
     *
      从队列头部消费一个元素，如果队列为空，则超时等待队列不为空条件
     * @param timeout how long to wait before giving up, in units of
     *        unit
     * @param unit a TimeUnit determining how to interpret the
     *        timeout parameter
     * @return the head of this queue, or null if the
     *         specified waiting time elapses before an element is available
     * @throws InterruptedException if interrupted while waiting
     */
    E poll(long timeout, TimeUnit unit)
        throws InterruptedException;

    /**
     * Returns the number of additional elements that this queue can ideally
     * (in the absence of memory or resource constraints) accept without
     * blocking, or Integer.MAX_VALUE if there is no intrinsic
     * limit.
     *
     在没有阻塞的情况下，队列可以添加的元素，即剩余容量
     * 
Note that you [i]cannot[/i] always tell if an attempt to insert
     * an element will succeed by inspecting remainingCapacity
     * because it may be the case that another thread is about to
     * insert or remove an element.
     *
     * @return the remaining capacity
     */
    int remainingCapacity();

    /**
     * Removes a single instance of the specified element from this queue,
     * if it is present.  More formally, removes an element e such
     * that o.equals(e), if this queue contains one or more such
     * elements.
     从队列中移除一个元素
     * Returns true if this queue contained the specified element
     * (or equivalently, if this queue changed as a result of the call).
     *
     * @param o element to be removed from this queue, if present
     * @return true if this queue changed as a result of the call
     * @throws ClassCastException if the class of the specified element
     *         is incompatible with this queue
     *         ([url=../Collection.html#optional-restrictions]optional[/url])
     * @throws NullPointerException if the specified element is null
     *         ([url=../Collection.html#optional-restrictions]optional[/url])
     */
    boolean remove(Object o);

    /**
     * Returns true if this queue contains the specified element.
     * More formally, returns true if and only if this queue contains
     * at least one element e such that o.equals(e).
     *
     判断队列中是否包含元素，队列中至少有一个元素与之相等，则返回true
     * @param o object to be checked for containment in this queue
     * @return true if this queue contains the specified element
     * @throws ClassCastException if the class of the specified element
     *         is incompatible with this queue
     *         ([url=../Collection.html#optional-restrictions]optional[/url])
     * @throws NullPointerException if the specified element is null
     *         ([url=../Collection.html#optional-restrictions]optional[/url])
     */
    public boolean contains(Object o);

    /**
     * Removes all available elements from this queue and adds them
     * to the given collection.  This operation may be more
     * efficient than repeatedly polling this queue.  A failure
     * encountered while attempting to add elements to
     * collection c may result in elements being in neither,
     * either or both collections when the associated exception is
     * thrown.  Attempts to drain a queue to itself result in
     * IllegalArgumentException. Further, the behavior of
     * this operation is undefined if the specified collection is
     * modified while the operation is in progress.
     *
     移除队列中所有的元素，并添加到给定的集合中。则个操作也许比重入的
     poll更有效。当在将元素添加到集合中时，如果有失败，则抛出关联的异常。
     尝试将队列drain到自己，则将抛出非法参数异常。进一步说，在操作集合的过程中，
     集合被修改，则drain的结果将是不确定的。
     * @param c the collection to transfer elements into
     * @return the number of elements transferred
     * @throws UnsupportedOperationException if addition of elements
     *         is not supported by the specified collection
     * @throws ClassCastException if the class of an element of this queue
     *         prevents it from being added to the specified collection
     * @throws NullPointerException if the specified collection is null
     * @throws IllegalArgumentException if the specified collection is this
     *         queue, or some property of an element of this queue prevents
     *         it from being added to the specified collection
     */
    int drainTo(Collection c);

    /**
     * Removes at most the given number of available elements from
     * this queue and adds them to the given collection.  A failure
     * encountered while attempting to add elements to
     * collection c may result in elements being in neither,
     * either or both collections when the associated exception is
     * thrown.  Attempts to drain a queue to itself result in
     * IllegalArgumentException. Further, the behavior of
     * this operation is undefined if the specified collection is
     * modified while the operation is in progress.
     *
     移除队列中最多maxElements的元素，并添加到给定的集合中。
     * @param c the collection to transfer elements into
     * @param maxElements the maximum number of elements to transfer
     * @return the number of elements transferred
     * @throws UnsupportedOperationException if addition of elements
     *         is not supported by the specified collection
     * @throws ClassCastException if the class of an element of this queue
     *         prevents it from being added to the specified collection
     * @throws NullPointerException if the specified collection is null
     * @throws IllegalArgumentException if the specified collection is this
     *         queue, or some property of an element of this queue prevents
     *         it from being added to the specified collection
     */
    int drainTo(Collection c, int maxElements);
}