What is ReentrantLock in Java? Difference between synchronized vs ReentrantLock with Example

ReentrantLock in Java is added on java.util.concurrent package in Java 1.5 along with other concurrent utilities like CountDownLatch, Executors, and CyclicBarrier. ReentrantLock is one of the most useful additions in Java concurrency package and several of concurrent collection classes from java.util.concurrent package is written using ReentrantLock, including ConcurrentHashMap, see How ConcurrentHashMap works in Java for more details. Two key feature of ReentrantLock, which provides more control on lock acquisition is trying to get a lock with the ability to interrupt, and a timeout on waiting for a lock, these are key for writing responsive and scalable systems in Java.


In short, ReentrantLock extends the functionality of synchronized keyword in Java and open the path for more controlled locking in Java. 

In this Java concurrency tutorial we will learn :

• What is ReentrantLock in Java?
• Difference between ReentrantLock and synchronized keyword in Java?
• Benefits of using Reentrant lock in Java?
• Drawbacks of using Reentrant lock-in concurrent program?
• Code Example of ReentrantLock in Java?

1. What is ReentrantLock in Java?

On class level,  ReentrantLock is a concrete implementation of the Lock interface provided in the Java concurrency package from Java 1.5 onwards.  

As per Javadoc, ReentrantLock is a mutual exclusive lock, similar to implicit locking provided by synchronized keyword in Java, with extended features like fairness, which can be used to provide lock to longest waiting thread. 

A lock is acquired by the lock() method and held by Thread until a call to unlock() method. The fairness parameter is provided while creating the instance of ReentrantLock in the constructor. ReentrantLock provides the same visibility and ordering guarantee, provided by implicitly locking, which means, unlock() happens before another thread gets lock(). 

And, if you are not familiar with key threading concepts in Java like happens-before then you can also see these Java Multithreading courses to learn more about locking and synchronization. 

2. Difference between ReentrantLock and synchronized keyword in Java

Though ReentrantLock provides the same visibility and orderings guaranteed as an implicit lock, acquired by synchronized keyword in Java, it provides more functionality and differs in certain aspects. 

As stated earlier, the main difference between synchronized and ReentrantLock is the ability to trying to lock interruptibly, and with a timeout. The thread doesn’t need to block infinitely, which was the case with synchronized. Let’s see a few more differences between synchronized and Lock-in Java.

1) Another significant difference between ReentrantLock and the synchronized keyword is fairness. The synchronized keyword doesn't support fairness. Any thread can acquire lock once released, no preference can be specified, on the other hand, you can make ReentrantLock fair by specifying fairness property while creating an instance of ReentrantLock. Fairness property provides a lock to the longest waiting thread, in case of contention.

2) The second difference between synchronized and Reentrant lock is tryLock() method. ReentrantLock provides a convenient tryLock() method, which acquires lock only if its available or not held by any other thread. This reduces the blocking of thread waiting for lock-in Java applications.

3) One more worth noting the difference between ReentrantLock and synchronized keyword in Java is, the ability to interrupt Thread while waiting for Lock. 

In case of a synchronized keyword, a thread can be blocked waiting for a lock, for an indefinite period of time and there was no way to control that. 

ReentrantLock provides a method called lockInterruptibly(), which can be used to interrupt thread when it is waiting for lock. Similarly, tryLock() with timeout can be used to timeout if the lock is not available in certain time period.

4) ReentrantLock also provides convenient method to get List of all threads waiting for lock.

So, you can see, lot of significant differences between synchronized keyword and ReentrantLock in Java. In short, Lock interface adds lot of power and flexibility and allows some control over lock acquisition process, which can be leveraged to write highly scalable systems in Java.

2.1 Benefits of ReentrantLock in Java

Most of the benefits derives from the differences covered between synchronized vs ReentrantLock in last section. Here is summary of benefits offered by ReentrantLock over synchronized in Java:

1) Ability to lock interruptibly.  Which means you can interrupt the thread while its waiting for lock. 

2) Ability to timeout while waiting for lock.

3) Power to create fair lock.

4) API to get list of waiting thread for lock.

5) Flexibility to try for lock without blocking.

2.2 Disadvantages of ReentrantLock in Java

Major drawback of using ReentrantLock in Java is wrapping method body inside try-finally block, which makes code unreadable and hides business logic. It’s really cluttered and I hate it most, though IDE like Eclipse and Netbeans can add those try catch block for you. 

Another disadvantage is that, now programmer is responsible for acquiring and releasing lock, which is a power but also opens gate for new subtle bugs, when programmer forget to release the lock in finally block.

3. Lock and ReentrantLock Example in Java

Here is a complete code example of How to use Lock interface and ReentrantLock in Java. This program locks a method called getCount(), which provides a unique count to each caller. Here we will see both synchronized and ReentrantLock versions of the same program. You can see code with synchronized is more readable but it’s not as flexible as locking mechanism provided by Lock interface.

import java.util.concurrent.locks.ReentrantLock;

import java.util.logging.Level;

import java.util.logging.Logger;

/**

 * Java program to show, how to use ReentrantLock in Java.

 * Reentrant lock is an alternative way of locking

 * apart from implicit locking provided by synchronized keyword in Java.

 *

 * @author  Javin Paul

 */

public class ReentrantLockHowto {

    private final ReentrantLock lock = new ReentrantLock();

    private int count = 0;

     //Locking using Lock and ReentrantLock

     public int getCount() {

        lock.lock();

        try {

            System.out.println(Thread.currentThread().getName() + " gets Count: " + count);

            return count++;

        } finally {

            lock.unlock();

        }

     }

     //Implicit locking using synchronized keyword

     public synchronized int getCountTwo() {

            return count++;

     }

    

    public static void main(String args[]) {

        final ThreadTest counter = new ThreadTest();

        Thread t1 = new Thread() {

            @Override

            public void run() {

                while (counter.getCount() < 6) {

                    try {

                        Thread.sleep(100);

                    } catch (InterruptedException ex) {

                        ex.printStackTrace();                    }

                }

            }

        };

      

        Thread t2 = new Thread() {

            @Override

            public void run() {

                while (counter.getCount() < 6) {

                    try {

                        Thread.sleep(100);

                    } catch (InterruptedException ex) {

                        ex.printStackTrace();

                    }

                }

            }

        };

      

        t1.start();

        t2.start();

      

    }

}

Output:

Thread-0 gets Count: 0

Thread-1 gets Count: 1

Thread-1 gets Count: 2

Thread-0 gets Count: 3

Thread-1 gets Count: 4

Thread-0 gets Count: 5

Thread-0 gets Count: 6

Thread-1 gets Count: 7

That’s all on What is ReentrantLock in Java, How to use with a simple example, and the difference between ReentrantLock and synchronized keyword in Java. We have also seen significant enhancement provided by Lock interface over synchronized e.g. trying for the lock, timeout while waiting for lock and ability to interrupt thread while waiting for the lock. Just be careful to release lock in finally block.

Related Java multithreading and concurrency tutorials from Javarevisited Blog

How to write code to avoid deadlock in Java

2 examples of race conditions in Java

What is counting semaphore in Java with example

Difference between Thread and Runnable in Java

How to use ThreadLocal variable in Java

And lastly, one question for you? What is difference between ReentrantLock and ReadWriteLock in Java? Can you use ReadWriteLock in place of ReentrantLock in Java?