什么是可重入锁和不可重入锁（包含ReentrantLock解析）？

前言

在之前的一次面试当中，被面试官狠狠拷打的一番juc，奈何我的juc学的一塌糊涂，今天在补juc的知识突然想到一个问题，什么是可重入锁和不可重入锁？以及为什么可重入锁的出现是为了解决什么问题？
话不多说，发车！

实验

首先我们做一个小实验

不可重入锁

自定义一个不可重入锁，这个锁是我们自己写的一个类

class NonReentrantLock {
    private boolean isLocked = false;

    public synchronized void lock() throws InterruptedException {
        while (isLocked) {
            wait(); // 别人持有锁就等待
        }
        isLocked = true;
    }

    public synchronized void unlock() {
        isLocked = false;
        notify(); // 通知别人可以抢锁了
    }
}

我们模拟使用这个锁进行操作

public class TestNonReentrantLock {
    NonReentrantLock lock = new NonReentrantLock();

    public void methodA() throws InterruptedException {
        lock.lock();
        System.out.println("methodA 获取锁");

        methodB();  // 再次尝试加锁
        lock.unlock();
    }

    public void methodB() throws InterruptedException {
        lock.lock();  // 这里会死锁
        System.out.println("methodB 获取锁");
        lock.unlock();
    }

    public static void main(String[] args) throws InterruptedException {
        TestNonReentrantLock test = new TestNonReentrantLock();
        test.methodA();
    }
}

运行下这段代码，运行后会卡死在 methodB 的 lock()，因为它试图再次获取已经持有的锁（但它不知道是自己）。

不可重入锁

那么下面我们使用可重入锁ReentrantLock

import java.util.concurrent.locks.ReentrantLock;

public class TestReentrantLock {
    ReentrantLock lock = new ReentrantLock();

    public void methodA() {
        lock.lock();
        try {
            System.out.println("methodA 获取锁");
            methodB();  // 重入，不会死锁
        } finally {
            lock.unlock();
        }
    }

    public void methodB() {
        lock.lock();  // ✅ 可重入
        try {
            System.out.println("methodB 获取锁");
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        new TestReentrantLock().methodA();
    }
}

结果如下，成功获取到了锁。

ReentrantLock

被面试官狠狠拷打了ReentrantLock的原理，结果答得很不好，这一次好好的学习一下ReentrantLock
我们点击进入ReentrantLock的源码去看看

可以看到ReentrantLock 里面有一个内部类 Sync，Sync 继承 AQS（AbstractQueuedSynchronizer），添加锁和释放锁的大部分操作实际上都是在 Sync 中实现的。Sync 有公平锁 FairSync 和非公平锁 NonfairSync 两个子类。

ReentrantLock 默认使用的是不公平锁，在上图的第一个构造函数中可以看到。
如果想用的是公平锁，就要使用第二个构造函数，可以传入true或false进行公平锁的获取。
主要的操作是在AQS中，下面顺着ReetrantLock我们去看看AQS是干什么的

AQS

介绍

AQS是一个抽象类，主要就是为锁和同步器构建了一个通用功能的实现，用AQS的包括有ReentrantLock，Semaphore等都是基于ReentrantLock的

AQS的核心原理

比较核心的是三部分
1.state
2.FIFO队列
3.实现获取/释放等方法

AQS是怎么工作的？

以ReentrantLock举例，如果state==0，那么此时说明这个资源是闲置的，
当一个节点来袭时，首先会将它变成一个Node放入这个CLH队列（FIFO队列）
放入队列后，这个节点每重入一次，就会将这个state++;
当另一个节点来袭时，首先尝试获取state，发现不是0，便进入到CLH队列，并且将前一个节点的waitStatus设置，等前一个节点释放后，就会唤醒自己
这时又来了另一个节点，这个节点也加入到fifo队列当中去
如果这个时候选的是公平锁，那么下一次这两个节点会排排队，赤果果
如果不是公平锁，这个头节点后面的节点，可能会被还未入队的节点抢走

那不禁要问了，既然是FIFO哪来的不公平呢？

这是在头节点后面一个节点被唤醒的时候，在这个期间，如果设置的锁是公平锁，那么他执行的代码是这样的

if (!hasQueuedPredecessors()) {
    // 没人排队在我前面，我可以抢
}

如果设置的是不公平的锁，那么他执行的代码是这样的，直接进行抢

if (compareAndSetState(0, 1)) {
    // 成功抢到，插队了
}

所以说，抢的时机是在释放锁的瞬间发生的。

这下，对reentrantLock的了解是不是更多了呢