Lock Interface in Java

The lock interface is one of the most used interfaces in Java. Lock interface is available in the Java.util.concurrent.locks package which we use as a thread synchronization mechanism, i.e., similar to synchronized blocks. It is more flexible and provides more options in comparison to the synchronized block.

These are the following differences between synchronized block and lock interface:

Parameter	Lock	Synchronized block
Guarantee of sequence	The lock interface ensures the sequence in which the waiting thread will be given access.	Synchronized block doesn't handle it.
No timeout	It provides options of timeout when the lock is not granted.	It doesn't provide such options.
Single method	We can call the lock's method in different methods.	It must be fully contained within a single method.

Lock Methods

Lock interface provides the following methods:

1. lock() method

The lock () method is one of the most important methods which is used for acquiring the lock. The current thread will become disabled for thread scheduling purposes when the lock is not available.

The lock () method doesn't return any value and has the following syntax:

2. The lockInterruptibly() method

This method is used to acquire the lock unless the current thread is interrupted. It acquires and returns a lock immediately if it is available. It is also a public method that returns void and takes no parameters:

Syntax:

3. The tryLock() method

It is another important method for acquiring the lock at the time of invocation. It accepts no parameters and returns the lock with a Boolean value based on the availability of the lock.

Syntax:

We use the tryLock() method in the following way:

Lock lock = .....;  
// use tryLock() to check availability of lock  
if (lock.tryLock()) {  
	try {  
		// in try block, we manipulate the protected state  
          } finally {  
    		// we unlock the current lock  
              	lock.unlock();  
          }  
} else {  
	// perform alternative actions  
}  

4. tryLock(long time, TimeUnit unit) method

It is similar to the tryLock() method(without parameter), which immediately returns the lock when the current thread is not interrupted, and the lock will be free within a given waiting time.

Syntax:

Parameters:

It accepts the following two parameters:

time: maximum waiting time for the lock.

unit: time unit of the time argument.

5. The unlock() method

It is a public method used for releasing the lock. It doesn't take any parameter and return any value.

Syntax:

Let's see an example and understand how to implement the Lock interface in Java.

LockExample.java

//import required package  
package javaTpoint.JavaExample;

//import required classes
import java.text.SimpleDateFormat;  
import java.util.Date;  
import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
import java.util.concurrent.locks.ReentrantLock;  

//class to implement runnable worker tread
class Work implements Runnable  
{  
	// declare variables
	String threadName;  
	ReentrantLock reentrantLock;  
	
	// initialize variables using constructor
	public Work(ReentrantLock reentrantLock, String threadName)  
	{  
		this.reentrantLock = reentrantLock;  
		this.threadName = threadName;  
	}  
	// define run() method Runnable interface
	public void run()  
	{  
		boolean exe = false; 
		
		// repeat steps until exe = false
		while (!exe)  
		{  
			//use tryLock() method to get outer lock
			boolean result = reentrantLock.tryLock();	// returns true when lock is available  
			if(result)  
			{  
				try  
				{  
					Date dateObj = new Date();  
					SimpleDateFormat sdf = new SimpleDateFormat("hh:mm:ss");  
					System.out.println("Outer lock is acquired at "+ sdf.format(dateObj)+" for task "+threadName);  
					Thread.sleep(1500);  
					
					// use lock() method to get inner lock
					reentrantLock.lock();  
					try  
					{  
						dateObj = new Date();  
						sdf = new SimpleDateFormat("hh:mm:ss");  
						System.out.println("Outer lock is acquired at "+ sdf.format(dateObj)+" for task "+threadName); 
						
						// use getHoldCount() method for getting the lock hold count of inner lock
						System.out.println("The lock hold count of inner lock is: "+ reentrantLock.getHoldCount());  
						Thread.sleep(1500);  
					}  
                   
					// catch block for handling inner lock exceptions and finally block for releasing lock
					catch(InterruptedException e)  
					{  
						e.printStackTrace();  
					}finally  
					{  
						System.out.println(threadName+" task release the inner lock: ");  
						reentrantLock.unlock();  
					}  
					System.out.println("The lock hold count of inner lock is: " + reentrantLock.getHoldCount());  
					System.out.println(threadName+" task is completed.");  
					
					
					result = true;  
				}  
				// catch block for handling outer lock exceptions and finally block for releasing lock
				catch(InterruptedException e)  
				{  
					e.printStackTrace();  
				}finally  
				{  
					System.out.println(threadName+" task release the outer lock: ");  
					reentrantLock.unlock();  
					System.out.println("The lock hold count of outer lock is: " + reentrantLock.getHoldCount());  
				}  
			}  
			else  
			{  
				System.out.println( threadName +" task is waiting for the lock");  
				try  
				{   
					Thread.sleep(1000);  
				}  
				catch(InterruptedException e)  
				{  
					e.printStackTrace();  
				}  
			}  
		}  
	}  
}  
public class LockExample  
{ 
	static final int Max_Data = 3;  
	// main() method start  
	public static void main(String[] args)  
	{  
		// create a lock 
		ReentrantLock reentrantLock = new ReentrantLock();  
		
		// make a thread pool by creating an instance of the ExecutorService class  
		ExecutorService pool = Executors.newFixedThreadPool(Max_Data);  
		Runnable work1 = new Work(reentrantLock, "Job A");  
		Runnable work2 = new Work(reentrantLock, "Job B");  
		Runnable work3 = new Work(reentrantLock, "Job C");  
		Runnable work4 = new Work(reentrantLock, "Job D");  
		
		// execute each job of the pool using execute() method
		pool.execute(work1);  
		pool.execute(work2);  
		pool.execute(work3);  
		pool.execute(work4);  
		
		// use shutdown() method for shutting down the pool 
		pool.shutdown();  
	}  
}  

Output: