# java.util.concurrent.locks Added in[API level 1](https://developer.android.com/guide/topics/manifest/uses-sdk-element#ApiLevels) # 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. The framework permits much greater flexibility in the use of locks and conditions, at the expense of more awkward syntax. The[Lock](https://developer.android.com/reference/java/util/concurrent/locks/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](https://developer.android.com/reference/java/util/concurrent/locks/ReentrantLock). The[ReadWriteLock](https://developer.android.com/reference/java/util/concurrent/locks/ReadWriteLock)interface similarly defines locks that may be shared among readers but are exclusive to writers. Only a single implementation,[ReentrantReadWriteLock](https://developer.android.com/reference/java/util/concurrent/locks/ReentrantReadWriteLock), is provided, since it covers most standard usage contexts. But programmers may create their own implementations to cover nonstandard requirements. The[Condition](https://developer.android.com/reference/java/util/concurrent/locks/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](https://developer.android.com/reference/java/util/concurrent/locks/AbstractQueuedSynchronizer)class serves as a useful superclass for defining locks and other synchronizers that rely on queuing blocked threads. The[AbstractQueuedLongSynchronizer](https://developer.android.com/reference/java/util/concurrent/locks/AbstractQueuedLongSynchronizer)class provides the same functionality but extends support to 64 bits of synchronization state. Both extend class[AbstractOwnableSynchronizer](https://developer.android.com/reference/java/util/concurrent/locks/AbstractOwnableSynchronizer), a simple class that helps record the thread currently holding exclusive synchronization. The[LockSupport](https://developer.android.com/reference/java/util/concurrent/locks/LockSupport)class provides lower-level blocking and unblocking support that is useful for those developers implementing their own customized lock classes. ## Interfaces |---------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | [Condition](https://developer.android.com/reference/java/util/concurrent/locks/Condition) | `Condition`factors out the`Object`monitor methods ([wait](https://developer.android.com/reference/java/lang/Object#wait()),[notify](https://developer.android.com/reference/java/lang/Object#notify())and[notifyAll](https://developer.android.com/reference/java/lang/Object#notifyAll())) into distinct objects to give the effect of having multiple wait-sets per object, by combining them with the use of arbitrary[Lock](https://developer.android.com/reference/java/util/concurrent/locks/Lock)implementations. | | [Lock](https://developer.android.com/reference/java/util/concurrent/locks/Lock) | `Lock`implementations provide more extensive locking operations than can be obtained using`synchronized`methods and statements. | | [ReadWriteLock](https://developer.android.com/reference/java/util/concurrent/locks/ReadWriteLock) | A`ReadWriteLock`maintains a pair of associated[locks](https://developer.android.com/reference/java/util/concurrent/locks/Lock), one for read-only operations and one for writing. | ## Classes |---------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | [AbstractOwnableSynchronizer](https://developer.android.com/reference/java/util/concurrent/locks/AbstractOwnableSynchronizer) | A synchronizer that may be exclusively owned by a thread. | | [AbstractQueuedLongSynchronizer](https://developer.android.com/reference/java/util/concurrent/locks/AbstractQueuedLongSynchronizer) | A version of[AbstractQueuedSynchronizer](https://developer.android.com/reference/java/util/concurrent/locks/AbstractQueuedSynchronizer)in which synchronization state is maintained as a`long`. | | [AbstractQueuedLongSynchronizer.ConditionObject](https://developer.android.com/reference/java/util/concurrent/locks/AbstractQueuedLongSynchronizer.ConditionObject) | Condition implementation for a[AbstractQueuedLongSynchronizer](https://developer.android.com/reference/java/util/concurrent/locks/AbstractQueuedLongSynchronizer)serving as the basis of a[Lock](https://developer.android.com/reference/java/util/concurrent/locks/Lock)implementation. | | [AbstractQueuedSynchronizer](https://developer.android.com/reference/java/util/concurrent/locks/AbstractQueuedSynchronizer) | Provides a framework for implementing blocking locks and related synchronizers (semaphores, events, etc) that rely on first-in-first-out (FIFO) wait queues. | | [AbstractQueuedSynchronizer.ConditionObject](https://developer.android.com/reference/java/util/concurrent/locks/AbstractQueuedSynchronizer.ConditionObject) | Condition implementation for a[AbstractQueuedSynchronizer](https://developer.android.com/reference/java/util/concurrent/locks/AbstractQueuedSynchronizer)serving as the basis of a[Lock](https://developer.android.com/reference/java/util/concurrent/locks/Lock)implementation. | | [LockSupport](https://developer.android.com/reference/java/util/concurrent/locks/LockSupport) | Basic thread blocking primitives for creating locks and other synchronization classes. | | [ReentrantLock](https://developer.android.com/reference/java/util/concurrent/locks/ReentrantLock) | A reentrant mutual exclusion[Lock](https://developer.android.com/reference/java/util/concurrent/locks/Lock)with the same basic behavior and semantics as the implicit monitor lock accessed using`synchronized`methods and statements, but with extended capabilities. | | [ReentrantReadWriteLock](https://developer.android.com/reference/java/util/concurrent/locks/ReentrantReadWriteLock) | An implementation of[ReadWriteLock](https://developer.android.com/reference/java/util/concurrent/locks/ReadWriteLock)supporting similar semantics to[ReentrantLock](https://developer.android.com/reference/java/util/concurrent/locks/ReentrantLock). | | [ReentrantReadWriteLock.ReadLock](https://developer.android.com/reference/java/util/concurrent/locks/ReentrantReadWriteLock.ReadLock) | The lock returned by method[ReentrantReadWriteLock.readLock](https://developer.android.com/reference/java/util/concurrent/locks/ReentrantReadWriteLock#readLock()). | | [ReentrantReadWriteLock.WriteLock](https://developer.android.com/reference/java/util/concurrent/locks/ReentrantReadWriteLock.WriteLock) | The lock returned by method[ReentrantReadWriteLock.writeLock](https://developer.android.com/reference/java/util/concurrent/locks/ReentrantReadWriteLock#writeLock()). | | [StampedLock](https://developer.android.com/reference/java/util/concurrent/locks/StampedLock) | A capability-based lock with three modes for controlling read/write access. | - ## Interfaces - [Condition](https://developer.android.com/reference/java/util/concurrent/locks/Condition) - [Lock](https://developer.android.com/reference/java/util/concurrent/locks/Lock) - [ReadWriteLock](https://developer.android.com/reference/java/util/concurrent/locks/ReadWriteLock) - ## Classes - [AbstractOwnableSynchronizer](https://developer.android.com/reference/java/util/concurrent/locks/AbstractOwnableSynchronizer) - [AbstractQueuedLongSynchronizer](https://developer.android.com/reference/java/util/concurrent/locks/AbstractQueuedLongSynchronizer) - [AbstractQueuedLongSynchronizer.ConditionObject](https://developer.android.com/reference/java/util/concurrent/locks/AbstractQueuedLongSynchronizer.ConditionObject) - [AbstractQueuedSynchronizer](https://developer.android.com/reference/java/util/concurrent/locks/AbstractQueuedSynchronizer) - [AbstractQueuedSynchronizer.ConditionObject](https://developer.android.com/reference/java/util/concurrent/locks/AbstractQueuedSynchronizer.ConditionObject) - [LockSupport](https://developer.android.com/reference/java/util/concurrent/locks/LockSupport) - [ReentrantLock](https://developer.android.com/reference/java/util/concurrent/locks/ReentrantLock) - [ReentrantReadWriteLock](https://developer.android.com/reference/java/util/concurrent/locks/ReentrantReadWriteLock) - [ReentrantReadWriteLock.ReadLock](https://developer.android.com/reference/java/util/concurrent/locks/ReentrantReadWriteLock.ReadLock) - [ReentrantReadWriteLock.WriteLock](https://developer.android.com/reference/java/util/concurrent/locks/ReentrantReadWriteLock.WriteLock) - [StampedLock](https://developer.android.com/reference/java/util/concurrent/locks/StampedLock)