ReentrantLock源码分析

一、ReentrantLock介绍

　　ReentrantLock是JDK1.5引入的，实现Lock接口的互斥锁。保证多线程的环境下，共享资源的原子性。与Synchronized的非公平锁不同，ReentrantLock的实现公平锁、非公平锁。ReentrantLock是重入锁，重入是指，同一个线程可以重复执行加锁的代码段。

二、ReentrantLock使用

　　ReentrantLock功能与Synchronized一样，使用起来比Synchronized更加灵活。与Synchronized自动加锁、释放锁不同，ReentrantLock需要手动加锁、释放锁。使用示例如下：

import java.util.concurrent.locks.ReentrantLock;

public class TestReentrantLock {
    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        lock.lock();
        try{
            // todo
        }finally {
            lock.unlock();
        }
    }
}

三、ReentrantLock原理

　　Synchronized基于对象实现；ReentrantLock基于 AQS + CAS 实现。

3.1、lock()流程图

 

　　ReentrantLock基于抽象队列同步器AQS + CAS 实现的加锁、释放锁。ReentrantLock实现了公平锁、非公平锁，公平锁与非公平锁唯一的区别在于，非公平锁不会判断等待队列中是否节点等待获取锁，而是直接尝试获取锁，获取不到，再将当前线程节点添加进等待队列的尾节点，判断当前线程节点是否挂起。

3.2、unlock()流程图

　　ReentrantLock释放锁的流程较为简单，优先判断持有锁资源的线程是否为当前线程，若不为当前线程抛出异常；若为当前线程，AQS的state的属性值减1，再判断减1后的值是否为0，若为0表示当前线程彻底释放锁资源，唤醒等待队列中的挂起线程节点，开始抢占锁资源。

四、ReentrantLock源码分析

1、构造函数

private final Sync sync;

// 默认使用非公平锁
public ReentrantLock() {
    sync = new NonfairSync();
}

// fair=true，公平锁；否则，非公平锁
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

　　Sync是ReentrantLock的抽象静态内部类，继承自AQS(AbstractQueuedSynchronizer) - 抽象队列同步器，AQS中定义了锁的基本行为，AQS中用volatile修饰的state表示当前锁重入的次数。

01  Sync类图：TODO

　　NonfairSync、FairSync是ReentrantLock的静态内部类，继承ReentrantLock$Sync，NonfairSync实现非公平锁，FairSync实现公平锁。

2、加锁

1、lock()

private final Sync sync;

// 加锁
public void lock() {
    sync.lock();
}

1.1、公平锁

　　调用AQS的acquire方法。ReentrantLock$FairSync#lock() 核心代码：

// 加锁
final void lock() {
    acquire(1);
}

1.2、非公平锁

　　通过CAS尝试获取锁(将AQS的state由0修改为1)，若成功，代表当前线程获取锁资源成功；若失败调用AQS的acquire方法。ReentrantLock$NonfairSync#lock() 核心代码：

// 加锁
final void lock() {
    // 获取锁资源，CAS 修改 AQS 的 state 属性值,，获取成功，设置当前线程
    if (compareAndSetState(0, 1))
        setExclusiveOwnerThread(Thread.currentThread());
    // 获取失败，执行AQS的acquire
    else
        acquire(1);
}

2、acquire()

　　acquire()方法是Sync父类AQS中的方法，AbstractQueuedSynchronizer#acquire() 核心代码：

