java.util.concurrent中文API

---

 概述  软件包 类 使用 树 已过时 索引 帮助 Java^TM Platform
Standard Ed. 6 上一个软件包   下一个软件包

 

---

软件包 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

---

概述  软件包 类 使用 树 已过时 索引 帮助 Java^TM Platform
Standard Ed. 6 上一个软件包   下一个软件包

 

---