软件包 java.util.concurrent使用说明

软件包 java.util.concurrent

在并发编程中很常用的实用工具类。

请参见： 
          描述

 

接口摘要
BlockingDeque<E>	支持两个附加操作的 Queue，这两个操作是：获取元素时等待双端队列变为非空；存储元素时等待双端队列中的空间变得可用。
BlockingQueue<E>	支持两个附加操作的 Queue，这两个操作是：获取元素时等待队列变为非空，以及存储元素时等待空间变得可用。
Callable<V>	返回结果并且可能抛出异常的任务。
CompletionService<V>	将生产新的异步任务与使用已完成任务的结果分离开来的服务。
ConcurrentMap<K,V>	提供其他原子 putIfAbsent、remove、replace 方法的 Map。
ConcurrentNavigableMap<K,V>	支持 NavigableMap 操作，且以递归方式支持其可导航子映射的 ConcurrentMap。
Delayed	一种混合风格的接口，用来标记那些应该在给定延迟时间之后执行的对象。
Executor	执行已提交的 Runnable 任务的对象。
ExecutorService	Executor 提供了管理终止的方法，以及可为跟踪一个或多个异步任务执行状况而生成 Future 的方法。
Future<V>	Future 表示异步计算的结果。
RejectedExecutionHandler	无法由 ThreadPoolExecutor 执行的任务的处理程序。
RunnableFuture<V>	作为 Runnable 的 Future。
RunnableScheduledFuture<V>	作为 Runnable 的 ScheduledFuture。
ScheduledExecutorService	一个 ExecutorService，可安排在给定的延迟后运行或定期执行的命令。
ScheduledFuture<V>	一个延迟的、结果可接受的操作，可将其取消。
ThreadFactory	根据需要创建新线程的对象。

 

 

类摘要
AbstractExecutorService	提供 ExecutorService 执行方法的默认实现。
ArrayBlockingQueue<E>	一个由数组支持的有界阻塞队列。
ConcurrentHashMap<K,V>	支持获取的完全并发和更新的所期望可调整并发的哈希表。
ConcurrentLinkedQueue<E>	一个基于链接节点的无界线程安全队列。
ConcurrentSkipListMap<K,V>	可缩放的并发 ConcurrentNavigableMap 实现。
ConcurrentSkipListSet<E>	一个基于 ConcurrentSkipListMap 的可缩放并发 NavigableSet 实现。
CopyOnWriteArrayList<E>	ArrayList 的一个线程安全的变体，其中所有可变操作（add、set 等等）都是通过对底层数组进行一次新的复制来实现的。
CopyOnWriteArraySet<E>	对其所有操作使用内部 CopyOnWriteArrayList 的 Set。
CountDownLatch	一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。
CyclicBarrier	一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。
DelayQueue<E extends Delayed>	Delayed 元素的一个无界阻塞队列，只有在延迟期满时才能从中提取元素。
Exchanger<V>	可以在对中对元素进行配对和交换的线程的同步点。
ExecutorCompletionService<V>	使用提供的 Executor 来执行任务的 CompletionService。
Executors	此包中所定义的 Executor、ExecutorService、ScheduledExecutorService、ThreadFactory 和 Callable 类的工厂和实用方法。
FutureTask<V>	可取消的异步计算。
LinkedBlockingDeque<E>	一个基于已链接节点的、任选范围的阻塞双端队列。
LinkedBlockingQueue<E>	一个基于已链接节点的、范围任意的 blocking queue。
PriorityBlockingQueue<E>	一个无界阻塞队列，它使用与类 PriorityQueue 相同的顺序规则，并且提供了阻塞获取操作。
ScheduledThreadPoolExecutor	ThreadPoolExecutor，它可另行安排在给定的延迟后运行命令，或者定期执行命令。
Semaphore	一个计数信号量。
SynchronousQueue<E>	一种阻塞队列，其中每个插入操作必须等待另一个线程的对应移除操作 ，反之亦然。
ThreadPoolExecutor	一个 ExecutorService，它使用可能的几个池线程之一执行每个提交的任务，通常使用 Executors 工厂方法配置。
ThreadPoolExecutor.AbortPolicy	用于被拒绝任务的处理程序，它将抛出 RejectedExecutionException.
ThreadPoolExecutor.CallerRunsPolicy	用于被拒绝任务的处理程序，它直接在 execute 方法的调用线程中运行被拒绝的任务；如果执行程序已关闭，则会丢弃该任务。
ThreadPoolExecutor.DiscardOldestPolicy	用于被拒绝任务的处理程序，它放弃最旧的未处理请求，然后重试 execute；如果执行程序已关闭，则会丢弃该任务。
ThreadPoolExecutor.DiscardPolicy	用于被拒绝任务的处理程序，默认情况下它将丢弃被拒绝的任务。

 

 