// 获取锁资源
public final void acquire(int arg) {
    // 尝试获取锁资源
    if (!tryAcquire(arg) &&
        // 当前线程为获取到锁资源，加入等待队列，同时挂起线程，等待唤醒
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}　

　　1、调用tryAcquire方法：

　　2、调用addWaiter方法

　　3、调用acquireQueued方法

2.1、tryAcquire()

　　tryAcquire()方法在FairSync、NonFairSync中均有实现，尝试获取锁资源，核心代码如下：

// 公平锁 FairSync#tryAcquire() 方法
protected final boolean tryAcquire(int acquires) {
    // 获取当前线程
    final Thread current = Thread.currentThread();
    // 获取AQS的 state
    int c = getState();
    // state == 0 当前没有线程占用锁资源
    if (c == 0) {
        // 判断是否有线程在排队，若有线程在排队，返回true
        if (!hasQueuedPredecessors() &&
            // 尝试抢锁
            compareAndSetState(0, acquires)) {
            // 无线程排队，将线程属性设置为当前线程
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    // state != 0  有线程占用锁资源
    // 占用锁资源的线程是否为当前线程
    else if (current == getExclusiveOwnerThread()) {
        // state + 1
        int nextc = c + acquires;
        // 锁重入超出最大限制 (int的最大值)，抛异常
        if (nextc < 0)
            throw new Error("Maximum lock count exceeded");
        // 将 state + 1 设置给 state
        setState(nextc);
        // 当前线程拿到锁资源，返回true
        return true;
    }
    return false;
}

// 非公平锁  NonFairSync#tryAcquire() 方法
protected final boolean tryAcquire(int acquires) {
    return nonfairTryAcquire(acquires);
}

// 非公平锁  Sync#nonfairTryAcquire() 方法
final boolean nonfairTryAcquire(int acquires) {
     // 获取当前线程
    final Thread current = Thread.currentThread();
    // 获取AQS的 state
    int c = getState();
    // 无线程占用锁资源
    if (c == 0) {
        // CAS 修改 state 的值，修改成功，设置线程属性为当前线程，返回占用锁资源标识
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    // 有线程占用锁资源
    // 占用锁资源的线程是当前线程（重入）
    else if (current == getExclusiveOwnerThread()) {
        // AQS 的 state + acquires
        int nextc = c + acquires;
        // 超出锁重入的上限(int的最大值)，抛异常
        if (nextc < 0)
            throw new Error("Maximum lock count exceeded");
        // 将 state + acquires 设置到 state 属性
        setState(nextc);
        return true;
    }
    return false;
}

　　获取当前线程、AQS的state。AQS的state属性值为0，表示无线程占用锁资源，判断等待队列中是否有线程在排队，若有线程在排队，返回尝试抢锁失败标识，将线程添加进等待队列中。

　　若state属性值不为0，判断持有锁资源的线程是否为当前线程，若为当前线程，AQS的state属性值 + 1，返回尝试抢锁成功标识。

　　公平锁与非公平锁的整体实现流程类似，唯一不同的是，AQS的state属性值为0，无线程占用锁资源时，非公平锁不会判断是否有线程在等待队列中排队，而是直接通过CAS抢锁。

2.2、addWaiter()

　　为当前线程创建入队节点AbstractQueuedSynchronizer$Node，入参mode表示锁类型，在AQS的静态内部类Node中有SHARE、EXCLUSIVE两个属性，SHARE代表共享锁、EXCLUSIVE代表排它锁。　　

 　　AbstractQueuedSynchronizer#addWaiter() 核心代码：

// 等待队列的尾节点，懒加载，只能通过enq方法添加节点
private transient volatile Node tail;

private Node addWaiter(Node mode) {
    // 当前线程、获取的锁类型封装为Node对象
    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;
        }
    }
    // 等待队列为空，初始化等待队列节点信息
    enq(node);
    // 返回当前线程节点
    return node;
}　

　　等待队列不为空，将当前线程封装的Node节点添加进队列尾部；若等待队列为空，先初始化等待队列，然后在将Node节点添加进队列尾部。

2.2.1、enq()

　　等待队列尾节点为空时，执行enq()方法初始化等待队列，并将Node节点添加进等待队列中。

private Node enq(final Node node) {
    for (;;) {
        // 获取等待队列的尾节点
        Node t = tail;
        // 等待队列为空，初始化等待队列
        if (t == null) {
            // 初始化等待队列头尾节点
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            // 当前线程的Node添加到等待队列中
            node.prev = t;
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}

2.3、acquireQueued()

　　当前线程是否挂起，AbstractQueuedSynchronizer#acquireQueued() 核心代码：

final boolean acquireQueued(final Node node, int arg) {
    // 获取锁资源标识
    boolean failed = true;
    try {
        boolean interrupted = false;
        // 自旋
        for (;;) {
            // 获取当前节点的前驱节点
            final Node p = node.predecessor();
            // 当前节点的前驱节点为头节点，并获取锁资源成功
            if (p == head && tryAcquire(arg)) {
                // 将当前节点设置到head - 头节点
                setHead(node);
                // 原头节点的下一节点指向设置为null，GC回收
                p.next = null;
                // 设置获取锁资源成功
                failed = false;
                // 不管线程GC
                return interrupted;
            }
            // 如果当前节点不是head的下一节点，获取锁资源失败,尝试将线程挂起
            if (shouldParkAfterFailedAcquire(p, node) &&
                // 线程挂起， UNSAFE.park()
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

　　查看当前排队的Node是否是head的next， 如果是，尝试获取锁资源， 如果不是或者获取锁资源失败那么就尝试将当前Node的线程挂起（unsafe.park()）。

　　shouldParkAfterFailedAcquire检查并更新未成功获取锁资源的状态，返回true表示线程被挂起。

　　AbstractQueuedSynchronizer#shouldParkAfterFailedAcquire() 核心代码：

static final class Node {
    // 线程被取消
    static final int CANCELLED =  1;
    // 等待队列中存在待被唤醒的挂起线程
    static final int SIGNAL    = -1;
    // 当前线程在Condition队列中，未在AQS对列中
    static final int CONDITION = -2;
    // 解决JDK1.5的BUG。共享锁在释放资源后，若头节点为0，无法确定真的没有后继节点
    // 如果头节点为0，需要将头节点的状态改为 -3 ，当最新拿到锁资源的线程查看
    // 是否有后继节点并且为当前锁为共享锁，需唤醒排队的线程。
    static final int PROPAGATE = -3;
}

// 获取锁资源失败，挂起线程
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    // 获取当前节点的上一个节点的状态
    int ws = pred.waitStatus;
    // 上一节点被挂起
    if (ws == Node.SIGNAL)
        // 返回true，挂起当前线程
        return true;
    if (ws > 0) {
        // 上一节点被取消，获取最近的线程挂起节点，
        // 并将当前节点的上一节点指向最近的线程挂起节点
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        // 最近线程挂起节点的下一节点指向当前节点
        pred.next = node;
    } else {
        // 上一节点状态小于等于0，存在线程处于等待状态，但未被挂起的场景
        // 通过CAS将处于等待的线程挂起，避免在挂起前节点获取到锁资源
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    //  返回true，不挂起当前线程
    return false;
}

　　在挂起线程前，确认当前节点的上一个节点的状态。若为1，代表是取消的节点，不能挂起；若为-1，代表后续节点中有挂起的线程；若为-2 (线程在等待队列 - Condition队列中)、-3 (避免线程无法唤醒的一个状态)，需要将状态改为-1之后，才能挂起当前线程。

3、释放锁

1、unlock()

　　释放锁，ReentrantLock#unlock() 核心代码：

// 释放锁
public void unlock() {
    sync.release(1);
}

　　unlock方法实际调用的是AQS的release方法，AbstractQueuedSynchronizer#release() 核心代码：

// 等待队列的头节点，懒加载，通过setHead方法初始化
private transient volatile Node head;

// 释放锁
public final boolean release(int arg) {
    // 当前线程释放锁资源的计数值
    if (tryRelease(arg)) {
        // 当前线程玩去释放锁资源，获取等待队列头节点
        Node h = head;
        if (h != null && h.waitStatus != 0)
            // 唤醒等待队列中待唤醒的节点
            unparkSuccessor(h);
        // 完全释放锁资源
        return true;
    }
    // 当前线程未完全释放锁资源
    return false;
}　

1.1、tryRelease()

　　释放锁，Reenttrant$Sync#tryRelease()的核心代码

// 释放锁
protected final boolean tryRelease(int releases) {
    // 修改 AQS 的 state 
    int c = getState() - releases;
    // 当前线程不是持有锁的线程，抛出异常
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    // 是否成功的将锁资源完全释放标识 （state == 0）
    boolean free = false;
    // 锁资源完全释放
    if (c == 0) {
        // 修改标识
        free = true;
        // 将占用锁资源的属性设置为null
        setExclusiveOwnerThread(null);
    }
    // state赋值
    setState(c);
    // 返回true表示当前线程完全释放锁资源；
    // 返回false标识当前线程是由锁资源，持有计数值减少
    return free;
}