java.util.concurrent

Utility classes commonly useful in concurrent programming. This package includes a few small standardized extensible frameworks, as well as some classes that provide useful functionality and are otherwise tedious or difficult to implement. Here are brief descriptions of the main components. See also the java.util.concurrent.locks and java.util.concurrent.atomic packages.

Executors

Interfaces. Executor is a simple standardized interface for defining custom thread-like subsystems, including thread pools, asynchronous I/O, and lightweight task frameworks. Depending on which concrete Executor class is being used, tasks may execute in a newly created thread, an existing task-execution thread, or the thread calling execute, and may execute sequentially or concurrently. ExecutorService provides a more complete asynchronous task execution framework. An ExecutorService manages queuing and scheduling of tasks, and allows controlled shutdown. The ScheduledExecutorService subinterface and associated interfaces add support for delayed and periodic task execution. ExecutorServices provide methods arranging asynchronous execution of any function expressed as Callable, the result-bearing analog of Runnable. A Future returns the results of a function, allows determination of whether execution has completed, and provides a means to cancel execution. A RunnableFuture is a Future that possesses a run method that upon execution, sets its results.

实现。 类ThreadPoolExecutor和ScheduledThreadPoolExecutor提供可调整的灵活线程池。 Executors类为Executors的最常见类型和配置提供工厂方法，以及使用它们的一些实用方法。 基于Executors其他实用程序包括具体的类FutureTask提供Futures的通用可扩展实现， ExecutorCompletionService ，它协助协调处理异步任务组。

ForkJoinPool类提供了一个Executor，主要用于处理ForkJoinTask及其子类的实例。 这些类使用工作窃取调度程序，可以获得高吞吐量，以执行符合经常用于计算密集型并行处理的限制的任务。

Queues

The ConcurrentLinkedQueue class supplies an efficient scalable thread-safe non-blocking FIFO queue. The ConcurrentLinkedDeque class is similar, but additionally supports the Deque interface.

五个实现都java.util.concurrent支持扩展BlockingQueue接口中，定义阻塞put和take的版本： LinkedBlockingQueue ， ArrayBlockingQueue ， SynchronousQueue ， PriorityBlockingQueue ，并DelayQueue 。 不同的类涵盖了生产者 - 消费者，消息传递，并行任务和相关并发设计的最常见使用情境。

扩展接口 TransferQueue ，和实施 LinkedTransferQueue引入同步 transfer方法，其中，生产商可以可选地等待块其消费者（以及相关的功能一起）。

BlockingDeque接口扩展BlockingQueue以支持FIFO和LIFO（基于堆栈）操作。 LinkedBlockingDeque类提供了一个实现。

Timing

The TimeUnit class provides multiple granularities (including nanoseconds) for specifying and controlling time-out based operations. Most classes in the package contain operations based on time-outs in addition to indefinite waits. In all cases that time-outs are used, the time-out specifies the minimum time that the method should wait before indicating that it timed-out. Implementations make a "best effort" to detect time-outs as soon as possible after they occur. However, an indefinite amount of time may elapse between a time-out being detected and a thread actually executing again after that time-out. All methods that accept timeout parameters treat values less than or equal to zero to mean not to wait at all. To wait "forever", you can use a value of Long.MAX_VALUE.

Synchronizers

Five classes aid common special-purpose synchronization idioms.

• Semaphore is a classic concurrency tool.
• CountDownLatch is a very simple yet very common utility for blocking until a given number of signals, events, or conditions hold.
• A CyclicBarrier is a resettable multiway synchronization point useful in some styles of parallel programming.
• A Phaser provides a more flexible form of barrier that may be used to control phased computation among multiple threads.
• An Exchanger allows two threads to exchange objects at a rendezvous point, and is useful in several pipeline designs.

Concurrent Collections

Besides Queues, this package supplies Collection implementations designed for use in multithreaded contexts: ConcurrentHashMap, ConcurrentSkipListMap, ConcurrentSkipListSet, CopyOnWriteArrayList, and CopyOnWriteArraySet. When many threads are expected to access a given collection, a ConcurrentHashMap is normally preferable to a synchronized HashMap, and a ConcurrentSkipListMap is normally preferable to a synchronized TreeMap. A CopyOnWriteArrayList is preferable to a synchronized ArrayList when the expected number of reads and traversals greatly outnumber the number of updates to a list.

与此包中的某些类一起使用的“并发”前缀是一种简写，表示与类似的“同步”类有几处不同之处。 例如java.util.Hashtable和Collections.synchronizedMap(new HashMap())是同步的。 但是ConcurrentHashMap是“并发”的。 并发集合是线程安全的，但不受单个排除锁定的控制。 在ConcurrentHashMap的特殊情况下，它安全地允许任意数量的并发读取以及可调数量的并发写入。 当需要通过单个锁来阻止对集合的所有访问时，“同步”类可能非常有用，但代价是可扩展性较差。 在其他情况下，多个线程需要访问一个通用集合，“并发”版本通常更可取。 如果任何一个集合是非共享的，或者只有在持有其他锁时才可访问，则非同步集合更可取。

