AbstractQueue简介: http://donald-draper.iteye.com/blog/2363608
ConcurrentLinkedQueue解析: http://donald-draper.iteye.com/blog/2363874
/* * 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是一个支持消费队列元素,如果为空,则等待,生产元素到队列 ,如果队列满,则等待操作的队列。 * <p><tt>BlockingQueue</tt> 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 * <tt>null</tt> or <tt>false</tt>, 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,依赖于具体的操作,第三种非确定性阻塞当前线程, 直到操作成功,第四种,在取消操作之前,超时阻塞等待条件。四种形式总结如下: 一下是四种处理方法对应的方法 * <p> * <table BORDER CELLPADDING=3 CELLSPACING=1> * <tr> * <td></td> * <td ALIGN=CENTER>[i]Throws exception[/i]</td> * <td ALIGN=CENTER>[i]Special value[/i]</td> * <td ALIGN=CENTER>[i]Blocks[/i]</td> * <td ALIGN=CENTER>[i]Times out[/i]</td> * </tr> * <tr>生产 * <td><b>Insert</b></td> * <td>{@link #add add(e)}</td> * <td>{@link #offer offer(e)}</td> * <td>{@link #put put(e)}</td>阻塞 * <td>{@link #offer(Object, long, TimeUnit) offer(e, time, unit)}</td>超时阻塞 * </tr> * <tr>消费 * <td><b>Remove</b></td> * <td>{@link #remove remove()}</td> * <td>{@link #poll poll()}</td> * <td>{@link #take take()}</td>阻塞 * <td>{@link #poll(long, TimeUnit) poll(time, unit)}</td>超时阻塞 * </tr> * <tr> * <td><b>Examine</b></td> * <td>{@link #element element()}</td> * <td>{@link #peek peek()}</td> * <td>[i]not applicable[/i]</td> * <td>[i]not applicable[/i]</td> * </tr> * </table> * * <p>A <tt>BlockingQueue</tt> does not accept <tt>null</tt> elements. * Implementations throw <tt>NullPointerException</tt> on attempts * to <tt>add</tt>, <tt>put</tt> or <tt>offer</tt> a <tt>null</tt>. A * <tt>null</tt> is used as a sentinel value to indicate failure of * <tt>poll</tt> operations. * BlockingQueue不允许null值元素,当add,put,offer为null时,则抛出空指针异常。 null最为poll失败的标识。 * <p>A <tt>BlockingQueue</tt> may be capacity bounded. At any given * time it may have a <tt>remainingCapacity</tt> beyond which no * additional elements can be <tt>put</tt> without blocking. * A <tt>BlockingQueue</tt> without any intrinsic capacity constraints always * reports a remaining capacity of <tt>Integer.MAX_VALUE</tt>. * BlockingQueue也许是有界的。在任何时候,当要生产的元素大于队列的剩余空间,则阻塞。 BlockingQueue没有严格容量限制,总是报告Integer.MAX_VALUE的剩余容量。 * <p> <tt>BlockingQueue</tt> 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 * <tt>remove(x)</tt>. 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从队列移除一个元素。然而,这种操作在大部分情况下 ,不会被执行,也许偶尔会用,不如当队列消息取消。 * <p> <tt>BlockingQueue</tt> 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 <tt>addAll</tt>, * <tt>containsAll</tt>, <tt>retainAll</tt> and <tt>removeAll</tt> are * [i]not[/i] necessarily performed atomically unless specified * otherwise in an implementation. So it is possible, for example, for * <tt>addAll(c)</tt> to fail (throwing an exception) after adding * only some of the elements in <tt>c</tt>. * BlockingQueue是线程安全的。队列的所有方法都是用内部锁或其他形式的同步控制, 实现高效的原子性操作。然而集合批量操作addAll,containsAll,retainAll,removeAll 是不需要原子性的操作,除非在特殊队列实现中。但是有一个可能,当批量插入时, 如果其中一个插入失败,则抛出异常。 * <p>A <tt>BlockingQueue</tt> 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等操作表示,不允许生产元素。 这种需要我们可以用一种跟着特点单独实现。 * <p> * Usage example, based on a typical producer-consumer scenario. * Note that a <tt>BlockingQueue</tt> can safely be used with multiple * producers and multiple consumers. 典型的生产消费者模式,BlockingQueue可在多个生产者和消费者情况下,线程安全使用。 * <pre> * 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(); * } * } * </pre> * * <p>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]<i>happen-before</i>[/url] * actions subsequent to the access or removal of that element from * the {@code BlockingQueue} in another thread. * 内存一致性,像其他并发集合一样,生产消息发生在另一个消费者消费消息之前。 * <p>This interface is a member of the * <a href="{@docRoot}/../technotes/guides/collections/index.html"> * Java Collections Framework</a>. * * @since 1.5 * @author Doug Lea * @param <E> the type of elements held in this collection */ public interface BlockingQueue<E> extends Queue<E> { /** * Inserts the specified element into this queue if it is possible to do * so immediately without violating capacity restrictions, returning * <tt>true</tt> upon success and throwing an * <tt>IllegalStateException</tt> 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 <tt>true</tt> (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 * <tt>true</tt> upon success and <tt>false</tt> 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 <tt>true</tt> if the element was added to this queue, else * <tt>false</tt> * @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 * <tt>unit</tt> * @param unit a <tt>TimeUnit</tt> determining how to interpret the * <tt>timeout</tt> parameter * @return <tt>true</tt> if successful, or <tt>false</tt> 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 * <tt>unit</tt> * @param unit a <tt>TimeUnit</tt> determining how to interpret the * <tt>timeout</tt> parameter * @return the head of this queue, or <tt>null</tt> 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 <tt>Integer.MAX_VALUE</tt> if there is no intrinsic * limit. * 在没有阻塞的情况下,队列可以添加的元素,即剩余容量 * <p>Note that you [i]cannot[/i] always tell if an attempt to insert * an element will succeed by inspecting <tt>remainingCapacity</tt> * 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 <tt>e</tt> such * that <tt>o.equals(e)</tt>, if this queue contains one or more such * elements. 从队列中移除一个元素 * Returns <tt>true</tt> 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 <tt>true</tt> 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 <tt>true</tt> if this queue contains the specified element. * More formally, returns <tt>true</tt> if and only if this queue contains * at least one element <tt>e</tt> such that <tt>o.equals(e)</tt>. * 判断队列中是否包含元素,队列中至少有一个元素与之相等,则返回true * @param o object to be checked for containment in this queue * @return <tt>true</tt> 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 <tt>c</tt> 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 * <tt>IllegalArgumentException</tt>. 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<? super E> 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 <tt>c</tt> 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 * <tt>IllegalArgumentException</tt>. 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<? super E> c, int maxElements); }