Java不可重入锁和可重入锁理解

转自：https://blog.csdn.net/u012545728/article/details/80843595

最近正在阅读Java ReentrantLock源码，始终对可重入和不可重入概念理解不透彻，进行学习后记录在这里。

基础知识

Java多线程的wait()方法和notify()方法

这两个方法是成对出现和使用的，要执行这两个方法，有一个前提就是，当前线程必须获其对象的monitor（俗称“锁”），否则会抛出IllegalMonitorStateException异常，所以这两个方法必须在同步块代码里面调用。

wait()：阻塞当前线程

notify()：唤起被wait()阻塞的线程

不可重入锁

所谓不可重入锁，即若当前线程执行某个方法已经获取了该锁，那么在方法中尝试再次获取锁时，就会获取不到被阻塞。我们尝试设计一个不可重入锁：

 
 

   
   

    
    

   
   
   
   

    
    

     
     public 
     
     class Lock{
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     private 
     
     boolean isLocked = 
     
     false;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     public synchronized void lock() throws InterruptedException{
    
    
   
   

   
   

    
    

   
   
   
   

    
    
        
     
     while(isLocked){    
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                 wait();
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             }
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             isLocked = 
     
     true;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         }
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     public synchronized void unlock(){
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             isLocked = 
     
     false;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             notify();
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         }
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     }
    
    
   
   
 
 

使用该锁：

 
 

   
   

    
    

   
   
   
   

    
    

     
     public 
     
     class Count{
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         Lock lock = 
     
     new Lock();
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     public void print(){
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             lock.lock();
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             doAdd();
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             lock.unlock();
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         }
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     public void doAdd(){
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             lock.lock();
    
    
   
   

   
   

    
    

   
   
   
   

    
    
        
     
     //do something
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             lock.unlock();
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         }
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     }
    
    
   
   
 
 

当前线程执行print()方法首先获取lock，接下来执行doAdd()方法就无法执行doAdd()中的逻辑，必须先释放锁。这个例子很好的说明了不可重入锁。

可重入锁

接下来，我们设计一种可重入锁

 
 

   
   

    
    

   
   
   
   

    
    

     
     public 
     
     class Lock{
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     boolean isLocked = 
     
     false;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         Thread  lockedBy = 
     
     null;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     int lockedCount = 
     
     0;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     public synchronized void lock()
    
    
   
   

   
   

    
    

   
   
   
   

    
    
            
     
     throws InterruptedException{
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             Thread thread = Thread.currentThread();
    
    
   
   

   
   

    
    

   
   
   
   

    
    
        
     
     while(isLocked && lockedBy != thread){
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                 wait();
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             }
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             isLocked = 
     
     true;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             lockedCount++;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             lockedBy = thread;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         }
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     public synchronized void unlock(){
    
    
   
   

   
   

    
    

   
   
   
   

    
    
        
     
     if(Thread.currentThread() == 
     
     this.lockedBy){
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                 lockedCount–;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
            
     
     if(lockedCount == 
     
     0){
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                     isLocked = 
     
     false;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                     notify();
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                 }
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             }
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         }
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     }
    
    
   
   
 
 

所谓可重入，意味着线程可以进入它已经拥有的锁的同步代码块儿。

我们设计两个线程调用print()方法，第一个线程调用print()方法获取锁，进入lock()方法，由于初始lockedBy是null，所以不会进入while而挂起当前线程，而是是增量lockedCount并记录lockBy为第一个线程。接着第一个线程进入doAdd()方法，由于同一进程，所以不会进入while而挂起，接着增量lockedCount，当第二个线程尝试lock，由于isLocked=true,所以他不会获取该锁，直到第一个线程调用两次unlock()将lockCount递减为0，才将标记为isLocked设置为false。

可重入锁的概念和设计思想大体如此，Java中的可重入锁ReentrantLock设计思路也是这样