ReentrantLock锁的可重入原理以及源码分析

了解Java中ReentrantLock可重入锁的人都知道可重入的原理：针对于同一线程而言，其中执行的嵌套同步方法只需获取一次锁，便可执行到底。

来个例子说明：在t线程中有两个同步方法A、B，而方法A中，调用了方法B。那么执行方法A的时候便获取到了锁对象，当执行到方法B中需要获取锁的时候，因为方法A、B处于同一个线程当中，而且使用的是可重入锁机制，所以方法B无须再次获取锁便可以继续执行之后的代码。

如果采用的是不可重入锁机制，那么当执行到方法B时候，就会和方法A争抢锁，而锁已被方法A获取。方法A当中需要执行完方法B才会释放锁，而方法B又需要锁才能执行，这种情况就会造成死锁。

（Synchronize关键字也属于可重入锁）

以上描述的就是可重入锁的一个作用和原理，具体到代码我们看下如何使用ReentrantLock锁实现可重入：

public class LockTest implements Runnable {

    ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        get();
    }

    public void get() {
        lock.lock();
        set();
        System.out.println("get");
        lock.unlock();
    }

    public void set() {
        lock.lock();
        System.out.println("set");
        lock.unlock();
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        LockTest lockTest = new LockTest();
        new Thread(lockTest).start();
    }
}

通过执行结果可以看到，先打印"set"，再打印"get"。说明执行方法set()时（此时锁已被方法get()获取）无需获取锁便可执行。

那在Java源码中可重入又是如何实现的？

要清楚这个问题，那就必须了解lock()方法当中做了什么。
ReentrantLock可重入锁的lock()有两套实现，一个是公平锁，另一个是非公平锁。因为Java当中默认使用的是非公平锁，因此以下的内容都是基于非公平锁的源码进行分析。

final void lock() {
    if (compareAndSetState(0, 1)) // 采用CAS原理，比较替换当前线程的状态state属性为1（state为0说明该锁没有被占用）。意味着当前有一个线程需要获取该锁
        setExclusiveOwnerThread(Thread.currentThread()); // 当比较替换成功返回true，说明state从0赋值为1，需要设置占有锁的线程为当前线程
    else
        acquire(1); // 该锁已被占用，请求锁
}

public final void acquire(int arg) {
    if (!tryAcquire(arg) && // 重点关注这个tryAcquire(1)方法（尝试获取锁），它是实现可重入机制的关键所在
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

protected final boolean tryAcquire(int acquires) {
       return nonfairTryAcquire(acquires); // 基于非公平锁的尝试获取锁
}

final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) { // 此处的作用和一开始，采用CAS原理修改锁的state属性和设置获取锁的线程作用类似，在此不再赘述
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    else if (current == getExclusiveOwnerThread()) { // 此处比较的是，当前线程与已占有锁的线程作比较。此处也是可重入机制实现的关键代码，详情见以下分析。
        int nextc = c + acquires; // 对锁属性state加1，意味着又多一个方法占有了该锁
        if (nextc < 0)
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}

终于到了实现可重入机制的具体关键代码，正是 current == getExclusiveOwnerThread() 这个条件比较。还记得在一开始的源码当中执行了 setExclusiveOwnerThread(Thread.currentThread()) ，将占有锁的线程设置为当前线程。而可重入机制的实现的基础原理，便是同个线程当中嵌套调用同步方法。所以该条件比较为true，同时返回值也是true。

我们已经知道了，通过条件比较最后的返回值为true。返回true的具体意义又是什么呢？

public final void acquire(int arg) {
    if (!tryAcquire(arg) && // 往回追溯到此处，方法返回true。说明尝试获取锁成功，不执行if条件的代码块，不阻塞该线程。
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) // 添加阻塞节点进入队列，阻塞当前线程
        selfInterrupt(); // 打断阻塞线程
}

到此便可说明了，当在同一个线程当中的调用（嵌套调用或者顺序调用）多个同步方法时候，只需要在第一个执行的同步方法中获取到锁，之后的同步方法便无须再获取锁也可直接执行。