枚举摘要
TimeUnit	TimeUnit 表示给定单元粒度的时间段，它提供在这些单元中进行跨单元转换和执行计时及延迟操作的实用工具方法。

 

 

异常摘要
BrokenBarrierException	当某个线程试图等待处于断开状态的 barrier 时，或者 barrier 进入断开状态而线程处于等待状态时，抛出该异常。
CancellationException	如果某项值生成任务（如 FutureTask）的结果因为任务被取消而无法获取到，则抛出该异常。
ExecutionException	当试图获取已通过抛出异常而中止的任务的结果时，抛出此异常。
RejectedExecutionException	当无法执行某个任务时,由 Executor 抛出的异常。
TimeoutException	阻塞操作超时时，抛出该异常。

 

软件包 java.util.concurrent 的描述

 

在并发编程中很常用的实用工具类。此包包括了几个小的、已标准化的可扩展框架，以及一些提供有用功能的类，没有这些类，这些功能会很难实现或实现起来冗长乏味。下面简要描述主要的组件。另请参阅 locks 和 atomic 包。

执行程序

接口。 Executor 是一个简单的标准化接口，用于定义类似于线程的自定义子系统，包括线程池、异步 IO 和轻量级任务框架。根据所使用的具体 Executor 类的不同，可能在新创建的线程中，现有的任务执行线程中，或者调用  execute() 的线程中执行任务，并且可能顺序或并发执行。 ExecutorService 提供了多个完整的异步任务执行框架。ExecutorService 管理任务的排队和安排，并允许受控制的关闭。 ScheduledExecutorService子接口及相关的接口添加了对延迟的和定期任务执行的支持。ExecutorService 提供了安排异步执行的方法，可执行由  Callable 表示的任何函数，结果类似于  Runnable。 Future 返回函数的结果，允许确定执行是否完成，并提供取消执行的方法。 RunnableFuture 是拥有  run 方法的 Future， run 方法执行时将设置其结果。

实现。类 ThreadPoolExecutor 和 ScheduledThreadPoolExecutor 提供可调的、灵活的线程池。Executors 类提供大多数 Executor 的常见类型和配置的工厂方法，以及使用它们的几种实用工具方法。其他基于 Executor 的实用工具包括具体类 FutureTask，它提供 Future 的常见可扩展实现，以及ExecutorCompletionService，它有助于协调对异步任务组的处理。

队列

java.util.concurrent  ConcurrentLinkedQueue 类提供了高效的、可伸缩的、线程安全的非阻塞 FIFO 队列。java.util.concurrent 中的五个实现都支持扩展的  BlockingQueue 接口，该接口定义了 put 和 take 的阻塞版本： LinkedBlockingQueue、 ArrayBlockingQueue、 SynchronousQueue、 PriorityBlockingQueue和  DelayQueue。这些不同的类覆盖了生产者-使用者、消息传递、并行任务执行和相关并发设计的大多数常见使用的上下文。 BlockingDeque 接口扩展 BlockingQueue，以支持 FIFO 和 LIFO（基于堆栈）操作。 LinkedBlockingDeque 类提供一个实现。

计时

TimeUnit 类为指定和控制基于超时的操作提供了多重粒度（包括纳秒级）。该包中的大多数类除了包含不确定的等待之外，还包含基于超时的操作。在使用超时的所有情况中，超时指定了在表明已超时前该方法应该等待的最少时间。在超时发生后，实现会“尽力”检测超时。但是，在检测超时与超时之后再次实际执行线程之间可能要经过不确定的时间。接受超时期参数的所有方法将小于等于 0 的值视为根本不会等待。要“永远”等待，可以使用 Long.MAX_VALUE 值。

同步器

四个类可协助实现常见的专用同步语句。 Semaphore 是一个经典的并发工具。 CountDownLatch 是一个极其简单但又极其常用的实用工具，用于在保持给定数目的信号、事件或条件前阻塞执行。 CyclicBarrier 是一个可重置的多路同步点，在某些并行编程风格中很有用。 Exchanger 允许两个线程在 collection 点交换对象，它在多流水线设计中是有用的。

并发 Collection

