本文共 9172 字，大约阅读时间需要 30 分钟。
简述：reentrantLock是java当中提供的一个锁，他和synchronized关键字有所不同，这篇文章主要是从reentrantLock获取锁，然后释放锁，来分析整个底层源码的实现，并不介绍ReentrantLock的具体使用（基于JDK1.8）
ReentrantLock 内部维护了一个Sync类， 这个类的两个有两个实现类，分别是NonfairSync和FairSync ，即非公平锁和公平锁。
我们主要是看下非公平锁，他的类继承关系如下：
对于AQS这个类，是java当中juc包的核心，这篇文章主要是从ReentrantLock的实现方式入手去分析AQS独占式锁的实现方式。juc包的整体实现采用的就是模板模式。通过重写各自需要的tryAcquire，tryRelease等方法即可。
AQS内部结构
static final class Node; // 维护由线程构成的列表 private transient volatile Node head; //线程链表的头结点 private transient volatile Node tail; //线程链表的尾节点 private volatile int state; //状态位 0 - 未被任何线程持有 大于等于1 已经有线程持有
static final class Node { static final Node SHARED = new Node(); // 是否是共享模式 static final Node EXCLUSIVE = null; // 排他模式 static final int CANCELLED = 1; // 取消状态static final int SIGNAL = -1; // 等待触发状态 static final int CONDITION = -2; //等待唤醒条件 static final int PROPAGATE = -3; // 节点状态需要向后传播 volatile int waitStatus; volatile Node prev; volatile Node next; volatile Thread thread; //当前节点持有的线程 Node nextWaiter; 关于waitStatus的状态说明：
CANCELLED = 1 , 在同步队列中等待的线程等待超时或者被中断，需要从队列当中取消，会将waitStatus的状态置为1，
SIGNAL = -1, 表示其后继节点处于等待状态中，如果当前节点的线程释放了同步状态或者是被取消，会通知后继节点
CONDITION = -2, 线程处于等待condition状态，当其他线程调用signal() 方法，该线程从等待队列当中移动到同步队列中，进行对锁的获取
PROPAGATE = -3, 表示下一次共享式同步状态获取将会无条件被传播下去
nextWaiter: 等待队列中的后继节点，如果当前节点是共享的，nextWaiter是 SHARED常量，也就是说节点类型和等待队列中的后继节点共用同一个字段
基于以上基础架构，来分析ReentrantLocak非公平锁的实现
Lock lock = new ReentrantLock();
lock.lock();
public void lock() { sync.lock(); } 调用NonfairSync代码实现
final void lock() { if (compareAndSetState(0, 1)) setExclusiveOwnerThread(Thread.currentThread()); else acquire(1); } sync继承自AbstractQueuedSynchronizer类，简称AQS, 其内部维护了一个int 类型的state变量，以及当前获取到锁的线程对象thread,
非公平锁，不管当前是否有线程队列在等待获取锁，都直接尝试去获取，成功直接设置AQS当中持有线程为当前线程，否则执行acquire(1)
以上第一步是1、将AQS当中的state状态更改为1，假设现在有三个线程来访问，其中thread1成功将state状态改为1，另外两个线程thread2 和thread3 将执行acquire(1), 以下是AQS当中acquire方法的实现：
public final void acquire(int arg) { if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) selfInterrupt(); } 1、先尝试去tryAcquire ，由上面的步骤可知，如果线程1 现在仍然持有锁，并且没有释放，tryAcquire返回的false
2、接下来将线程2和线程3添加到AQS双向链表当中的队尾
tryAcquire的方法实现：
final boolean nonfairTryAcquire(int acquires) { final Thread current = Thread.currentThread(); int c = getState(); if (c == 0) { if (compareAndSetState(0, acquires)) { setExclusiveOwnerThread(current); return true; } } else if (current == getExclusiveOwnerThread()) { int nextc = c + acquires; if (nextc < 0) // overflow throw new Error("Maximum lock count exceeded"); setState(nextc); return true; } return false; } 再次判断thread1是否将锁释放掉了，如果state的值是0，并且线程2成功将状态修改成1，说明线程2获取到锁，返回true
如果当前线程和AQS当中持有的线程是同一个线程，那么就在原来state的基础上添加acquires,并且返回true
否则返回false说明尝试获取锁失败
接下来我们来看下如果获取锁失败后，是如何操作的，addWaiter方法
private Node addWaiter(Node mode) { Node node = new Node(Thread.currentThread(), mode); // Try the fast path of enq; backup to full enq on failure Node pred = tail; if (pred != null) { node.prev = pred; if (compareAndSetTail(pred, node)) { pred.next = node; return node; } } enq(node); return node; } 获取到AQS当中node的尾部元素，如果tail是null 的话，执行enq方法
private Node enq(final Node node) { for (;;) { Node t = tail; if (t == null) { // Must initialize if (compareAndSetHead(new Node())) tail = head; } else { node.prev = t; if (compareAndSetTail(t, node)) { t.next = node; return t; } } } } 结合我们上面的场景，线程2和线程3 都没有获取到锁，那么此时tail元素是null , 在这个enq方法当中先创建一个head节点，不包含thread的，然后将thread2添加至node链表的尾部返回
接下来处理队列中的元素
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)) { setHead(node); p.next = null; // help GC failed = false; return interrupted; } if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt()) interrupted = true; } } finally { if (failed) cancelAcquire(node); } } 1、先找到当前元素的前一个元素，如果当前元素的前一个元素是head，并且tryAcquire成功了，说明当前链表的前一个元素head可以失效了
2、如果当前元素的前一个元素不是head，或者说当前线程尝试获取锁也失败了，那么执行shouldParkAfterFaildAcquire
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) { int ws = pred.waitStatus; if (ws == Node.SIGNAL) /* * This node has already set status asking a release * to signal it, so it can safely park. */ return true; if (ws > 0) { /* * Predecessor was cancelled. Skip over predecessors and * indicate retry. */ do { node.prev = pred = pred.prev; } while (pred.waitStatus > 0); pred.next = node; } else { /* * waitStatus must be 0 or PROPAGATE. Indicate that we * need a signal, but don't park yet. Caller will need to * retry to make sure it cannot acquire before parking. */ compareAndSetWaitStatus(pred, ws, Node.SIGNAL); } return false; } 1、如果前一个节点的waitState 是-1，直接返回，然后就是执行&&后面的操作，将当前线程挂起
private final boolean parkAndCheckInterrupt() { LockSupport.park(this); return Thread.interrupted(); } 2、如果前一个节点的waitState 大于0，即状态是cancelled ==1 从链表尾部开始查找，找到状态小于等于0 ，并且返回false
3、如果当前状态小于0，且不是signal状态，将pred节点的状态更新为signal
以上就是非共享模式下的AQS实现，整理下执行流程：
1、线程A和线程B同时去获取锁，如果线程A获取成功，会将AQS当中的state改为1，并且将AQS当中的线程指定为当前线程
2、线程B尝试去获取锁失败，这时候会去生成新的node节点（这个节点所有参数都不设置，不包含thread）作为head节点,然后将线程B放在head节点的后面作为tail
3、在放入对列之后，先进行自旋，判断前面的节点是否是head节点，以及当前线程再次尝试获取锁，如果这时候线程A已经执行结束，并且释放掉锁，线程B这时候就不需要进行挂起，直接去执行
4、如果线程B这时候没有获取到锁，判断它前一个节点的状态，如果前一个节点状态是SIGNAL, 将线程B通过LockSupport方式挂起，如果前一个节点状态是CANCELLED状态，那么就会从尾部开始查找，直到waitState小于0，然后将节点waitState改为是SIGNAL状态。
公平锁和非公平锁的区别在于：
在执行lock操作时，公平锁会先去判断阻塞队列当中有没有线程，如果有，将该线程放入到队尾，而非公平锁的操作是，某个线程尝试去获取锁的时候，先执行CAS看是否可以将状态为从0改为1，也就是说，非公平锁拿到锁的这个线程是随机的
公平锁：
protected final boolean tryAcquire(int acquires) { final Thread current = Thread.currentThread(); int c = getState(); if (c == 0) { if (!hasQueuedPredecessors() && 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; } 非公平锁：
final boolean nonfairTryAcquire(int acquires) { final Thread current = Thread.currentThread(); int c = getState(); if (c == 0) { if (compareAndSetState(0, acquires)) { setExclusiveOwnerThread(current); return true; } } else if (current == getExclusiveOwnerThread()) { int nextc = c + acquires; if (nextc < 0) // overflow throw new Error("Maximum lock count exceeded"); setState(nextc); return true; } return false;} 关于释放锁的操作：
公平锁和非公平锁对于释放锁的操作是一致的
public final boolean release(int arg) { if (tryRelease(arg)) { Node h = head; if (h != null && h.waitStatus != 0) unparkSuccessor(h); return true; } return false; }
protected final boolean tryRelease(int releases) { int c = getState() - releases; if (Thread.currentThread() != getExclusiveOwnerThread()) throw new IllegalMonitorStateException(); boolean free = false; if (c == 0) { free = true; setExclusiveOwnerThread(null); } setState(c); return free; } 1、如果当前线程和持有线程不是同一个线程直接抛出异常，
2、如果释放过后state=0,说明没有任何线程持有锁，会将之前持有的线程置空，返回true
3、尝试释放成功之后，并且head的状态不为0，说明未释放，接下来会unparkSuccess
private void unparkSuccessor(Node node) { int ws = node.waitStatus; if (ws < 0) compareAndSetWaitStatus(node, ws, 0); Node s = node.next; 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; } if (s != null) LockSupport.unpark(s.thread); } 4、获取到当前head的waitState, 如果小于0，将其通过CAS更新为0
5、找到当前链表当中waitState值小于0的，已经取消的不考虑，最后将waitState小于0的线程，并且唤醒它。
参考：
《java并发编程的艺术》-方腾飞