Mastering Java ReentrantLock: Synchronization, Communication, and Fairness

Lock Object Overview

The Lock interface, introduced after JDK 1.5, has common implementations such as ReentrantLock; these are collectively referred to as Lock objects.

ReentrantLock for Thread Synchronization

ReentrantLock can achieve the same mutual exclusion as the synchronized keyword while offering additional flexible features.

Running the example shows that a thread releases the lock after printing, allowing other threads to acquire it; the printed groups are ordered because the lock is held during each thread's output, though the overall order is random.

Another test demonstrates ReentrantLock’s ability to synchronize threads using lock.lock().

Result shows that while a thread holds the lock, other threads wait, mirroring synchronized behavior.

Using Lock for Thread Communication

Beyond synchronization, ReentrantLock enables thread communication via Condition objects, which replace the wait/notify pattern used with synchronized.

Condition creation example:

Conditions allow selective notification, unlike synchronized’s single monitor where notify/notifyAll awaken threads randomly.

Lock and Condition Wait/Notify Example

Key method mappings:

Object.wait() ↔ Condition.await()

Object.notify() ↔ Condition.signal()

Object.notifyAll() ↔ Condition.signalAll()

Example code (illustrated in images) demonstrates acquiring the lock before using Condition methods.

Result confirms correct execution.

Lock with Multiple Conditions Example

Using several Condition objects enables notifying specific groups of threads.

Output shows selective notifications, demonstrating that signal can wake a particular group while signalAll notifies all waiting threads in that group.

Fair and Unfair Locks

A fair lock grants access in FIFO order, while an unfair lock allows threads to acquire the lock opportunistically, leading to random acquisition.

ReentrantLock provides a constructor to specify fairness:

Setting the boolean parameter fair to true creates a fair lock.

Other ReentrantLock Methods

Key methods include:

getHoldCount(): returns how many times the current thread has acquired the lock.

getQueueLength(): estimates the number of threads waiting for the lock.

isFair(): indicates whether the lock is fair.

Further methods follow the same intuitive naming.