Concurrency Utilities

Overview

Introduction

The Java 2 platform includes a new package of concurrency utilities. These are classes which are

designed to be used as building blocks in building concurrent classes or applications. Just as the

Collections Framework greatly simplified the organization and manipulation of in-memory data

by providing implementations of commonly used data structures, the Concurrency Utilities aims

to simplify the development of concurrent classes by providing implementations of building

blocks commonly used in concurrent designs. The Concurrency Utilities include a high-

performance, 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; atomic variables; locks; and condition variables.

Using the Concurrency Utilities, instead of developing components such as thread pools

yourself, offers a number of advantages:

Reduced programming effort. It is far easier to use a standard class than to develop it

yourself.

Increased performance. The implementations in the Concurrency Utilities were

developed and peer-reviewed by concurrency and performance experts; these

implementations are likely to be faster and more scalable than a typical implementation,

even by a skilled developer.

Increased reliability. Developing concurrent classes is difficult -- the low-level

concurrency primitives provided by the Java language (synchronized, volatile,

wait(), notify(), and notifyAll()) are difficult to use correctly, and errors using

these facilities can be difficult to detect and debug. By using standardized, extensively

tested concurrency building blocks, many potential sources of threading hazards such as

deadlock, starvation, race conditions, or excessive context switching are eliminated. The

concurrency utilities have been carefully audited for deadlock, starvation, and race

conditions.

Improved maintainability. Programs which use standard library classes are easier to

understand and maintain than those which rely on complicated, homegrown classes.

Increased productivity. Developers are likely to already understand the standard library

classes, so there is no need to learn the API and behavior of ad-hoc concurrent

components. Additionally, concurrent applications are far simpler to debug when they are

built on reliable, well-tested components.

In short, using the Concurrency Utilities to implement a concurrent application can help you

make your program clearer, shorter, faster, more reliable, more scalable, easier to write, easier to

read, and easier to maintain.

The Concurrency Utilities includes:

Task Scheduling Framework - The Executor framework is a framework for

standardizing invocation, scheduling, execution, and control of asynchronous tasks

according to a set of execution policies. Implementations are provided that allow 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 supporting arbitrary execution policies. The

built-in implementations offer configurable policies such as queue length limits and

saturation policy which can improve the stability of applications by preventing runaway

resource consumption.

Concurrent Collections - Several new Collections classes have been 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 details.

Atomic Variables - Classes for atomically manipulating single variables (primitive types

or references), providing high-performance atomic arithmetic and compare-and-set

methods. The atomic variable implementations in java.util.concurrent.atomic offer

higher performance than would be available by using synchronization (on most

platforms), making them useful for implementing high-performance concurrent

algorithms as well as conveniently implementing counters and sequence number

generators.

Synchronizers - General purpose synchronization classes, including semaphores,

mutexes, barriers, latches, and exchangers, which facilitate coordination between threads.

Locks - While locking is built into the Java language via the synchronized keyword,

there are a number of inconvenient 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, but which also

supports specifying a timeout when attempting to acquire a lock, multiple condition

variables per lock, non-nested ("hand-over-hand") holding of multiple locks, and support

for interrupting threads which 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

which 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 System.nanoTime is platform-dependent.

Copyright © 2004 Sun Microsystems, Inc. All Rights Reserved.

Java Software