Lock in Java

In Java, Lock is an interface available in the Java.util.concurrent.locks package. Java lock acts as thread synchronization mechanisms that are similar to the synchronized blocks. After some time, a new locking mechanism was introduced. It is very flexible and provides more options in comparison to the Synchronized block.

These are some of the following differences between a Synchronized block and a Lock:

S.N.	Factor	Synchronized block	Lock
1.	Sequence guarantee	It doesn’t provide any guarantee of sequence in which the waiting thread will be access.	Unlike Synchronized block, the Lock interface handles it.
2.	No timeout	It doesn’t have any options of time when the lock is not granted.	The Lock interface provides such options at the time of granting the lock.
3.	Single method	It can be contained within a single method.	The lock() and unlock() methods of the interface can be called in different methods.

In Java, the Lock interface basically provides six methods which are as follows:

The lock() method

The lock() method is one of the most important methods of the Lock interface. It is used for acquiring the lock. For thread scheduling purposes, the current thread becomes disabled when the lock is not available. The lock() method is a public method that returns void.

Syntax:

Note: The lock implementation can be used for finding an incorrect use of a lock. In our code, the invocation can create a deadlock and can throw an unchecked exception.

The lockInterruptibly() method

The lockInterruptibly() method is another important method of Lock interface that is used for acquiring the lock unless the current thread is interrupted. It acquires and returns a lock immediately if it is available. Just like the lock() method, the current thread becomes disabled for thread scheduling purposes only when the lock is not available. At this time, the thread remains idle until the lock is not acquired or some other thread will not interrupt the current thread.

It throws the InterruptedException when the current thread is interrupted at the time of acquiring the lock.

The lockInterruptibly() method is a public method that returns void and takes no parameters:

Syntax:

The tryLock() method

The tryLock() method is mainly used at the time of invocation for acquiring the lock. It returns the lock immediately with the Boolean value true when the lock is available. It returns the Boolean value false when the lock is not available.

The tryLock() method take no parameters and return the Boolean value.

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        }  

The tryLock(long time, TimeUnit unit) method

It is another variation of the tryLock() method which is used for acquiring the lock when:

In the given waiting time, the lock will be free.
The current thread will not be interrupted.

It acquires and returns a lock immediately if it is available. Just like the lock() method, the current thread becomes disabled for thread scheduling purposes only when the lock is not available. At this time, the thread remains idle until the lock is not acquired by the current thread. Some other threads will not interrupt the current thread, or the specified waiting time elapses.

Syntax:

Parameters:

time: The time parameter defines the maximum time to wait for the lock.

unit: The unit parameter defines the time unit of the time argument.

Note: The tryLock(long time, TimeUnit unit) throws InterruptedExeption when the current thread is interrupted at the time of acquiring the lock.

The unlock() method

The unlock() method is another most common method which is used for releasing the lock. The unlock() method is a public method that returns nothing and takes no parameter.

Syntax:

The newCondition() method

The newCondition() method is used for getting a new Condition instance that is bound to this Lock instance.

The lock must be held by the current thread before waiting on the condition. A call to the condition.wait() will atomically release the lock before the wait and re-acquire the lock before the wait returns.

Syntax:

Note: The newCondition() throws UnsupportedOperationExeption when the lock implementation doesn’t support conditions.

LockExample.java

  package TutorAspire .MicrosoftJava;  // import required classes and packages  import java.text.SimpleDateFormat;  import java.util.Date;  import java.util.concurrent.ExecutorService;  import java.util.concurrent.Executors;  import java.util.concurrent.locks.ReentrantLock;  // create workerThread class for implementing the runnable worker thread  class workerThread implements Runnable  {  String name;  ReentrantLock lock;  // workerThread class constructor  public workerThread(ReentrantLock lock, String name)  {  this.lock = lock;  this.name = name;  }  // run() method provided by Runnable interface  public void run()  {  boolean execution = false;  while (!execution)  {  //get outer lock using tryLock() method  boolean result = lock.tryLock();  // the tryLock() method returns true when the lock is free  if(result)  {  // try section of outer lock  try  {  // create instance of Date class  Date dateObj = new Date();  // convert dateObj into required format using SimpleDateFormat class   SimpleDateFormat sdf = new SimpleDateFormat(“hh:mm:ss”);  System.out.println(“Task : “+ name + ” outer lock is acquired at “+ sdf.format(dateObj));  // use sleep() method of Thread class  Thread.sleep(1500);  // get inner lock using lock() method  lock.lock();  // try section of inner lock  try  {  dateObj = new Date();  sdf = new SimpleDateFormat(“hh:mm:ss”);  System.out.println(“Task : “+ name+ ” inner lock is acquired at “+ sdf.format(dateObj));  // use getHoldCount() method to get lock hold count of inner lock  System.out.println(“The lock hold count of inner lock: “+ lock.getHoldCount());    // use sleep() method of the thread class  Thread.sleep(1500);  }    // catch block for handling inner lock exceptions  catch(InterruptedException e)  {  e.printStackTrace();  }  // finally block for releasing the inner lock  finally  {  //inner lock release  System.out.println(“The inner lock is released by task : ” + name);  lock.unlock();  }    // use getHoldCount() method to get lock hold count of inner lock  System.out.println(“The lock hold count of inner lock: ” + lock.getHoldCount());  System.out.println(“The work of the ” + name + ” task is done”);  // set result to true  result = true;  }  // catch block for handling outer lock exceptions  catch(InterruptedException e)  {  e.printStackTrace();  }  // finally block for releasing the outer lock  finally  {  //Outer lock release  System.out.println(“The outer lock is released by task” + name);  lock.unlock();  System.out.println(“The lock hold count of outer lock: ” + lock.getHoldCount());  }  }  else  {     //print that tasks waiting for lock  System.out.println(“Task ” + name +” is waiting for the lock”);  try  {     // use sleep method to suspend execution   Thread.sleep(1000);  }  catch(InterruptedException e)  {  e.printStackTrace();  }  }  }  }  }  public class LockExample  {  // define final value for MAX_VAL  static final int MAX_VAL = 2;  // main() method start  public static void main(String[] args)  {  // create instance of the ReentrantLock   ReentrantLock lock = new ReentrantLock();   // create thread pool by using ExecutorService class   ExecutorService pool = Executors.newFixedThreadPool(MAX_VAL);   Runnable wt1 = new workerThread(lock, “Job1”);   Runnable wt2 = new workerThread(lock, “Job2”);   Runnable wt3 = new workerThread(lock, “Job3”);   Runnable wt4 = new workerThread(lock, “Job4”);   // execute jobs by using execute() method of ExecutorService   pool.execute(wt1);   pool.execute(wt2);   pool.execute(wt3);   pool.execute(wt4);   // shutdown pool   pool.shutdown();  }  }  

Output:

Lock in Java

Next TopicSegment Tree in Java

Lock in Java

Lock in Java

The lock() method

Note: The lock implementation can be used for finding an incorrect use of a lock. In our code, the invocation can create a deadlock and can throw an unchecked exception.

The lockInterruptibly() method

The tryLock() method

The tryLock(long time, TimeUnit unit) method

Note: The tryLock(long time, TimeUnit unit) throws InterruptedExeption when the current thread is interrupted at the time of acquiring the lock.

The unlock() method

The newCondition() method

Note: The newCondition() throws UnsupportedOperationExeption when the lock implementation doesn’t support conditions.

Java String indexOf() method

JavaScript String indexOf() Method

You may also like