# 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
  Interface | Description
  --- | ---
  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
  Class | Description
  --- | ---
  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 from 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

Copyright © 2025 API Design. All Rights Reserved.