Stay organized with collections
Save and categorize content based on your preferences.
java.util.concurrent.locks
Interfaces
| 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.
|
Classes
Content and code samples on this page are subject to the licenses described in the Content License. Java and OpenJDK are trademarks or registered trademarks of Oracle and/or its affiliates.
Last updated 2025-02-10 UTC.
[[["Easy to understand","easyToUnderstand","thumb-up"],["Solved my problem","solvedMyProblem","thumb-up"],["Other","otherUp","thumb-up"]],[["Missing the information I need","missingTheInformationINeed","thumb-down"],["Too complicated / too many steps","tooComplicatedTooManySteps","thumb-down"],["Out of date","outOfDate","thumb-down"],["Samples / code issue","samplesCodeIssue","thumb-down"],["Other","otherDown","thumb-down"]],["Last updated 2025-02-10 UTC."],[],[],null,["# java.util.concurrent.locks\n==========================\n\nInterfaces\n----------\n\n|-----------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| [Condition](/reference/kotlin/java/util/concurrent/locks/Condition) | `Condition` factors out the `Object` monitor methods ([wait](../../../lang/Object.html#wait()), [notify](../../../lang/Object.html#notify()) and [notifyAll](../../../lang/Object.html#notifyAll())) into distinct objects to give the effect of having multiple wait-sets per object, by combining them with the use of arbitrary [Lock](/reference/kotlin/java/util/concurrent/locks/Lock) implementations. |\n| [Lock](/reference/kotlin/java/util/concurrent/locks/Lock) | `Lock` implementations provide more extensive locking operations than can be obtained using `synchronized` methods and statements. |\n| [ReadWriteLock](/reference/kotlin/java/util/concurrent/locks/ReadWriteLock) | A `ReadWriteLock` maintains a pair of associated [locks](/reference/kotlin/java/util/concurrent/locks/Lock), one for read-only operations and one for writing. |\n\nClasses\n-------\n\n|---------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| [AbstractOwnableSynchronizer](/reference/kotlin/java/util/concurrent/locks/AbstractOwnableSynchronizer) | A synchronizer that may be exclusively owned by a thread. |\n| [AbstractQueuedLongSynchronizer](/reference/kotlin/java/util/concurrent/locks/AbstractQueuedLongSynchronizer) | A version of [AbstractQueuedSynchronizer](/reference/kotlin/java/util/concurrent/locks/AbstractQueuedSynchronizer) in which synchronization state is maintained as a `long`. |\n| [AbstractQueuedSynchronizer](/reference/kotlin/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. |\n| [LockSupport](/reference/kotlin/java/util/concurrent/locks/LockSupport) | Basic thread blocking primitives for creating locks and other synchronization classes. |\n| [ReentrantLock](/reference/kotlin/java/util/concurrent/locks/ReentrantLock) | A reentrant mutual exclusion [Lock](/reference/kotlin/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. |\n| [ReentrantReadWriteLock](/reference/kotlin/java/util/concurrent/locks/ReentrantReadWriteLock) | An implementation of [ReadWriteLock](/reference/kotlin/java/util/concurrent/locks/ReadWriteLock) supporting similar semantics to [ReentrantLock](/reference/kotlin/java/util/concurrent/locks/ReentrantLock). |\n| [StampedLock](/reference/kotlin/java/util/concurrent/locks/StampedLock) | A capability-based lock with three modes for controlling read/write access. |"]]
