ReentrantLock源码分析

一、ReentrantLock的介绍

1.简介

Java中提供的锁：synchronized, lock锁（ReentrantLock、ReentrantReadWriteLock）
ReentrantLock就是一个互斥锁，可以让多线程执行期间，只有一个线程在执行指定的一段代码。

2.使用方式

/*前置知识：CAS、volatile、AQS*/
ReentrantLock lock = new ReentrantLock();
//加锁
lock.lock();
try {
    // 执行业务...
} finally {
    //释放锁
    lock.unlock();
}

二、加锁的相关方法源码分析

ReentrantLock的所有方法如下图左侧所示：

1.lock方法

（1）在lock方法内部调用了sync.lock()抽象方法，发现该方法有两个实现。
Sync是一个内部静态抽象类，继承了AQS类

public class ReentrantLock implements Lock, java.io.Serializable {
    private static final long serialVersionUID = 7373984872572414699L;
    /** Synchronizer providing all implementation mechanics */
    private final Sync sync;

    /**
     * Base of synchronization control for this lock. Subclassed
     * into fair and nonfair versions below. Uses AQS state to
     * represent the number of holds on the lock.
     */
    abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = -5179523762034025860L;

        /**
         * Performs {@link Lock#lock}. The main reason for subclassing
         * is to allow fast path for nonfair version.
         */
        abstract void lock();

（2）抽象方法lock()有两种实现：公平的FairSync，和不公平的NonfairSync。
a. FairSync公平锁
每个线程在执行lock方法时，会先查看是否有线程排队，如果有，直接去排队。如果没有才去尝试竞争锁资源。
b. NonfairSync非公平锁
每个线程都会在执行lock方法时，先尝试获取锁资源，获取不到再排队。

（3）如果需要使用公平锁：在new ReentrantLock时，传入参数true.
如果需要使用非公平锁：直接调用无参构造方法（默认非公平锁）。
PS：更推荐非公平锁，非公平锁的效率比公平锁高。
（4）从源码的角度也发现了公平锁直接调用acquire方法尝试获取锁，

而非公平锁会先基于CAS的方式尝试获取锁资源，如果获取不到，才会执行acquire方法尝试获取锁。

2.分析AQS

AQS就是AbstractQueuedSynchronizer类，AQS内部维护着一个队列，还有三个核心属性：state、head、tail。
state代表当前锁重入的个数，用getState和setState方法读取和设置。

3. lock方法源码

非公平锁的lock方法：

//非公平锁的lock方法
final void lock() {
    //以CAS的方式，尝试将state从0改为1
    if (compareAndSetState(0, 1))
        // 进入if证明修改state成功，也就代表获取锁资源成功
        // 将当前线程设置到AQS中的exculusiveOwnerThread(AOS中，AOS为AQS的父类)，代表当前线程拿着锁资源（和后面的可重入锁有关）
        setExclusiveOwnerThread(Thread.currentThread());
    else
        acquire(1);
}

protected final boolean compareAndSetState(int expect, int update) {
    return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}

protected final void setExclusiveOwnerThread(Thread thread) {
    exclusiveOwnerThread = thread;
}

公平锁的lock方法：

//公平锁的lock方法
final void lock() {
    acquire(1);
}

4.ReentrantLock的acquire方法

acquire方法中调用了tryAcquire、addWaiter、acquireQueued三个方法
非公平锁和公平锁调用的acquire方法是一样的，只是tryAcquire方法分为公平锁和非公平锁的实现

// 公平锁还是非公平锁都会调用当前的acquire方法
public final void acquire(int arg) {
    // tryAcquire方法，分为两种实现。第一种是公平锁，第二种是非公平锁。
    // 公平锁：如果state为0，再看是否有线程排队，如果有就去排队。如果是锁重入的操作，直接获取锁。
    // 非公平锁：如果state为0，直接尝试CAS修改。如果是锁重入的操作，直接获取锁。
    if (!tryAcquire(arg) && // 如果tryAcquire返回fasle说明获取锁失败，要去尝试排队
        // addWaiter方法，在线程没有通过tryAcquire拿到锁资源时，需要将当前线程封装为Node对象，去AQS内部排队
        // acquireQueued方法：查看当前线程是否是排在队伍前面的，如果是就尝试获取锁资源。如果长时间没拿到锁，也需要将当前线程挂起
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

注：遇到的锁几乎都是可重入锁。只有一些特殊的实现，如线程池就单独实现了非可重入锁。

总结：acquire主要是三个部分：①tryAcquire方法获取锁，根据公平锁和非公平锁不同处理。②如果没拿到锁资源，调用addWaiter方法把当前线程封装成AQS的Node对象去排队。③排队后调用acquireQueued方法判断当前Node是不是头节点，能不能拿到锁资源，如果一直没拿到要把线程挂起。

5.ReentrantLock的tryAcquire方法

tryAcquire方法是AQS提供的，内部并没有任何的实现，需要继承AQS的类自己去实现逻辑代码
查看到tryAcquire在ReentrantLock中提供了两种实现：公平锁、非公平锁
非公平锁的实现逻辑：

protected final boolean tryAcquire(int acquires) {
    return nonfairTryAcquire(acquires);
}

// 非公平锁实现
final boolean nonfairTryAcquire(int acquires) {
    //获取了当前线程
    final Thread current = Thread.currentThread();
    // 获取AQS的state值
    int c = getState();
    // 如果state为0，这就代表当前没有线程占用锁资源
    if (c == 0) {
        // 直接基于CAS的方式，尝试修改state，从0~1，如果成功就代表拿到锁资源
        if (compareAndSetState(0, acquires)) {
            // 将exclusiveOwnerThread属性设置为当前线程（exclusiveOwnerThread为AQS父类AOS的属性）
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    // 说明state肯定不为0，不为0就代表当前lock被线程占用
    // 判断占用锁资源的线程是不是当前线程
    else if (current == getExclusiveOwnerThread()) {
        // 锁重入操作！
        // 对state + 1
        int nextc = c + acquires;
        // 判断锁重入是否已经达到最大值（整数溢出变为负数）
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        // 将AQS的state设置好
        setState(nextc);
        // 返回true
        return true;
    }
    //返回false表示在tryAcquire方法中想尝试拿到锁的资源但是没有拿到，要去排队了
    return false;
}

公平锁的实现逻辑：

protected final boolean tryAcquire(int acquires) {
    //获取了当前线程
    final Thread current = Thread.currentThread();
    // 获取AQS的state值
    int c = getState();
    // 没有线程占用锁资源
    if (c == 0) {
        //首先查看有没有线程排队
        if (!hasQueuedPredecessors() &&// 与非公平锁的实现只差在这一行代码上，先判断有无线程排队
            // 如果没有线程排队，CAS尝试获取锁资源（没有线程排队时，下面的代码逻辑公平锁和非公平锁是一样的）
            compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    else if (current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;
        if (nextc < 0)
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}

6.ReentrantLock的addWaiter方法

在线程执行tryAcquire方法没有获取到锁资源之后会返回false，再配合上if中的!操作，会执行&&后面的方法，而在acquireQueued(addWaiter(Node.EXCLUSIVE), arg)的参数中执行了addWaiter方法，要将当前获取锁失败的线程封装为Node，排队到AQS的队列中。
addWaiter方法参数是一个标识，代表当前锁是一个互斥锁

static final Node EXCLUSIVE = null;

// 获取锁失败，封装Node，排队到AQS的队列中
private Node addWaiter(Node mode) {// mode = null表示互斥锁
    // 将线程封装为Node对象
    Node node = new Node(Thread.currentThread(), mode);
    // 获取到tail节点，pred
    Node pred = tail;
    // 如果tail节点不为null（说明有人在排队）
    if (pred != null) {
        // 将当前节点的prev指向tail
        node.prev = pred;
        //为了避免并发问题，基于CAS的方式将tail指向当前线程
        if (compareAndSetTail(pred, node)) {
            // 将之前的tail的next，指向当前节点
            pred.next = node;
            //返回当前节点
            return node;
        }
    }
    // 如果在队列为空，或者CAS操作失败后，会执行enq方法，将node排到队列的末尾
    enq(node);
    return node;
}

// enq方法，传入的node就是当前节点
private Node enq(final Node node) {
    // 死循环
    for (;;) {
        // 获取tail节点
        Node t = tail;
        if (t == null) { // Must initialize
            // 如果队列为空，先初始化head节点作为头
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            // 到这里，队列肯定不为空，采用之前的逻辑，将当前节点插入到队列的末尾作为tail，循环到插入成功为止
            node.prev = t;
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}

整体逻辑为，先初始化Node节点，将当前线程传入，并且标识为互斥锁。
尝试将当前Node插入到AQS队列的末尾

• 队列为空：执行enq，先初始化空Node作为头，然后再将当前Node插入
• 队列不为空：直接将当前Node插入，作为tail

总结：tryAcquire先尝试获取锁，拿不到要排队，在addWaiter方法中完成Node的封装并将它放到末尾。

7.ReentrantLock的acquireQueue方法

首先查看当前node是否排在队列的第一个位置（不算head），直接再次执行tryAcquire方法竞争锁资源。
如果不是在第一个位置，就尝试将当前线程挂起，最终排在有效节点后，才会将当前线程挂起。

// 队伍前面，竞争锁资源。队伍非前面，挂起线程。
final boolean acquireQueued(final Node node, int arg) {//参数node就是上面addWaiter中封装好返回的node，arg就是1
    // 竞争锁资源失败标识，默认true
    boolean failed = true;
    try {
        // 线程中断标识
        boolean interrupted = false;
        // 死循环 核心代码
        for (;;) {
            // predecessor获取当前节点的上一个节点
            final Node p = node.predecessor();
            // 如果当前节点的上一个节点是head，就执行tryAcquire竞争锁资源
            if (p == head && tryAcquire(arg)) {
                // 竞争锁资源成功，进入当前业务代码
                // 因为当前线程已经拿到锁资源，将当前线程的Node设置为head，并且将Node中的prev和thread置为null
                /*node的线程获取了锁之后，这个node就没有用了,可以置空作为下一个头节点*/
                setHead(node);
                // 将之前的头节点的next置为null，让GC将之前的head回收掉
                p.next = null; 
                // 将获取锁失败的标识置为false
                failed = false;
                // 返回线程中断标识，默认情况为false
                return interrupted;
            }
            // 如果当前node不是第一个节点，那就尝试将它挂起，并且中断
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

尝试将当前线程挂起，涉及到了判断以及LockSupport的方法挂起线程
shouldParkAfterFailedAcquire(p, node)是一个判断，只有它返回ture才会调用中断方法，参数为上一个节点和当前节点。

// 判断当前线程是否可以挂起
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    // 拿到了上一个节点的状态
    int ws = pred.waitStatus;
    // 如果ws为-1，直接返回true，代表当前节点可以挂起线程
    if (ws == Node.SIGNAL)
        return true;
    // 如果ws > 0， 说明肯定是CANCELLED状态，绕过这个节点，找上一个节点的上一个
    if (ws > 0) {
        // 循环，直到找到上一个节点为小于等于0的节点
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        // 可能为0，-2，-3，直接以CAS的方式将节点状态改为-1
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

//线程状态
static final int CANCELLED =  1; // 线程被取消
static final int SIGNAL    = -1; // 正常状态
static final int CONDITION = -2; // 在执行锁时用到了condition对象调用await或signal操作，可以把状态变成SIGNAL
static final int PROPAGATE = -3; // 贡献锁，可以把状态变成SIGNAL

// 找到上一个节点状态是正常的后，就可以调用当前方法将线程挂起
private final boolean parkAndCheckInterrupt() {
    // 直接使用Unsafe类的park方法挂起线程
    LockSupport.park(this);
    return Thread.interrupted();
}

总结：acquireQueue方法一共两部分。第一部分是上一个节点是head时，直接tryAcquire。第二部分如果上一个节点不是head，要把线程挂起，当上一个节点状态为-1时可以挂起，如果不是-1，就找到前面-1的节点。
整个加锁过程：先用tryAcquire拿锁，拿不到添加一个node排到队列末尾，看一下队列的上一个是不是头节点，是就尝试竞争，不是就尝试挂起（调用park方法挂起）。当持有锁的线程释放锁时调用unpark方法唤醒线程。

三、释放锁的相关方法源码分析

1.ReentrantLock的unlock方法

ReentrantLock的lock、acquire、tryAcquire、addWaiter、acquireQueued方法用来获取锁资源，即把state成功的从0改为1. 同样，释放锁即把state从1改为0.
其中acquireQueued方法会将获取锁失败的线程用pack方法挂起，那么释放锁时会用unpack来唤醒挂起线程。
unlock是释放锁操作的入口

public void unlock() {
    //每次只释放1
    sync.release(1);
}

unlock释放锁操作不分公平和非公平，都是执行sync的release方法
释放锁的核心，就是将state从大于0的数值更改为0即为释放锁成功（如果涉及到锁重入，state的值可能是2）
并且unlock方法应该会涉及到将AQS队列中堵塞的线程进行唤醒，阻塞用的是park方法，唤醒必然是unpark方法。

2.ReentrantLock的release方法

在释放锁时，只有state被减为0之后，才会去唤醒AQS队列中被挂起的线程
在唤醒挂起线程时，如果head的next状态不正确，会从后往前找到离head最近的节点进行唤醒。
为什么从后往前找？addWaiter方法中是先将prev指针赋值，最后才会将上一个节点的next指针赋值。为了避免丢失节点或者跳过节点，必须从后往前找。

// 释放锁操作
public final boolean release(int arg) { //参数arg为1
    // 先查看tryRelease方法
    if (tryRelease(arg)) {
        // 释放锁成功，进行后续处理
        Node h = head;
        // 如果head不为null，并且当前head的状态不为0（只有状态为-1时，后面才有挂起的node线程。如果状态是0，后面没有挂起，不需要unpack唤醒线程的操作）
        if (h != null && h.waitStatus != 0)
            // 说明AQS的队列中，有Node在排队，并且线程已经挂起了
            // 需要唤醒被挂起的Node
            unparkSuccessor(h);
        return true;
    }
    // 返回false，代表释放一次没有完全释放掉
    return false;
}

protected boolean tryRelease(int arg) {
    throw new UnsupportedOperationException();
}

//ReentrantLock实现的release方法
//优先查看的tryRelease
protected final boolean tryRelease(int releases) {
    // 直接获取state，并且 - releases.将state - 1
    int c = getState() - releases;
    // 如果释放锁的线程，不是占用锁的线程，直接抛出异常。（健壮性判断）
    if (Thread.currentThread() != getExclusiveOwnerThread())
    /*注：try{}代码块中不要写lock.lock()方法，因为finally中有lock.unlock。避免抛出IllegalMonitorStateException下面的异常
    lock.lock()方法要放到try外面，在没有获取锁成功的情况下，不能执行try里面的业务代码*/
        throw new IllegalMonitorStateException();
    // 声明了一个标识
    boolean free = false;
    // 判断state - 1后是否为0
    if (c == 0) {
        // 如果为0，锁资源释放掉了
        free = true;
        // 将占用互斥锁的线程标识置为null
        setExclusiveOwnerThread(null);
    }
    // 锁之前重入了，一次没释放掉，将c赋值给state，等待下次再次执行时，再次判断
    setState(c);
    return free;
}

// 唤醒AQS中被挂起的线程
private void unparkSuccessor(Node node) {
    // 获取head的状态
    int ws = node.waitStatus;
    if (ws < 0)
        // 将当前head状态设置为0（代表当前的head节点已经失效）
        compareAndSetWaitStatus(node, ws, 0);
    // 拿到next节点
    Node s = node.next;
    // 如果下一个节点为null，或者状态为CANCEL，需要找到离head节点最近的有效Node
    if (s == null || s.waitStatus > 0) {
        s = null;
        // 从后往前找这个节点（为什么从后往前找，需要查看addWaiter的内容）
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                s = t;
    }
    //找到最近的node后，直接唤醒
    if (s != null)
        // 唤醒线程
        LockSupport.unpark(s.thread);
}