Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| Java™ Platform Standard Ed. 6
PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES

## Package java.util.concurrent.locks

Interfaces and classes providing a framework for locking and waiting for conditions that is distinct from built-in synchronization and monitors.

See:
Description

Interface Summary
Condition | `Condition` factors out the `Object` monitor methods (`wait`, `notify` and `notifyAll`) into distinct objects to give the effect of having multiple wait-sets per object, by combining them with the use of arbitrary `Lock` implementations.
Lock | `Lock` implementations provide more extensive locking operations than can be obtained using `synchronized` methods and statements.
ReadWriteLock | A `ReadWriteLock` maintains a pair of associated `locks`, one for read-only operations and one for writing.

Class Summary
AbstractOwnableSynchronizer | A synchronizer that may be exclusively owned by a thread.
AbstractQueuedLongSynchronizer | A version of `AbstractQueuedSynchronizer` in which synchronization state is maintained as a `long`.
AbstractQueuedSynchronizer | Provides a framework for implementing blocking locks and related synchronizers (semaphores, events, etc) that rely on first-in-first-out (FIFO) wait queues.
LockSupport | Basic thread blocking primitives for creating locks and other synchronization classes.
ReentrantLock | A reentrant mutual exclusion `Lock` with the same basic behavior and semantics as the implicit monitor lock accessed using `synchronized` methods and statements, but with extended capabilities.
ReentrantReadWriteLock | An implementation of `ReadWriteLock` supporting similar semantics to `ReentrantLock`.
ReentrantReadWriteLock.ReadLock | The lock returned by method `ReentrantReadWriteLock.readLock()`.
ReentrantReadWriteLock.WriteLock | The lock returned by method `ReentrantReadWriteLock.writeLock()`.

## Package java.util.concurrent.locks Description

Interfaces and classes providing a framework for locking and waiting for conditions that is distinct from built-in synchronization and monitors. The framework permits much greater flexibility in the use of locks and conditions, at the expense of more awkward syntax.

The `Lock` interface supports locking disciplines that differ in semantics (reentrant, fair, etc), and that can be used in non-block-structured contexts including hand-over-hand and lock reordering algorithms. The main implementation is `ReentrantLock`.

The `ReadWriteLock` interface similarly defines locks that may be shared among readers but are exclusive to writers. Only a single implementation, `ReentrantReadWriteLock`, is provided, since it covers most standard usage contexts. But programmers may create their own implementations to cover nonstandard requirements.

The `Condition` interface describes condition variables that may be associated with Locks. These are similar in usage to the implicit monitors accessed using `Object.wait`, but offer extended capabilities. In particular, multiple `Condition` objects may be associated with a single `Lock`. To avoid compatibility issues, the names of `Condition` methods are different than the corresponding `Object` versions.

The `AbstractQueuedSynchronizer` class serves as a useful superclass for defining locks and other synchronizers that rely on queuing blocked threads. The `AbstractQueuedLongSynchronizer` class provides the same functionality but extends support to 64 bits of synchronization state. Both extend class `AbstractOwnableSynchronizer`, a simple class that helps record the thread currently holding exclusive synchronization. The `LockSupport` class provides lower-level blocking and unblocking support that is useful for those developers implementing their own customized lock classes.

Since:
  1.5

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| Java™ Platform Standard Ed. 6
PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES

Submit a bug or feature
For further API reference and developer documentation, see Java SE Developer Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.

Copyright © 1993, 2011, Oracle and/or its affiliates. All rights reserved.