Movatterモバイル変換

Concurrency Utilities Overview

Introduction

Using the Concurrency Utilities, instead of developing components such asthread 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(), andnotifyAll()) 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 concurrentapplication can help you make your program clearer, shorter, faster, morereliable, more scalable, easier to write, easier to read, and easier tomaintain.

The Concurrency Utilities includes:

• Task Scheduling Framework - TheExecutor 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 asingle background thread (as with events in Swing), in a newly created thread, or in athread pool, and developers can create of Executor supporting arbitrary execution policies. The built-in implementations offer configurable policies such as queue length limits andsaturation policy which can improve the stability of applications by preventing runaway resource consumption.
• Concurrent Collections - Several new Collections classes have been added, including the newQueue andBlockingQueue interfaces, and high-performance, concurrent implementations ofMap,List, andQueue.
• 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 injava.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, includingsemaphores,mutexes,barriers,latches, andexchangers, 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. Thejava.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-lexically scoped locks, and support for interrupting threads which are waiting to acquire a lock.
• Nanosecond-granularity timing - TheSystem.nanoTime method enables access to a nanosecond-granularity time source for making relative time measurements, and methods which accept timeouts (such as theBlockingQueue.offer,BlockingQueue.poll,Lock.tryLock,Condition.await, andThread.sleep) can take timeout values in nanoseconds. The actual precision ofSystem.nanoTime is platform-dependent.