ReentrantLock in Java

In Java, a Reentrant Lock is part of the java.util.concurrent.locks package and provides a more flexible mechanism for thread synchronization compared to the synchronized keyword. It allows threads to enter a lock multiple times (reentrant behavior) without causing deadlock on itself. It offers features like:

• Reentrancy: The same thread can acquire the lock multiple times. Each lock acquisition must be paired with a corresponding unlock.
• Explicit Locking: Unlike synchronized, Reentrant Lock requires manual locking and unlocking using lock() and unlock().
• Interruptible: Threads waiting for a lock can be interrupted.
• TryLock() Support: Threads can attempt to acquire a lock without waiting indefinitely.
• Fairness Policy: Locks can be configured to grant access in first-come-first-serve order.

Declaration and Usage

Reentrant locks are created using the ReentrantLock class:

import java.util.concurrent.locks.ReentrantLock; public class SharedResource {  private final ReentrantLock lock = new ReentrantLock();  public void performTask() {  lock.lock(); // Acquire lock  try {  // Critical section code  System.out.println(Thread.currentThread().getName() + " is performing task");  } finally {  lock.unlock(); // Release lock  }  } } 

Explanation:

• lock.lock() acquires the lock. If another thread holds it, the current thread waits.
• The critical section contains code that must be accessed by only one thread at a time.
• lock.unlock() releases the lock in the finally block to ensure it is released even if an exception occurs.

Reentrant Behavior Example

import java.util.concurrent.locks.ReentrantLock; public class ReentrantExample {  private final ReentrantLock lock = new ReentrantLock();  public void methodA() {  lock.lock();  try {  System.out.println("Inside Method A");  methodB(); // Reentrant lock allows the same thread to enter methodB  } finally {  lock.unlock();  }  }  public void methodB() {  lock.lock();  try {  System.out.println("Inside Method B");  } finally {  lock.unlock();  }  }  public static void main(String[] args) {  ReentrantExample example = new ReentrantExample();  example.methodA();  } } 

Inside Method A Inside Method B 

Here, the same thread acquires the lock twice without any issue, demonstrating reentrant behavior.

Fairness Policy

Reentrant locks can be created with a fairness option:

ReentrantLock fairLock = new ReentrantLock(true); // Fair lock 

• Fair lock: Threads acquire the lock in the order they requested it (first-come-first-serve).
• Non-fair lock (default): Threads may acquire the lock in an arbitrary order, which can improve throughput but may cause starvation.

ReentrantLock() Methods 

Advantages over synchronized