面试官：重入锁的机制了解吗？-技术圈

点击“蓝字”，关注，置顶公众号

每日技术干货，第一时间送达！

首先我们这里提到的锁，是把所需要的代码块，资源，或数据锁上，在操作他们的时候只允许一个线程去做操作。最终结果是为了保证cpu计算结果的正确性。

对不可重入锁的理解：

public class Test{
     Lock lock = new Lock();
     public void methodA(){
         lock.lock();
         ...........;
         methodB();
         ...........;
         lock.unlock();
     }
     public void methodB(){
         lock.lock();
         ...........;
         lock.unlock();
     }
}

当A方法获取lock锁去锁住一段需要做原子性操作的B方法时，如果这段B方法又需要锁去做原子性操作，那么A方法就必定要与B方法出现死锁。这种会出现问题的重入一把锁的情况，叫不可重入锁。

A方法需要等B方法执行完才能解锁，但是B方法想执行完代码又必须要lock锁来加锁。A的锁未解锁前，其他代码块无法使用此锁来加锁。这是由这个不可重入锁决定的。

不可重入锁：

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();
    }
}

那么平时我们又有需要重入一把锁的需求！！！！比如A方法是个原子性操作，但它有需要调用B方法的原子性操作，他们还争抢的是同一个临界资源，因此需要同一把锁来加锁（ps：争抢同一临界资源的实质就是对同一把锁的争抢），欢迎关注我们，公号IT码徒。

针对此情况，就有了可重入锁的概念：

可重入锁的实现：

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();
            }
        }
    }
}

可以看见代码的核心概念是：

首先解释lockedBy：顾名思义，临界资源被哪个线程锁住了。

加锁时，先获取当前线程。（识别谁需要锁）

Thread thread = Thread.currentThread();

判断：当临界资源已被锁上，但当前请求锁的线程又不是之前锁上临界资源的线程。那么当前请求锁的线程需要等待。

while(isLocked && lockedBy != thread){
        wait();
}

注意上面是个while，并且是个wait，因此当请求线程请求不到锁的时候，就wait了。

当时当while不满足有的3种情况：

A:当前锁没有线程使用.

B:当前锁有线程使用，当前请求锁的线程就是现在正在使用锁的线程。

C:当前锁没有线程使用，当前请求锁的线程就是现在正在使用锁的线程。（不可能出现，锁0没有被用，哪还有线程使用锁）

来看看

A:没有线程使用：

那么：

isLocked = true;
lockedCount++;
lockedBy = thread;

当前请求锁的线程先把锁加上，然后把上锁次数＋1，然后把自己（本线程）赋值给lockedBy，以说明当前谁用了这把锁方便之后重入的时候做while判断。

再来看解锁：

public synchronized void unlock(){
    if(Thread.currentThread() == this.lockedBy){
        lockedCount--;
        if(lockedCount == 0){
            isLocked = false;
            notify();
        }
    }
}