reentrantlock in java

The ReentrantLock class implements the Lock interface. It is the most widely used implementation class of Lock interface. It works in same way as synchronized keyword with extended capabilities.

As the name suggest, it allows threads to re-enter into lock on a resource more than once. When the thread first enters into lock, a hold count is set to one. Before unlocking the thread can re-enter into lock again and every time hold count is incremented by one. For every unlock request, hold count is decremented by one and when hold count is 0, the resource is unlocked.

Example

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.ReentrantLock;
 
public class LockTest {
  public static void main(String[] args) {
	ExecutorService executorService = Executors.newFixedThreadPool(2);
        ReentrantLockMethodsCounter lockMethodsCounter = new ReentrantLockMethodsCounter();
        executorService.submit(() -> {
           System.out.println("IncrementCount (First Thread) : " +
                   lockMethodsCounter.incrementAndGetCounter());
        });
 
        executorService.submit(() -> {
            System.out.println("IncrementCount (Second Thread) : " +
                    lockMethodsCounter.incrementAndGetCounter());
        });
 
        executorService.shutdown();
  }
}
 
 
class ReentrantLockMethodsCounter {
    private final ReentrantLock lock = new ReentrantLock();
    private int count = 0;
    public int incrementAndGetCounter() {
        boolean isAcquired = lock.tryLock();
        System.out.println("Lock Acquired : " + isAcquired);
        if(isAcquired) {
            try {
                Thread.sleep(1000);
                count = count + 1;
            } catch (InterruptedException e) {
                throw new IllegalStateException(e);
            } finally {
                lock.unlock();
            }
        }
        return count;
    }
}
 
 
class ReentrantLockCounter {
    private final ReentrantLock lock = new ReentrantLock();
    private int count = 0;
    //Use Lock For Thread Safe Increment
    public void increment() {
        lock.lock();
        try {
            count = count + 1;
        } finally {
            lock.unlock();
        }
    }
}

Output

Lock Acquired : true
Lock Acquired : false
IncrementCount (Second Thread) : 0
IncrementCount (First Thread) : 1

The basic idea behind locking is to acquire the lock when any thread calls increment method. Thread will release the lock after incrementing the variable so that other waiting threads can acquires the lock.

We have used try-catch block to ensure that the lock is released if any exception occurs.

Please follow and like us: