前言

本文隶属于专栏《100个问题搞定Java并发》,该专栏为笔者原创,引用请注明来源,不足和错误之处请在评论区帮忙指出,谢谢!

本专栏目录结构和参考文献请见100个问题搞定Java并发

思维导图

在这里插入图片描述

正文

类注释

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.
 *
 * <p>{@code 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
 * {@code null} or {@code 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:
 *
 * <table BORDER CELLPADDING=3 CELLSPACING=1>
 * <caption>Summary of BlockingQueue methods</caption>
 *  <tr>
 *    <td></td>
 *    <td ALIGN=CENTER><em>Throws exception</em></td>
 *    <td ALIGN=CENTER><em>Special value</em></td>
 *    <td ALIGN=CENTER><em>Blocks</em></td>
 *    <td ALIGN=CENTER><em>Times out</em></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><em>not applicable</em></td>
 *    <td><em>not applicable</em></td>
 *  </tr>
 * </table>
 *
 * <p>A {@code BlockingQueue} does not accept {@code null} elements.
 * Implementations throw {@code NullPointerException} on attempts
 * to {@code add}, {@code put} or {@code offer} a {@code null}.  A
 * {@code null} is used as a sentinel value to indicate failure of
 * {@code poll} operations.
 *
 * <p>A {@code BlockingQueue} may be capacity bounded. At any given
 * time it may have a {@code remainingCapacity} beyond which no
 * additional elements can be {@code put} without blocking.
 * A {@code BlockingQueue} without any intrinsic capacity constraints always
 * reports a remaining capacity of {@code Integer.MAX_VALUE}.
 *
 * <p>{@code 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
 * {@code remove(x)}. However, such operations are in general
 * <em>not</em> performed very efficiently, and are intended for only
 * occasional use, such as when a queued message is cancelled.
 *
 * <p>{@code BlockingQueue} implementations are thread-safe.  All
 * queuing methods achieve their effects atomically using internal
 * locks or other forms of concurrency control. However, the
 * <em>bulk</em> Collection operations {@code addAll},
 * {@code containsAll}, {@code retainAll} and {@code removeAll} are
 * <em>not</em> necessarily performed atomically unless specified
 * otherwise in an implementation. So it is possible, for example, for
 * {@code addAll(c)} to fail (throwing an exception) after adding
 * only some of the elements in {@code c}.
 *
 * <p>A {@code BlockingQueue} does <em>not</em> intrinsically support
 * any kind of &quot;close&quot; or &quot;shutdown&quot; 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
 * <em>end-of-stream</em> or <em>poison</em> objects, that are
 * interpreted accordingly when taken by consumers.
 *
 * <p>
 * Usage example, based on a typical producer-consumer scenario.
 * Note that a {@code BlockingQueue} can safely be used with multiple
 * producers and multiple consumers.
 *  <pre> {@code
 * 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}
 * <a href="package-summary.html#MemoryVisibility"><i>happen-before</i></a>
 * 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> {

看起来注释好长,实际上就讲了下面几点:

1. BlockingQueue 是什么?

BlockingQueue 是一种队列,它还支持在检索元素时等待队列变为非空,在存储元素时等待队列中的空间变为可用的操作。

2. BlockingQueue方法有哪些形式?

BlockingQueue方法有四种形式,有不同的处理操作的方法,这些操作不能立即满足,但在将来的某个时候可能会满足:

  1. 抛出异常
  2. 返回特殊值(null或false,取决于操作)
  3. 线程无限期地阻塞当前线程,直到操作成功
  4. 线程在放弃之前只阻塞给定的最大时间限制。

在这里插入图片描述

3. BlockingQueue不接受空元素

实现在尝试添加、放置或提供null时抛出NullPointerException。

null用作哨兵值,以指示轮询操作失败。

4. 阻塞队列可能有容量限制

在任何给定的时间,它都可能有一个剩余容量,超过这个容量,就不能不阻塞地放置额外的元素。

没有任何内在容量约束的 BlockingQueue 始终报告 Integer.MAX_VALUE 值的剩余容量。

5. BlockingQueue 实现主要用于生产者-消费者队列,但还支持java.util.Collection 接口

因此,例如,可以使用 remove() 从队列中删除任意元素。

然而,这样的操作通常不是非常有效地执行的,并且仅用于偶尔使用,例如当队列消息被取消时。

6. BlockingQueue 实现是线程安全的。

所有排队方法都使用内部锁或其他形式的并发控制以原子方式实现其效果。

但是,除非在实现中另有规定,否则批量收集操作 addAll 、 containsAll 、 retainal 和 removeAll 不一定以原子方式执行。

因此,例如, addAll( c ) 在只添加 c 中的一些元素之后失败(引发异常)是可能的。

7. BlockingQueue 本质上不支持任何类型的 close 或 shutdown 操作,以指示不再添加任何项目

这些特性的需求和使用往往取决于实现。

例如,一种常见的策略是生产商插入特殊的 end-of-stream 或“毒丸”(poison)对象,当消费者使用这些对象时,会相应地进行解释。

8. 使用示例

基于典型的生产者-消费者场景。

请注意, 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();
   }
 }}

9. 内存一致性影响

与其他并发集合一样,在将对象放入 BlockingQueue 之前,线程中的操作发生在另一个线程中从 BlockingQueue 访问或移除该元素之后的操作之前。

add

    /**
     * Inserts the specified element into this queue if it is possible to do
     * so immediately without violating capacity restrictions, returning
     * {@code true} upon success and throwing an
     * {@code IllegalStateException} if no space is currently available.
     * When using a capacity-restricted queue, it is generally preferable to
     * use {@link #offer(Object) offer}.
     *
     * @param e the element to add
     * @return {@code 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);


如果可以在不违反容量限制的情况下立即将指定元素插入此队列,则会在成功时返回 true ,如果当前没有可用空间,则会引发 IllegalStateException 。

当使用容量受限队列时,通常最好使用 offer 。

异常

  1. IllegalStateException –如果此时由于容量限制而无法添加元素
  2. ClassCastException –如果指定元素的类阻止将其添加到此队列中
  3. NullPointerException –如果指定的元素为 null
  4. IllegalArgumentException –如果指定元素的某些属性阻止将其添加到此队列中。

offer


    /**
     * Inserts the specified element into this queue if it is possible to do
     * so immediately without violating capacity restrictions, returning
     * {@code true} upon success and {@code 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.
     *
     * @param e the element to add
     * @return {@code true} if the element was added to this queue, else
     *         {@code 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);

如果可以在不违反容量限制的情况下立即将指定元素插入此队列,则在成功时返回 true ,如果当前没有可用空间,则返回 false 。

当使用容量受限队列时,此方法通常比 add 更可取,因为 add 只能通过抛出异常来插入元素。

异常

  1. ClassCastException –如果指定元素的类阻止将其添加到此队列中
  2. NullPointerException –如果指定的元素为 null
  3. IllegalArgumentException –如果指定元素的某些属性阻止将其添加到此队列中

put


    /**
     * 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;

将指定的元素插入此队列,如有必要,等待空间变为可用。

异常

  1. InterruptedException–如果在等待时中断
  2. ClassCastException–如果指定元素的类阻止将其添加到此队列中
  3. NullPointerException–如果指定的元素为null
  4. IllegalArgumentException–如果指定元素的某些属性阻止将其添加到此队列中

offer + timeout

    /**
     * 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
     *        {@code unit}
     * @param unit a {@code TimeUnit} determining how to interpret the
     *        {@code timeout} parameter
     * @return {@code true} if successful, or {@code 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;

将指定的元素插入此队列,如果需要空间可用,请等待指定的等待时间。

异常

  1. InterruptedException–如果在等待时中断
  2. ClassCastException–如果指定元素的类阻止将其添加到此队列中
  3. NullPointerException–如果指定的元素为null
  4. IllegalArgumentException–如果指定元素的某些属性阻止将其添加到此队列中

take

    /**
     * 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;

检索并删除此队列的头,如有必要,等待元素可用。

异常

  1. InterruptedException–如果在等待时中断

poll + timeout

    /**
     * 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
     *        {@code unit}
     * @param unit a {@code TimeUnit} determining how to interpret the
     *        {@code timeout} parameter
     * @return the head of this queue, or {@code 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;

检索并删除此队列的头,如果需要元素变为可用,则等待指定的等待时间。

异常

  1. InterruptedException–如果在等待时中断

remainingCapacity

    /**
     * Returns the number of additional elements that this queue can ideally
     * (in the absence of memory or resource constraints) accept without
     * blocking, or {@code Integer.MAX_VALUE} if there is no intrinsic
     * limit.
     *
     * <p>Note that you <em>cannot</em> always tell if an attempt to insert
     * an element will succeed by inspecting {@code remainingCapacity}
     * because it may be the case that another thread is about to
     * insert or remove an element.
     *
     * @return the remaining capacity
     */
    int remainingCapacity();

返回此队列理想情况下(在没有内存或资源约束的情况下)可以不阻塞地接受的其他元素的数量,或者如果没有内在限制,返回 Integer.MAX_VALUE 值。

请注意,您不能总是通过检查 remainingCapacity 来判断插入元素的尝试是否成功,因为可能是另一个线程即将插入或删除元素。

remove

    /**
     * Removes a single instance of the specified element from this queue,
     * if it is present.  More formally, removes an element {@code e} such
     * that {@code o.equals(e)}, if this queue contains one or more such
     * elements.
     * Returns {@code 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 {@code 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
     *         (<a href="../Collection.html#optional-restrictions">optional</a>)
     * @throws NullPointerException if the specified element is null
     *         (<a href="../Collection.html#optional-restrictions">optional</a>)
     */
    boolean remove(Object o);

从该队列中删除指定元素的单个实例(如果存在)。

更正式地说,如果此队列包含一个或多个这样的元素,则删除元素e,使o.equals(e)。

如果此队列包含指定的元素,则返回true(如果此队列因调用而更改,则返回等效值)。

异常

  1. ClassCastException–如果指定元素的类与此队列不兼容(可选)
  2. NullPointerException–如果指定的元素为null(可选)
  3. UnsupportedOperationException–如果此集合不支持删除操作

contains

    /**
     * Returns {@code true} if this queue contains the specified element.
     * More formally, returns {@code true} if and only if this queue contains
     * at least one element {@code e} such that {@code o.equals(e)}.
     *
     * @param o object to be checked for containment in this queue
     * @return {@code true} if this queue contains the specified element
     * @throws ClassCastException if the class of the specified element
     *         is incompatible with this queue
     *         (<a href="../Collection.html#optional-restrictions">optional</a>)
     * @throws NullPointerException if the specified element is null
     *         (<a href="../Collection.html#optional-restrictions">optional</a>)
     */
    public boolean contains(Object o);

如果此队列包含指定的元素,则返回true。

更正式地说,当且仅当此队列包含至少一个元素e,使得o.equals(e)时,返回true。

异常

  1. ClassCastException–如果指定元素的类与此队列不兼容(可选)
  2. NullPointerException–如果指定的元素为null(可选)

drainTo

    /**
     * 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 {@code 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
     * {@code IllegalArgumentException}. Further, the behavior of
     * this operation is undefined if the specified collection is
     * modified while the operation is in progress.
     *
     * @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);

从此队列中删除所有可用元素并将它们添加到给定集合。

此操作可能比重复轮询此队列更有效。

尝试将元素添加到集合c时遇到的故障可能会导致在引发关联异常时元素既不在集合中,也不在集合中或同时在集合中。

尝试将队列排入自身会导致IllegalArgumentException。

此外,如果在操作进行过程中修改了指定的集合,则此操作的行为是未定义的。

异常

  1. UnsupportedOperationException–如果指定集合不支持添加元素
  2. ClassCastException–如果此队列元素的类阻止将其添加到指定集合中
  3. NullPointerException–如果指定的集合为null
  4. IllegalArgumentException–如果指定集合是此队列,或者此队列元素的某些属性阻止将其添加到指定集合中

drainTo + maxElements

    /**
     * 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 {@code 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
     * {@code IllegalArgumentException}. Further, the behavior of
     * this operation is undefined if the specified collection is
     * modified while the operation is in progress.
     *
     * @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);
}

从该队列中最多移除给定数量的可用元素,并将它们添加到给定集合中。

尝试将元素添加到集合c时遇到的故障可能会导致在引发关联异常时元素既不在集合中,也不在集合中或同时在集合中。

尝试将队列排入自身会导致IllegalArgumentException。

此外,如果在操作进行过程中修改了指定的集合,则此操作的行为是未定义的。

异常

  1. UnsupportedOperationException–如果指定集合不支持添加元素
  2. ClassCastException–如果此队列元素的类阻止将其添加到指定集合中
  3. NullPointerException–如果指定的集合为null
  4. IllegalArgumentException–如果指定集合是此队列,或者此队列元素的某些属性阻止将其添加到指定集合中
上一篇 下一篇