Java ReentrantLock lockInterruptibly() Method

The lockInterruptibly() method of ReentrantLock class hold the lock until or unless the current thread is interrupted.

Syntax

Parameter

No parameter is passed.

Returns

Throws

InterruptedException - if the current thread is interrupted

Example 1

import java.util.Date; 
import java.util.concurrent.ExecutorService; 
import java.util.concurrent.Executors; 
import java.util.concurrent.locks.ReentrantLock; 
  
class WorkerClass29 implements Runnable 
{ 
  String nm; 
  ReentrantLock relc; 
  public WorkerClass29(ReentrantLock rl, String n) 
  { 
    relc = rl; 
    nm = n; 
  } 
  public void run() 
  { 
    
    
      //Outer Lock 
      boolean ans = relc.tryLock(); 
  
      //  True if lock is free 
      if(ans) 
      { 
        
        
        int i =0;
       	 Thread t=new Thread();
       	 
       	 for(  i=0 ; i<5 ; i++)
       	 {
       		if(i>3){        				
       			System.out.println("    "+i+  "  " +t.getPriority());
       		
       			
       		}
       		if(i<2) {
       			System.out.println("    "+i+  "  " +t.getName());
       			
       		}
       		
       	 }
      
      } 
     
  }
}
     
public class  ReentrantLocklockInterruptiblyExample1
{ 
  static final int MAX_Time = 2; 
  public static void main(String[] args) 
  { 
    ReentrantLock rel = new ReentrantLock(); 
    ExecutorService pool = Executors.newFixedThreadPool(MAX_Time); 
    Runnable wrk1 = new WorkerClass29(rel, "Job1"); 
    pool.execute(wrk1); 
    pool.shutdown(); 
  } 
} 

Test it Now

Output:

0  Thread-0
1  Thread-0
4  5

Example 2

 import java.util.concurrent.locks.ReentrantLock;
 
 public class ReentrantLocklockInterruptiblyExample2  {
     public static void main(String[] args) {
  
            ReentrantLock lock=new ReentrantLock();
            MyRunnableClass909 myRnbl=new MyRunnableClass909(lock);
            new Thread(myRnbl,"Thread-1").start();
                        
     }
 }
    
 class MyRunnableClass909 implements Runnable{
     
     ReentrantLock lock;
     public MyRunnableClass909(ReentrantLock lock) { 
            this.lock=lock;
     }
     
     public void run(){
            
            System.out.println(Thread.currentThread().getName()
                         +" is Waiting to get the lock");
            
            try {
            	
                	int i=1;
                	Thread t=new Thread();
                  while(i<5) {
                	  
                	  System.out.println("     "+t.getThreadGroup());
                	  if(i==2)
                    System.out.println("     "+t.getThreadGroup());
                	  if(i==3)
                    System.out.println("     "+t.isInterrupted());
                	  if(i==4)
                    System.out.println("     "+t.getStackTrace());
                	  
                	  i=i+1;
                  }
                	  
                 
          
                  assert !lock.isHeldByCurrentThread();
                  lock.lock();
                            
                  System.out.println(" after sleep(1500) Is held by Current Thread - " + lock.isHeldByCurrentThread()); 
                 
                } 
                 
                finally {
                	lock.unlock();
                }       
     }
 }

Test it Now

Output:

Thread-1 is Waiting to get the lock
     java.lang.ThreadGroup[name=main,maxpri=10]
     java.lang.ThreadGroup[name=main,maxpri=10]
     java.lang.ThreadGroup[name=main,maxpri=10]
     java.lang.ThreadGroup[name=main,maxpri=10]
     false
     java.lang.ThreadGroup[name=main,maxpri=10]
     [Ljava.lang.StackTraceElement;@53bc4411
 after sleep(1500) Is held by Current Thread - true

Next TopicJava ReentrantLock

← prev next →