方法

1. 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 throwing an IllegalStateException if no space is currently available. When using a capacity-restricted queue, it is generally preferable to use offer.
2. boolean offer(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 add(E), which can fail to insert an element only by throwing an exception.
3. void put(E e) throws InterruptedException;
   Inserts the specified element into this queue,** waiting if necessary for space to become available.**
4. boolean offer(E e, long timeout, TimeUnit unit) throws InterruptedException;
   Inserts the specified element into this queue, waiting up to the specified wait time if necessary for space to become available.
5. E take() throws InterruptedException;
   Retrieves and removes the head of this queue, waiting if necessary until an element becomes available
6. E poll(long timeout, TimeUnit unit) 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.
7. int remainingCapacity();
   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 cannot 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.
8. boolean remove(Object o);
   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).
9. boolean contains(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).
10. int drainTo(Collection<? super E> c);
    排水管
    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.
11. int drainTo(Collection<? super E> c, int maxElements);

整体描述

主要为生产者，消费者而设计的
BlockingQueue implementations are designed to be used primarily for producer-consumer queues, but additionally support the Collection interface.

msg cancelled
So, for example, it is possible to remove an arbitrary element from a queue using remove(x). However, such operations are in general not performed very efficiently, and are intended for only occasional use, such as when a queued message is cancelled.

线程安全的
BlockingQueue implementations are thread-safe. All queuing methods achieve their effects atomically using internal locks or other forms of concurrency control.

However, the bulk Collection operations addAll, containsAll, retainAll and removeAll are not 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.

不支持 close
A BlockingQueue does not 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 end-of-stream or poison objects, that are interpreted accordingly when taken by consumers.

生产者，消费者
Usage example, based on a typical producer-consumer scenario. Note that a BlockingQueue can safely be used with multiple producers and multiple consumers.

不断的生产：

 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) { ... }
 }

go：

 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();
   }
 }}