深入剖析ReentrantLock公平锁与非公平锁源码实现

原文地址： https://blog.csdn.net/lsgqjh/article/details/63685058

ReentrantLock是JUC包中重要的并发工具之一，支持中断和超时、还支持尝试机制获取锁，并且是一种通过编程控制的可重入锁，尽可能减少死锁问题。本文以公平与非公平锁的加锁释放锁过程成为主线，分析ReentrantLock的重要内容。

目标

掌握AQS基本原理，理解ReentrantLock的具体实现
挖掘体会AQS精妙设计

总之，学习AQS过程，要多思考为什么要这样实现，善于带着问题主动探索答案，不断的回过头去看，去思考，我们对并发会有更深的理解。在学习过程中沉淀的“pattern”认知和学习能力能够轻松的复制到我们工作实践和其它优秀代码的学习中。工作后时不时会遇到业界通用方案不匹配自身业务，到造轮子的时候可能才会后悔之前没有多多沉淀吧～。同时感谢我参考学习过的大神资料。

准备知识

ReentrantLock类图：

理想情况下，线程A拿到锁，执行完后释放锁，线程B恰好到来顺手接下这把锁，一切都那么完美的话，也没必要加锁了，问题就在于在A没释放锁时，后续线程也想得到这把锁，所以只好让这些等待的线程进行排队，进而需要一套数据结构来组织这个队伍：

Node结点：作为获取锁失败线程的包装类，组合了Thread引用，实现为FIFO双向队列。下图为Node结点的属性描述

下图为用Node节点构成的双向链表图示：

CLH queues need a dummy header node to get started. But we don’t create them on construction, because it would be wasted effort if there is never contention. Instead, the node is constructed and head and tail pointers are set upon first contention.

链表初始化的头节点其实是一个虚拟节点，英文名称之为dummy header，因为它不会像后继节点一样真实的存放线程，并且这个节点只会在真正产生竞争排队情况下才会延迟初始化，避免性能浪费，下面看代码的时候，我会再次提到。
AbstractQueuedSynchronizer 类是一个模版类，维护了着一个同步队列（双向链表），提供着同步队列一些操作的公共方法，JUC并发包里基于此类实现了很多常用的并发工具类，如 Semaphore, CountDownLatch等。

   /*** The synchronization state.*/private volatile int state;

AbstractQueuedSynchronizer维护了一个state变量，来表示同步器的状态，state可以称为AQS的灵魂，基于AQS实现的好多JUC工具，都是通过操作state来实现的，state为0表示没有任何线程持有锁；state为1表示某一个线程拿到了一次锁，state为n(n > 1)，表示这个线程获取了n次这把锁，用来表达所谓的“可重入锁”的概念。

锁的创建

非公平锁（默认）

final ReentrantLock lock = new ReentrantLock();
final ReentrantLock lock = new ReentrantLock(false);

公平锁

final ReentrantLock lock = new ReentrantLock(true);

非公平锁加锁过程

lock()方法的逻辑：多个线程调用lock（）方法，如果当前state为0，说明当前没有线程占有锁，那么只有一个线程会CAS获得锁，并设置此线程为独占锁线程。那么其它线程会调用acquire方法来竞争锁（后续会全部加入同步队列中自旋或挂起）。当有其它线程A又进来想要获取锁时，恰好此前的某一线程恰好释放锁，那么A会恰好在同步队列中所有等待获取锁的线程之前抢先获取锁。也就是说所有已经在同步队列中的尚未被取消获取锁的线程是绝对保证串行获取锁，而其它新来的却可能抢先获取锁。后面代码解释。

    static final class NonfairSync extends Sync {private static final long serialVersionUID = 7316153563782823691L;final void lock() {if (compareAndSetState(0, 1))setExclusiveOwnerThread(Thread.currentThread());elseacquire(1);}/*** 此为AQS的protected方法，允许子类重写， 在这里被NonfairSync类重写*/protected final boolean tryAcquire(int acquires) {return nonfairTryAcquire(acquires);}}

先看acquire方法：
逻辑：tryAcquire方法仍然尝试获取锁（快速获取锁机制），成功返回false，如果没有成功，那么就将此线程包装成Node加入同步队列尾部。。Node.EXCLUSIVE 为null表示这是独占锁，如果为读写锁，那就是共享模式(shared)。

    public final void acquire(int arg) {// tryAcquire()方法也是让新来的线程进行第二次插队的机会！！//如果再次获取锁还不成功才会放到队列if (!tryAcquire(arg) &&acquireQueued(addWaiter(Node.EXCLUSIVE), arg))selfInterrupt();}

再看addWaiter 逻辑：

Node包装当前线程
pred 尾指针不为null，即队列不为空，则快速CAS将自己设为新的tail
如果队列为空，则调用enq强制入队
如果CAS设置失败，说明在其它线程入队节点争抢了tail，则此线程只能调用enq强制入队

注意这里在链表尾部添加节点时，先设置的prev，我们先记住这个事情。

 private Node addWaiter(Node mode) {Node node = new Node(Thread.currentThread(), mode);// Try the fast path of enq; backup to full enq on failureNode pred = tail;if (pred != null) {node.prev = pred;if (compareAndSetTail(pred, node)) {pred.next = node;return node;}}enq(node);return node;}

 Node(Thread thread, Node mode) {     // Used by addWaiterthis.nextWaiter = mode;this.thread = thread;}

看Node的构造方法，属性 nextWaiter 值在此被赋予EXCLUSIVE表示独占模式。

下面是enq方法，方法内是一个for(;;)，看来退出的条件只能是当前线程入队成功。之前也提到过，只有在产生锁竞争了，才会去初始化链表头节点。如果队列为空，初始化头尾节点，然后后续循环会走到else，else的逻辑和上线CAS入队的逻辑一样，只不过这里套在for循环里，直到入队成功才退出循环。

private Node enq(final Node node) {for (;;) {Node t = tail; if (t == null) { // 判断队列是否为空，空队列应该先初始化头节点if (compareAndSetHead(new Node()))tail = head;//头尾共同指向头结点} else {//CAS添加并允许失败， 走for(;;)node.prev = t;if (compareAndSetTail(t, node)) {t.next = node;return t;//返回新插入节点的前置节点}}}}

入队完成后看下acquireQueued 逻辑：

failed 标记最终acquire是否成功， interrupted标记是否曾被挂起过。注意到for(;