JMM——AQS之ReentrantLock源码解读

ReentrantLock源码解读

1.什么是ReentrantLock？

ReentrantLock是一个可重入锁，ReentrantLock主要是使用了AQS的独占和（是否公平）的特性实现的一个锁。
有意思的是，JDK没有自带的不可重入锁😁。当然，如果非要去使用不可重入锁，可以自己去写一个。了解加锁逻辑后，很简单。

2.ReentrantLock的用法

// 首先去创建一个对象
ReentrantLock reentrantLock = new ReentrantLock();
// 加锁
reentrantLock.lock();
// 解锁
reentrantLock.unlock();

使用起来很简单，接下来就看一下ReentrantLock的源码。

3.源码解读（公平锁为例）

3.1 从构造方法入手

查看ReentrantLock的构造方法，看一下创建ReentrantLock对象的时候，会做什么事情？

关于什么是非公平锁和公平锁，可以百度一下概念，后面会讲到两者代码层面的差别。本篇拿公平锁逻辑在看源码。

3.2 加锁逻辑入手 reentrantLock.lock();

此处可以看出，会进入sync.lock() 方法，深入看一下会发现sync是一个内部类抽象类，且继承AbstractQueuedSynchronizer类。在构造方法创建reentrantLock对象的时候，就初始化了sync的子类。这个代码写的确实不怎么样。进入看一下



到此，我们可以看到 tryAcquire(),addWaiter(),acquireQueued(),selfInterrupt(),四个方法。作用如下：

1. tryAcquire()，参数arg=1，此方法的作用是尝试去获取锁。
2. addWaiter(),参数Node.EXCLUSIVE，arg=1，表示reentrantLock是一个独占锁。此方法的作用是入队。
3. acquireQueued(), 参数是addWaiter()，arg=1，此方法的作用是挂起（线程休眠）。
4. selfInterrupt(),此方法的作用是自我中断，防止线程异常场景发生。

3.2.1 查看tryAcquire方法。

把源码复制过来。

// 参数 acquires 就是1.
protected final boolean tryAcquire(int acquires) {
			// 获取当前线程对象
            final Thread current = Thread.currentThread();
            // 获取同步器的当前状态，
            int c = getState();
            // 0表示没有线程在执行。
            if (c == 0) {
            	// 此处判断队列中有没有在排队的线程。同样用到短路与&&
                if (!hasQueuedPredecessors() &&
                	// 通过cas操作将状态加1
                    compareAndSetState(0, acquires)) {
                    // 设置同步器的独占锁
                    setExclusiveOwnerThread(current);
                    // 获取锁成功，返回true
                    return true;
                }
            }
            // 此代码逻辑，就是可重入的逻辑
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            // 获取不到锁就返回false。
            return false;
        }

图解代码逻辑：

3.2.2 查看addWaiter方法。

tryAcquire 没有获取到锁，就会执行addWaiter方法。

// 参数mode是 Node.EXCLUSIVE，因为ReentrantLock是独占锁。
private Node addWaiter(Node mode) {
		// 先创建个节点，节点包含当前线程，和此节点的状态。
        Node node = new Node(Thread.currentThread(), mode);
        // 获取同步器的尾部节点，即队列的尾部结点。
        Node pred = tail;
        // 尾部节点如果不等于null，说明队列里面有值，开始入队
        if (pred != null) {
        	// 设置尾部节点为当前节点的前置节点。
            node.prev = pred;
            // 将前置节点设置到同步器的尾部节点，表示新的节点就是尾部插入的。
            if (compareAndSetTail(pred, node)) {
            	// 又将当前的节点，设置成第一次获取的尾部节点为当前节点的头部节点。
                pred.next = node;
                // 返回当前节点
                return node;
            }
        }
        // 如果尾部节点等于null，说明队列没有值，在enq()逻辑进行入队
        enq(node);
        return node;
    }

// 如果尾部节点等于null，说明队列没有值，在这里进行入队
private Node enq(final Node node) {
		// ***此处精髓*** ，CAS加循环，典型的自旋锁逻辑。下面有重点讲解
        for (;;) {
        	// 获取头部节点
            Node t = tail;
            // 头部节点为null
            if (t == null) { // Must initialize
                // 将头部节点设置成一个空的Node对象
                if (compareAndSetHead(new Node()))
                    // 把尾部节点指向头部节点。后续会用到
                    tail = head;
            } else {
            	// 如果不等于null，说明头部节点已经有node对象了。
                node.prev = t;
                // 将此节点设置成尾部节点
                if (compareAndSetTail(t, node)) {
                    // 将头部节点的后置节点指向node节点。
                    t.next = node;
                    // 返回节点对象。
                    return t;
                }
            }
        }
    }

这里的代码逻辑，因为要考虑，队列是不是空的情况，所以比较绕。看图
图解代码逻辑：

3.2.3 查看acquireQueued方法。

此方法是进行挂起操作即线程的休眠。