大多数并发集合实现（包括大多数队列）也与通常的 java.util约定不同，因为它们的 Iterators和 Spliterators提供 弱一致性而不是快速失败遍历：

• they may proceed concurrently with other operations
• they will never throw ConcurrentModificationException
• they are guaranteed to traverse elements as they existed upon construction exactly once, and may (but are not guaranteed to) reflect any modifications subsequent to construction.

Memory Consistency Properties

Chapter 17 of The Java™ Language Specification defines the happens-before relation on memory operations such as reads and writes of shared variables. The results of a write by one thread are guaranteed to be visible to a read by another thread only if the write operation happens-before the read operation. The synchronized and volatile constructs, as well as the Thread.start() and Thread.join() methods, can form happens-before relationships. In particular:

• Each action in a thread happens-before every action in that thread that comes later in the program's order.
• An unlock (synchronized block or method exit) of a monitor happens-before every subsequent lock (synchronized block or method entry) of that same monitor. And because the happens-before relation is transitive, all actions of a thread prior to unlocking happen-before all actions subsequent to any thread locking that monitor.
• A write to a volatile field happens-before every subsequent read of that same field. Writes and reads of volatile fields have similar memory consistency effects as entering and exiting monitors, but do not entail mutual exclusion locking.
• A call to start on a thread happens-before any action in the started thread.
• All actions in a thread happen-before any other thread successfully returns from a join on that thread.

The methods of all classes in java.util.concurrent and its subpackages extend these guarantees to higher-level synchronization. In particular:

• Actions in a thread prior to placing an object into any concurrent collection happen-before actions subsequent to the access or removal of that element from the collection in another thread.
• Actions in a thread prior to the submission of a Runnable to an Executor happen-before its execution begins. Similarly for Callables submitted to an ExecutorService.
• Actions taken by the asynchronous computation represented by a Future happen-before actions subsequent to the retrieval of the result via Future.get() in another thread.
• Actions prior to "releasing" synchronizer methods such as Lock.unlock, Semaphore.release, and CountDownLatch.countDown happen-before actions subsequent to a successful "acquiring" method such as Lock.lock, Semaphore.acquire, Condition.await, and CountDownLatch.await on the same synchronizer object in another thread.
• For each pair of threads that successfully exchange objects via an Exchanger, actions prior to the exchange() in each thread happen-before those subsequent to the corresponding exchange() in another thread.
• Actions prior to calling CyclicBarrier.await and Phaser.awaitAdvance (as well as its variants) happen-before actions performed by the barrier action, and actions performed by the barrier action happen-before actions subsequent to a successful return from the corresponding await in other threads.

Interfaces

BlockingDeque<E>	Deque还支持在检索元素时等待deque变为非空的阻塞操作，并在存储元素时等待空间在deque中可用。
BlockingQueue<E>	Queue还支持在检索元素时等待队列变为非空操作的操作，并在存储元素时等待队列中的空间变得可用。
Callable<V>	返回结果并可能抛出异常的任务。
CompletableFuture.AsynchronousCompletionTask	一个标记接口，标识由 async方法生成的异步任务。
CompletionService<V>	一种将新的异步任务的生成与已完成任务的结果消耗分离的服务。
CompletionStage<T>	一个可能是异步计算的阶段，在另一个CompletionStage完成时执行一个操作或计算一个值。
ConcurrentMap<K, V>	Map提供线程安全性和原子性保证。
ConcurrentNavigableMap<K, V>	一个 ConcurrentMap支持 NavigableMap操作，并递归地为其可导航的子地图。
Delayed	混合式界面用于标记在给定延迟后应该执行的对象。
Executor	执行提交的 Runnable任务的对象。
ExecutorService	一个 Executor ，提供管理终止方法和方法，可以生成用于跟踪一个或多个异步任务的进度的 Future 。
ForkJoinPool.ForkJoinWorkerThreadFactory	工厂用于创建新的 ForkJoinWorkerThread s。
ForkJoinPool.ManagedBlocker	用于扩展在 ForkJoinPool运行的任务的管理并行性的接口。
Future<V>	Future代表异步计算的结果。
RejectedExecutionHandler	ThreadPoolExecutor不能执行的任务处理程序。
RunnableFuture<V>	Future即 Runnable 。
RunnableScheduledFuture<V>	ScheduledFuture即 Runnable 。
ScheduledExecutorService	ExecutorService可以安排命令在给定延迟后运行，或定期执行。
ScheduledFuture<V>	可以取消的延迟结果支持动作。
ThreadFactory	按需创建新线程的对象。
TransferQueue<E>	生产者可以等待消费者接收元素的 BlockingQueue 。

Classes

