How would you define a reentrant lock in Java?

In Java, a ReentrantLock is a type of lock that allows a thread to acquire the same lock multiple times without blocking. This makes it possible for a thread to enter a synchronized block or method that it already holds a lock on, preventing deadlocks and improving the efficiency of the application.

Here’s an example of how to define a ReentrantLock in Java:

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockExample {
    private Lock lock = new ReentrantLock();

    public void doSomething() {
        lock.lock();
        try {
            // Critical section of code
        } finally {
            lock.unlock();
        }
    }
}

In this example, we define a ReentrantLock object and use it to protect a critical section of code in the doSomething() method. The lock() method is called to acquire the lock on the mutex, and the try-finally block is used to ensure that the lock is always released, even if an exception is thrown in the critical section of code.

Overall, a ReentrantLock is a powerful tool for managing access to shared resources in a multi-threaded application. By allowing threads to acquire the same lock multiple times, a ReentrantLock prevents deadlocks and improves the efficiency of the application.