// 参数node就是当前的节点，arg=1
final boolean acquireQueued(final Node node, int arg) {
        // 失败的标识符，为了代码的健壮性考虑。
        boolean failed = true;
        try {
        	// 线程中断的标识符
            boolean interrupted = false;
            // 此处循环+CAS，说明又用到自旋锁
            for (;;) {
            	// 获取当前节点的前置节点
                final Node p = node.predecessor();
                // 判断当前节点的前置节点是不是首节点。如果是尝试获取锁。
                if (p == head && tryAcquire(arg)) {
                	// 如果获取成功，设置当前节点为首节点。
                    setHead(node);
                    // 把当前节点的上一个节点，出队，断掉。
                    p.next = null; // help GC
                    // 剩下的代码无须多考虑
                    failed = false;
                    return interrupted;
                }
                // 获取锁失败，走这个逻辑，看一下shouldParkAfterFailedAcquire方法。看下面
                if (shouldParkAfterFailedAcquire(p, node) &&
                	// shouldParkAfterFailedAcquire 设置成功，走parkAndCheckInterrupt；看下面
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }
// 参数是pred当前节点的前置节点，node当前节点。
// 此方法主要做的工作就是将当前节点的前置节点waitStatus状态设置成Node.SIGNA。
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
		// 获取当前节点的前置节点的waitStatus，初始默认值为0
        int ws = pred.waitStatus;
       	// 是不是等于Node.SIGNAL，Node.SIGNAL代表阻塞队列，即当前节点的下一个节点是不是阻塞状态。因为此处代码复用，所以逻辑判断较为复杂。
        if (ws == Node.SIGNAL)
            return true;
        // 如果大于零，且不等于Node.SIGNAL，说明当前队列中的某些节点的前置节点是除Node.SIGNAL以外的。
        if (ws > 0) {
            do {
            	// 一直找，直到找到，直到找到节点状态为-1即Node.SIGNA
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            // 然后将找到的节点设置成当前节点的前置节点。
            pred.next = node;
        } else {
        // 否则，就设置当前节点的前置节点为Node.SIGNAL
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }
    
private final boolean parkAndCheckInterrupt() {
        // 把当前线程挂起，代码执行到这里，阻塞入队，就结束了。
        LockSupport.park(this);
        return Thread.interrupted();
    }

这里的代码逻辑，因为要考虑，队列中存在除Node.SIGNAL，0 以外其他状态的节点。
图解代码逻辑：

加锁逻辑结束！

3.3 释放锁逻辑入手 reentrantLock.unlock();

此处可以看出，执行了tryRelease，unparkSuccessor 方法，并且把头部节点的waitStatus设置成0。此处是用于非公平锁的场景，如果唤醒队列中的节点，依然没有抢到锁，再入队。

3.3.1 tryRelease(),尝试释放锁。

// 尝试释放锁，参数releases=1
protected final boolean tryRelease(int releases) {
            // 把当前状态减去1，可以减少重入次数。
            int c = getState() - releases;
            // 健壮判断无须关注
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            // 如果等于0，就说明无线程持有锁
            if (c == 0) {
                free = true;
                // 同步器的独占线程设置成null
                setExclusiveOwnerThread(null);
            }
            // 设置会状态值
            setState(c);
            return free;
        }

图解：

3.3.2 unparkSuccessor(),唤醒线程。

执行unparkSuccessor前看一下执行了什么‘

public final boolean release(int arg) {
        if (tryRelease(arg)) {
        	// 获取头部节点
            Node h = head;
            // 头部是否等于null，
            if (h != null && h.waitStatus != 0)
            	// 唤醒阻塞线程
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

再来看unparkSuccessor方法。

// 唤醒线程，参数为头部节点
private void unparkSuccessor(Node node) {
        // 头部节点的状态
        int ws = node.waitStatus;
        // 并且将头部节点的waitStatus=0，非公平锁的状态下，会有抢不到锁的情况.仍然可以再次入队。
        if (ws < 0)
            compareAndSetWaitStatus(node, ws, 0);
         // 获取头部节点的后置节点，也就是线程所在的节点。
        Node s = node.next;
        // 如果节点等于null，或者waitStatus大于零，就不属于ReentrantLock的职责范围。此时无需关注。
        if (s == null || s.waitStatus > 0) 
            s = null;
            for (Node t = tail; t != null && t != node; t = t.prev)
                if (t.waitStatus <= 0)
                    s = t;
        }
        // 不等于null，唤醒线程线程
        if (s != null)
            LockSupport.unpark(s.thread);
    		// 唤醒线程后回到java.util.concurrent.locks.AbstractQueuedSynchronizer#acquireQueued方法去。
    }

图解：

至此，公平锁逻辑结束。

3.源码解读（公平锁与非公平锁的差别）

释放锁逻辑一样，差别在于获取锁

3.1 差异1

公平锁

非公平锁

非公平锁，进来的时候会直接一次锁。获取不到在走acquire逻辑。公平锁直接走acquire逻辑。

3.2 差异2

公平锁

非公平锁

公平锁会调用hasQueuedPredecessors() 方法去判断，队列中是否有值。非公平锁不会。