AbstractExecutorService	提供 ExecutorService执行方法的默认实现。
ArrayBlockingQueue<E>	由数组支持的有界 blocking queue 。
CompletableFuture<T>	一个 Future可以明确完成（设置它的值和状态），并且可以用作 CompletionStage ，支持依赖函数和完成时触发的操作。
ConcurrentHashMap<K, V>	哈希表支持检索的完全并发和更新的高预期并发。
ConcurrentHashMap.KeySetView<K, V>	将ConcurrentHashMap视图作为密钥的 Set ，其中可以通过映射到公共值来可选地启用添加。
ConcurrentLinkedDeque<E>	基于链接节点的无限制并发 deque 。
ConcurrentLinkedQueue<E>	基于链接节点的无限线程安全 queue 。
ConcurrentSkipListMap<K, V>	可扩展的并发 ConcurrentNavigableMap实现。
ConcurrentSkipListSet<E>	可扩展的并行 NavigableSet实现基于一个 ConcurrentSkipListMap 。
CopyOnWriteArrayList<E>	线程安全的随机访问列表。
CopyOnWriteArraySet<E>	一个 Set ，其所有操作都使用内部 CopyOnWriteArrayList 。
CountDownLatch	同步协助，允许一个或多个线程等待，直到在其他线程中执行的一组操作完成。
CountedCompleter<T>	一个 ForkJoinTask在触发时执行完成操作并且没有剩余的待处理操作。
CyclicBarrier	一种同步辅助，它允许一组线程互相等待以达到共同的障碍点。
DelayQueue<E extends Delayed>	无界 blocking queue的 Delayed元件，其中，当其延迟已到期的元素只能采取。
Exchanger<V>	一个同步点，线程可以在其中配对和交换对内的元素。
ExecutorCompletionService<V>	CompletionService使用提供的 Executor执行任务。
Executors	工厂和工具方法 Executor ， ExecutorService ， ScheduledExecutorService ， ThreadFactory和 Callable此包中定义的类。
ForkJoinPool	一个 ExecutorService运行 ForkJoinTask秒。
ForkJoinTask<V>	在 ForkJoinPool内运行的任务的抽象基类。
ForkJoinWorkerThread	由 ForkJoinPool管理的线程，执行 ForkJoinTask 。
FutureTask<V>	可取消的异步计算。
LinkedBlockingDeque<E>	基于链接节点的可选有界 blocking deque 。
LinkedBlockingQueue<E>	基于链接节点的可选有界 blocking queue 。
LinkedTransferQueue<E>	基于链接节点的无限制 TransferQueue 。
Phaser	可重复使用的同步屏障，功能类似于 CyclicBarrier和 CountDownLatch但支持更灵活的使用。
PriorityBlockingQueue<E>	无界的 blocking queue使用与 PriorityQueue类相同的排序规则，并提供阻止检索操作。
RecursiveAction	一个递归的结果 ForkJoinTask 。
RecursiveTask<V>	递归结果 - 承载 ForkJoinTask 。
ScheduledThreadPoolExecutor	一个 ThreadPoolExecutor ，可以额外安排命令在给定延迟后运行，或定期执行。
Semaphore	计数信号量。
SynchronousQueue<E>	一个 blocking queue其中每个插入操作必须等待另一个线程的相应删除操作，反之亦然。
ThreadLocalRandom	随机数发生器与当前线程隔离。
ThreadPoolExecutor	ExecutorService使用可能的几个池线程中的一个执行每个提交的任务，通常使用 Executors工厂方法进行配置。
ThreadPoolExecutor.AbortPolicy	被抛弃的任务处理程序抛出 RejectedExecutionException 。
ThreadPoolExecutor.CallerRunsPolicy	被拒绝任务的处理程序直接在 execute方法的调用线程中运行被拒绝的任务，除非执行程序已关闭，在这种情况下任务将被丢弃。
ThreadPoolExecutor.DiscardOldestPolicy	拒绝任务的处理程序，丢弃最旧的未处理的请求，然后重试 execute ，除非执行程序关闭，在这种情况下任务将被丢弃。
ThreadPoolExecutor.DiscardPolicy	被拒绝任务的处理程序，默默丢弃被拒绝的任务。

Enums

TimeUnit

A TimeUnit表示给定粒度单位的持续时间，并提供跨设备转换的实用方法，并在这些设备中执行计时和延迟操作。

Exceptions

BrokenBarrierException	当线程试图等待处于断开状态的障碍或在线程正在等待时进入断开状态时抛出的异常。
CancellationException	指示由于任务被取消而无法检索值生成任务（例如 FutureTask的结果的异常。
CompletionException	在完成结果或任务过程中遇到错误或其他异常时抛出异常。
ExecutionException	尝试检索由抛出异常中止的任务的结果时抛出异常。
RejectedExecutionException	当任务不能被接受执行时，由 Executor引发的异常。
TimeoutException	阻止操作超时时抛出异常。