Which five items are provided by the Java concurrency utilities?
A.
High-performance, flexible thread pools
B.
Dynamic adjustment of thread priorities
C.
Collection classes designed for concurrent access
D.
Atomic variables
E.
synchronized wrappers for collection classes in the java.util package,
F.
Asynchronous execution of tasks
G.
Counting semaphores
H.
Concurrent collection sorting implementations
Explanation:
The Java 2 platform includes a new package of concurrency utilities. These are
classes that are designed to be used as building blocks in building concurrent classes or
applications. Just as thecollections framework simplified the organization and manipulation of inmemory data by providing implementations of commonly used data structures, the concurrency
utilities simplify the development of concurrent classes by providing implementations of building
blocks commonly used in concurrent designs. The concurrency utilities include a highperformance, flexible thread pool; a framework for asynchronous execution of tasks; a host of
collection classes optimized for concurrent access; synchronization utilities such as counting
semaphores (G); atomic variables; locks; and condition variables.
The concurrency utilities includes:
* Task scheduling framework. The Executor interface standardizes invocation, scheduling,
execution, and control of asynchronous tasks according to a set of execution policies.
Implementations are provided that enable tasks to be executed within the submitting thread, in a
single background thread (as with events in Swing), in a newly created thread, or in a thread pool,
and developers can create customized implementations of Executor that support arbitrary
execution policies. The built-in implementations offer configurable policies such as queue length
limits and saturation policy that can improve the stability of applications by preventing runaway
resource use.
* Fork/join framework. Based on the ForkJoinPool class, this framework is an implementation of
Executor. It is designed to efficiently run a large number of tasks using a pool of worker threads
(A) . A work-stealing technique is used to keep all the worker threads busy, to take full advantage
of multiple processors.
* (C) Concurrent collections. Several new collections classes were added, including the new
Queue, BlockingQueue and BlockingDeque interfaces, and high-performance, concurrent
implementations of Map, List, and Queue. See the Collections Framework Guide for more
information.
* (D) Atomic variables. Utility classes are provided that atomically manipulate single variables
(primitive types or references), providing high-performance atomic arithmetic and compare-and-set
methods. The atomic variable implementations in the java.util.concurrent.atomic package offer
higher performance than would be available by using synchronization (on most platforms), making
them useful for implementing high-performance concurrent algorithms and conveniently
implementing counters and sequence number generators.
* (E) Synchronizers. General purpose synchronization classes, including semaphores, barriers,
latches, phasers, and exchangers, facilitate coordination between threads.
* Locks. While locking is built into the Java language through the synchronized keyword, there are
a number of limitations to built-in monitor locks. The java.util.concurrent.locks package provides a
high-performance lock implementation with the same memory semantics as synchronization, and
it also supports specifying a timeout when attempting to acquire a lock, multiple condition variables
per lock, nonnested (“hand-over-hand”) holding of multiple locks, and support for interrupting
threads that are waiting to acquire a lock.
* Nanosecond-granularity timing. The System.nanoTime method enables access to a
nanosecond-granularity time source for making relative time measurements and methods that
accept timeouts (such as the BlockingQueue.offer, BlockingQueue.poll, Lock.tryLock,
Condition.await, and Thread.sleep) can take timeout values in nanoseconds. The actual precision
of the System.nanoTime method is platform-dependent.
Reference: Java SE Documentation, Concurrency Utilities