What is ReentrantLock?
In Java, multithreading is an essential feature that allows multiple threads to run concurrently. However, when multiple threads share common resources, there’s a risk of data inconsistency and other issues due to race conditions. To solve this problem, synchronization is required. One of the most commonly used synchronization mechanisms is locks. While Java provides synchronized methods and blocks, there are cases where more control is needed, and this is where ReentrantLock comes into play. It is part of the java.util.concurrent package and provides a more flexible and powerful way to manage locks than the traditional synchronized keyword.
Why is ReentrantLock Important?
The ReentrantLock is crucial because it provides advanced locking capabilities that cannot be achieved using traditional synchronized blocks or methods. Here’s a breakdown of why ReentrantLock is important:
- Reentrant: The lock is reentrant, meaning that the same thread can acquire the lock multiple times without causing a deadlock.
- Flexible Locking Mechanism: Unlike synchronized methods or blocks,
ReentrantLockallows explicit lock and unlock calls, offering more control over the synchronization process. - Timeouts: The lock can be acquired with a timeout, which prevents threads from waiting indefinitely for a lock.
- Fairness:
ReentrantLocksupports a fairness policy, where the threads acquire the lock in the order they requested it, reducing the chances of thread starvation. - Interruptible Lock Acquisition: Threads can attempt to acquire the lock in a way that allows them to be interrupted.
How Does ReentrantLock Work?
The ReentrantLock works by providing a lock object that can be used to ensure that only one thread can access a critical section at any given time. The lock ensures mutual exclusion and prevents race conditions.
Here’s an example demonstrating how ReentrantLock works in practice:
import java.util.concurrent.locks.ReentrantLock;
public class ReentrantLockExample {
private static final ReentrantLock lock = new ReentrantLock();
public static void main(String[] args) {
Thread t1 = new Thread(() -> {
lock.lock();
try {
System.out.println("Thread 1 is executing critical section");
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
});
Thread t2 = new Thread(() -> {
lock.lock();
try {
System.out.println("Thread 2 is executing critical section");
} finally {
lock.unlock();
}
});
t1.start();
t2.start();
}
}
In this example, we create a ReentrantLock and two threads, t1 and t2. The lock.lock() method is called by each thread before entering the critical section. Once the thread has finished executing the critical section, it calls lock.unlock() to release the lock. This prevents the second thread from entering the critical section while the first thread is still executing.
Reentrant Nature of ReentrantLock
One of the unique features of ReentrantLock is that it is reentrant. This means that a thread that already holds the lock can acquire it again without causing a deadlock. This is particularly useful when a thread needs to enter a critical section multiple times within the same method or call hierarchy.
Here’s an example demonstrating the reentrant property:
import java.util.concurrent.locks.ReentrantLock;
public class ReentrantLockReentrantExample {
private static final ReentrantLock lock = new ReentrantLock();
public static void main(String[] args) {
Thread t1 = new Thread(() -> {
lock.lock();
try {
System.out.println("Thread 1 entering critical section");
enterCriticalSection();
} finally {
lock.unlock();
}
});
t1.start();
}
public static void enterCriticalSection() {
lock.lock(); // Reentrant call to acquire the lock again
try {
System.out.println("Thread 1 re-entering critical section");
} finally {
lock.unlock();
}
}
}
In this example, the enterCriticalSection method tries to acquire the lock again, even though the thread already holds the lock. The reentrant nature of ReentrantLock allows this without deadlock.
Fairness in ReentrantLock
A ReentrantLock can be created with an optional fairness parameter. When fairness is enabled, the lock ensures that threads acquire the lock in the order they requested it, preventing thread starvation.
Here’s how you can create a fair ReentrantLock:
import java.util.concurrent.locks.ReentrantLock;
public class FairReentrantLockExample {
private static final ReentrantLock lock = new ReentrantLock(true); // Fair lock
public static void main(String[] args) {
Thread t1 = new Thread(() -> {
lock.lock();
try {
System.out.println("Thread 1 is executing critical section");
} finally {
lock.unlock();
}
});
Thread t2 = new Thread(() -> {
lock.lock();
try {
System.out.println("Thread 2 is executing critical section");
} finally {
lock.unlock();
}
});
t1.start();
t2.start();
}
}
By passing true to the constructor of ReentrantLock, we ensure that the lock is fair, and threads acquire the lock in the order they requested it.
Advantages of ReentrantLock
- Explicit Locking: With
ReentrantLock, you can explicitly lock and unlock, giving more control than synchronized methods or blocks. - Interruptible Lock Acquisition: The lock can be acquired in a way that allows the thread to be interrupted if needed.
- Timed Lock Acquisition: You can try to acquire the lock with a timeout, reducing the chance of indefinite blocking.
- Fairness Option: You can ensure that threads acquire the lock in the order they requested it.
- Non-blocking Features:
ReentrantLockprovides non-blocking methods liketryLock()andlockInterruptibly().
Conclusion
In conclusion, the ReentrantLock class is a powerful tool in Java for controlling thread synchronization. It provides advanced features like reentrancy, fairness, interruptibility, and timed locking, making it a versatile choice for managing concurrent access to shared resources. By using ReentrantLock, developers can avoid common issues like deadlock and thread starvation while enhancing the reliability and performance of their multithreaded applications.
