Package java9.util.concurrent

Some of the Java 8 and Java 9 utility classes commonly used in concurrent programming.

See: Description

Interface Summary

Interface	Description
CompletableFuture.AsynchronousCompletionTask	A marker interface identifying asynchronous tasks produced by async methods.
CompletionStage<T>	A stage of a possibly asynchronous computation, that performs an action or computes a value when another CompletionStage completes.
Flow.Processor<T,R>	A component that acts as both a Subscriber and Publisher.
Flow.Publisher<T>	A producer of items (and related control messages) received by Subscribers.
Flow.Subscriber<T>	A receiver of messages.
Flow.Subscription	Message control linking a Flow.Publisher and Flow.Subscriber.
ForkJoinPool.ForkJoinWorkerThreadFactory	Factory for creating new ForkJoinWorkerThreads.
ForkJoinPool.ManagedBlocker	Interface for extending managed parallelism for tasks running in ForkJoinPools.

Class Summary

Class	Description
CompletableFuture<T>	A Future that may be explicitly completed (setting its value and status), and may be used as a CompletionStage, supporting dependent functions and actions that trigger upon its completion.
CountedCompleter<T>	A ForkJoinTask with a completion action performed when triggered and there are no remaining pending actions.
Flow	Interrelated interfaces and static methods for establishing flow-controlled components in which Publishers produce items consumed by one or more Subscribers, each managed by a Subscription.
ForkJoinPool	An ExecutorService for running ForkJoinTasks.
ForkJoinTask<V>	Abstract base class for tasks that run within a ForkJoinPool.
ForkJoinWorkerThread	A thread managed by a ForkJoinPool, which executes ForkJoinTasks.
SubmissionPublisher<T>	A Flow.Publisher that asynchronously issues submitted (non-null) items to current subscribers until it is closed.

Package java9.util.concurrent Description

Some of the Java 8 and Java 9 utility classes commonly used in concurrent programming. Covers a backport of the upgraded (JEP 266) Java 9 CompletableFuture API for Java 8. In addition, it includes a Java 8 version of the new Java 9 (JEP 266) reactive-streams Flow and SubmissionPublisher API for Java 8. See JEP 266: More Concurrency Updates.

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.

Since:

9