除队列外，此包还提供了设计用于多线程上下文中的 Collection 实现： ConcurrentHashMap、 ConcurrentSkipListMap、 ConcurrentSkipListSet、 CopyOnWriteArrayList 和  CopyOnWriteArraySet。当期望许多线程访问一个给定 collection 时， ConcurrentHashMap 通常优于同步的  HashMap， ConcurrentSkipListMap 通常优于同步的  TreeMap。当期望的读数和遍历远远大于列表的更新数时， CopyOnWriteArrayList 优于同步的  ArrayList。

此包中与某些类一起使用的“Concurrent&rdquo前缀;是一种简写，表明与类似的“同步”类有所不同。例如，java.util.Hashtable 和Collections.synchronizedMap(new HashMap()) 是同步的，但 ConcurrentHashMap 则是“并发的”。并发 collection 是线程安全的，但是不受单个排他锁的管理。在 ConcurrentHashMap 这一特定情况下，它可以安全地允许进行任意数目的并发读取，以及数目可调的并发写入。需要通过单个锁不允许对 collection 的所有访问时，“同步”类是很有用的，其代价是较差的可伸缩性。在期望多个线程访问公共 collection 的其他情况中，通常“并发”版本要更好一些。当 collection 是未共享的，或者仅保持其他锁时 collection 是可访问的情况下，非同步 collection 则要更好一些。

大多数并发 Collection 实现（包括大多数 Queue）与常规的 java.util 约定也不同，因为它们的迭代器提供了弱一致的，而不是快速失败的遍历。弱一致的迭代器是线程安全的，但是在迭代时没有必要冻结 collection，所以它不一定反映自迭代器创建以来的所有更新。

内存一致性属性

Java Language Specification 第 17 章定义了内存操作（如共享变量的读写）的  happen-before 关系。只有写入操作  happen-before 读取操作时，才保证一个线程写入的结果对另一个线程的读取是可视的。 synchronized 和  volatile 构造  happen-before 关系， Thread.start() 和  Thread.join() 方法形成 happen-before 关系。尤其是：

• 线程中的每个操作 happen-before 稍后按程序顺序传入的该线程中的每个操作。
• 一个解除锁监视器的（synchronized 阻塞或方法退出）happen-before 相同监视器的每个后续锁（synchronized 阻塞或方法进入）。并且因为happen-before 关系是可传递的，所以解除锁定之前的线程的所有操作 happen-before 锁定该监视器的任何线程后续的所有操作。
• 写入 volatile 字段 happen-before 每个后续读取相同字段。volatile 字段的读取和写入与进入和退出监视器具有相似的内存一致性效果，但不需要互斥锁。
• 在线程上调用 start happen-before 已启动的线程中的任何线程。
• 线程中的所有操作 happen-before 从该线程上的 join 成功返回的任何其他线程。

java.util.concurrent 中所有类的方法及其子包扩展了这些对更高级别同步的保证。尤其是：

• 线程中将一个对象放入任何并发 collection 之前的操作 happen-before 从另一线程中的 collection 访问或移除该元素的后续操作。
• 线程中向 Executor 提交 Runnable 之前的操作 happen-before 其执行开始。同样适用于向 ExecutorService 提交 Callables。
• 异步计算（由 Future 表示）所采取的操作 happen-before 通过另一线程中 Future.get() 获取结果后续的操作。
• “释放”同步储存方法（如 Lock.unlock、Semaphore.release 和 CountDownLatch.countDown）之前的操作 happen-before 另一线程中相同同步储存对象成功“获取”方法（如 Lock.lock、Semaphore.acquire、Condition.await 和 CountDownLatch.await）的后续操作。
• 对于通过 Exchanger 成功交换对象的每个线程对，每个线程中 exchange() 之前的操作 happen-before 另一线程中对应 exchange() 后续的操作。
• 调用 CyclicBarrier.await 之前的操作 happen-before 屏障操作所执行的操作，屏障操作所执行的操作 happen-before 从另一线程中对应 await成功返回的后续操作。

 

 

从以下版本开始：

1.5

概述   软件包  类  使用  树  已过时  索引  帮助		JavaTM Platform Standard Ed. 6
上一个软件包   下一个软件包	框架    无框架    所有类

提交错误或意见
有关更多的 API 参考资料和开发人员文档，请参阅 Java SE 开发人员文档。该文档包含更详细的、面向开发人员的描述，以及总体概述、术语定义、使用技巧和工作代码示例。

版权所有 2007 Sun Microsystems, Inc. 保留所有权利。 请遵守许可证条款。另请参阅文档重新分发政策。