- 浏览: 950463 次
文章分类
- 全部博客 (428)
- Hadoop (2)
- HBase (1)
- ELK (1)
- ActiveMQ (13)
- Kafka (5)
- Redis (14)
- Dubbo (1)
- Memcached (5)
- Netty (56)
- Mina (34)
- NIO (51)
- JUC (53)
- Spring (13)
- Mybatis (17)
- MySQL (21)
- JDBC (12)
- C3P0 (5)
- Tomcat (13)
- SLF4J-log4j (9)
- P6Spy (4)
- Quartz (12)
- Zabbix (7)
- JAVA (9)
- Linux (15)
- HTML (9)
- Lucene (0)
- JS (2)
- WebService (1)
- Maven (4)
- Oracle&MSSQL (14)
- iText (11)
- Development Tools (8)
- UTILS (4)
- LIFE (8)
最新评论
-
Donald_Draper:
Donald_Draper 写道刘落落cici 写道能给我发一 ...
DatagramChannelImpl 解析三(多播) -
Donald_Draper:
刘落落cici 写道能给我发一份这个类的源码吗Datagram ...
DatagramChannelImpl 解析三(多播) -
lyfyouyun:
请问楼主,执行消息发送的时候,报错:Transport sch ...
ActiveMQ连接工厂、连接详解 -
ezlhq:
关于 PollArrayWrapper 状态含义猜测:参考 S ...
WindowsSelectorImpl解析一(FdMap,PollArrayWrapper) -
flyfeifei66:
打算使用xmemcache作为memcache的客户端,由于x ...
Memcached分布式客户端(Xmemcached)
Queue接口定义:http://donald-draper.iteye.com/blog/2363491
AbstractQueue简介:http://donald-draper.iteye.com/blog/2363608
ConcurrentLinkedQueue解析:http://donald-draper.iteye.com/blog/2363874
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); }
发表评论
-
Executors解析
2017-04-07 14:38 1197ThreadPoolExecutor解析一(核心线程池数量、线 ... -
ScheduledThreadPoolExecutor解析三(关闭线程池)
2017-04-06 20:52 4400ScheduledThreadPoolExecutor解析一( ... -
ScheduledThreadPoolExecutor解析二(任务调度)
2017-04-06 12:56 2067ScheduledThreadPoolExecutor解析一( ... -
ScheduledThreadPoolExecutor解析一(调度任务,任务队列)
2017-04-04 22:59 4908Executor接口的定义:http://donald-dra ... -
ThreadPoolExecutor解析四(线程池关闭)
2017-04-03 23:02 9025Executor接口的定义:http: ... -
ThreadPoolExecutor解析三(线程池执行提交任务)
2017-04-03 12:06 6020Executor接口的定义:http://donald-dra ... -
ThreadPoolExecutor解析二(线程工厂、工作线程,拒绝策略等)
2017-04-01 17:12 2982Executor接口的定义:http://donald-dra ... -
ThreadPoolExecutor解析一(核心线程池数量、线程池状态等)
2017-03-31 22:01 20458Executor接口的定义:http://donald-dra ... -
ScheduledExecutorService接口定义
2017-03-29 12:53 1444Executor接口的定义:http://donald-dra ... -
AbstractExecutorService解析
2017-03-29 08:27 1009Executor接口的定义:http: ... -
ExecutorCompletionService解析
2017-03-28 14:27 1513Executor接口的定义:http://donald-dra ... -
CompletionService接口定义
2017-03-28 12:39 997Executor接口的定义:http://donald-dra ... -
FutureTask解析
2017-03-27 12:59 1269package java.util.concurrent; ... -
Future接口定义
2017-03-26 09:40 1124/* * Written by Doug Lea with ... -
ExecutorService接口定义
2017-03-25 22:14 1106Executor接口的定义:http://donald-dra ... -
Executor接口的定义
2017-03-24 23:24 1590package java.util.concurrent; ... -
简单测试线程池拒绝执行任务策略
2017-03-24 22:37 1955线程池多余任务的拒绝执行策略有四中,分别是直接丢弃任务Disc ... -
JAVA集合类简单综述
2017-03-23 22:51 869Queue接口定义:http://donald-draper. ... -
DelayQueue解析
2017-03-23 11:00 1672Queue接口定义:http://donald-draper. ... -
SynchronousQueue解析下-TransferQueue
2017-03-22 22:20 2081Queue接口定义:http://donald-draper. ...
相关推荐
线程----BlockingQueue 的介绍说明
在新增的Concurrent包中,BlockingQueue很好的解决了多线程中,如何高效安全“传输”数据的问题。通过这些高效并且线程安全的队列类,为我们快速搭建高质量的多线程程序带来极大的便利。本文详细介绍了BlockingQueue...
BlockingQueue java 的工具类,初次要用于消费者,生产者的同步问题。
类似java BlockingQueue,C++写的,支持Windows与Linux。
简单实现BlockingQueue,BlockingQueue源码详解
定义全局线程池,将用户的请求放入自定义队列中,排队等候线程调用,等待超时则自动取消该任务,实现超时可取消的异步任务
本文简要介绍下BlockingQueue接口中几个方法的作用及区别。 boolean add(E e) (1)在不违反容量限制的情况下,可立即将指定元素插入此队列,成功返回true。 (2)当无可用空间时候,抛出IllegalStateException异常 ...
这个demo主要讲解了BlockingQueue的使用希望可以帮户需要的同学.
14-阻塞队列BlockingQueue实战及其原理分析二.pdf
BlockingQueue是一种特殊的Queue,若BlockingQueue是空的,从BlockingQueue取东西的操作将会被阻断进入等待状态直到BlocingkQueue进了新货才会被唤醒,下面是用BlockingQueue来实现Producer和Consumer的例子
10、阻塞队列BlockingQueue实战及其原理分析_
java中线程队列BlockingQueue的用法
主要介绍了Java多线程Queue、BlockingQueue和使用BlockingQueue实现生产消费者模型方法解析,涉及queue,BlockingQueue等有关内容,具有一定参考价值,需要的朋友可以参考。
BlockingQueue支持两个附加操作的Queue:1)当Queue为空时,获取元素线程被阻塞直到Queue变为非空;2)当Queue满时,添加元素线程被阻塞直到Queue不满。BlockingQueue不允许元素为null,如果入队一个null元素,会抛...
本篇文章小编为大家介绍,基于java中BlockingQueue的使用介绍。需要的朋友参考下
Java-concurrent-collections-concurrenthashmap-blockingqueue.pdf
6.6 阻塞队列BlockingQueue 实战及其原 理分析一副本.mp4
主要介绍了java 中 阻塞队列BlockingQueue详解及实例的相关资料,需要的朋友可以参考下
6.7 阻塞队列BlockingQueue 实战及其原 理分析二副本.mp4
6.6 阻塞队列BlockingQueue 实战及其原 理分析一副本副本.mp4