1.ReentrantLock和AQS
ReentrantLock中使用了AbstractQueuedSynchronizer也就是AQS，完成了锁的获取和释放等。从ReentrantLock类中进入，我们看到它的默认构造方法：
public ReentrantLock() {
sync = new NonfairSync();
}
默认使用的是非公平锁，而它的lock方法中，使用的sync.lock()是非公平锁的实现。
public void lock() {
sync.lock();
}
2.获取锁
我们进入NonfairSync的lock方法中，查看内部实现如下：
final void lock() {
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
protected final boolean compareAndSetState(int expect, int update) {
// See below for intrinsics setup to support this
return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}
stateOffset = unsafe.objectFieldOffset
(AbstractQueuedSynchronizer.class.getDeclaredField("state"));
AQS中的锁是可重入的，即同一个线程可以多次获取锁
AQS中的锁也是独占的，即一个线程没有释放锁时，其他的线程不能获取锁
这里，对state的偏移量中的内存进行CAS操作，设置为1，表明第一次获取锁。AQS中，state是一个volatile变量，表示线程获取锁的次数，state为0，表示没有获取锁，state大于1，则表示重入锁获取的次数。执行完compareAndSetState第一次获取锁之后，执行setExclusiveOwnerThread，在AbstractOwnableSynchronizer类中设置成员变量Thread exclusiveOwnerThread为当前线程，表示这个线程独占了这个锁。
如果第二次调用lock()获取锁，由于内存中state不为0，cas失败，则进入else执行acquire(1);
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
该方法执行逻辑如下，如果tryAcquire为true，则直接返回，否则执行acquireQueued(addWaiter(Node.EXCLUSIVE), arg)，tryAcquire是一个抽象方法，NonfairSync中的实现如下：
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
final boolean nonfairTryAcquire(int acquires) {
// 获取当前线程
final Thread current = Thread.currentThread();
// 得到state数量
int c = getState();
// 没有获取过锁
if (c == 0) {
// 获取一次，cas设置state为acquires，也就是1
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");
// 设置state，这里不需要同步，因为已经是统一线程第二次获取锁，也是在本线程里获取锁，没有线程安全问题，第一次调用的state和ownerThread一定是可见的
setState(nextc);
return true;
}
return false;
}
3.队列中添加元素
acquires参数为每次获取锁的增量，传入1，每次递增1。其中的判断c==0的这段逻辑其实在NonfairSync的lock方法中又实现了一遍，个人认为重复了，lock方法中可以去掉这一块。解释完这段代码，回到acquire方法中，执行
acquireQueued(addWaiter(Node.EXCLUSIVE), arg)
private Node addWaiter(Node mode) {
// mode=Node.EXCLUSIVE，排他模式 Node = null
Node node = new Node(Thread.currentThread(), mode);
// Try the fast path of enq; backup to full enq on failure
// 获取AQS的尾节点
Node pred = tail;
// 尾节点不为null，在后方插入新的node，也就是null节点
if (pred != null) {
node.prev = pred;
// 设置AQS的tail为node节点
if (compareAndSetTail(pred, node)) {
// 连接上一个尾节点和node
pred.next = node;
// 返回新建的节点，封装了本线程
return node;
}
}
// 尾节点为null，则在队列中加入本节点
enq(node);
return node;
}
private Node enq(final Node node) {
for (;;) {
Node t = tail;
// 如果其他线程在之前往队列中添加了节点，则tail可能不为null，需要再次判断
if (t == null) { // Must initialize
// 尾节点为null则需要新建Node，cas设置头节点为node，head为冗余节点
if (compareAndSetHead(new Node()))
// 设置尾节点为head
tail = head;
} else {
// 在队列后面添加节点，完成双向链表添加节点
node.prev = t;
if (compareAndSetTail(t, node)) {
t.next = node;
return t;
}
}
}
}
Node(Thread thread, Node mode) { // Used by addWaiter
// Node = null
this.nextWaiter = mode;
// thread = Thread.currentThread();
this.thread = thread;
}
addWaiter方法中主要作用是在当前AQS维护的队列尾部，添加一个节点，如果队列为null，则需要创建一个冗余节点head，否则在队列尾部加入封装了新创建线程的Node，完成双向链表的节点添加。
4.acquireQueued
执行完该操作，返回新创建的Node节点，调用acquireQueued(addWaiter(Node.EXCLUSIVE), 1)方法，该方法细节如下：
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
boolean interrupted = false;
for (;;) {
// 获取node的前继节点
final Node p = node.predecessor();
// 是头节点的话，也就是node为第二个节点，尝试获取锁
if (p == head && tryAcquire(arg)) {
// 获取锁成功，则更新头节点为当前节点，消除冗余节点
setHead(node);
p.next = null; // help GC
failed = false;
return interrupted;
}
// node不是头节点或者获取锁失败，执行判断是否需要阻塞等待
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
本方法中，判断了当前节点的前一个节点是否是head节点，如果是的话，则node节点是第二个节点，可以获取锁，获取锁成功，则设置头节点为node，消除了原来初始化产生的冗余节点，并且返回中断状态为false。
5.shouldParkAfterFailedAcquire
否则进行判断是否需要阻塞等待，如果需要阻塞等待，则执行parkAndCheckInterrupt()。
/**
* 判断未获取到锁的节点是否需要阻塞等待
* @param pred 前一个节点
* @param node 当前节点
**/
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.
* 移除所有前继节点，直到pred.waitStatus不为>0
*/
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;
}
/** waitStatus value to indicate thread has cancelled */
static final int CANCELLED = 1;
/** waitStatus value to indicate successor's thread needs unparking */
static final int SIGNAL = -1;
/** waitStatus value to indicate thread is waiting on condition */
static final int CONDITION = -2;
/**
* waitStatus value to indicate the next acquireShared should
* unconditionally propagate
*/
static final int PROPAGATE = -3;
节点的状态再AQS中有四种，在AQS构造新节点时，使用的是默认值0，方法进入else中，设置pred节点的status为Node.SIGNAL。在AQS#acquireQueued()中，如果还是没有成功获取锁，则第二次进入本方法，则进入第一个if判断。上一轮循环中，已经将pred.waitStatus设置为`Node.SIGNAL = -1，表示应该阻塞。
ws > 0的情况是当pred所维护的获取请求被取消时，pred.waitStatus会被设置为CANCELLED = 1,此时，移除所有pred.waitStatus > 0的前继节点，并且直接返回false。这里不需要判断pred是否为null，因为队列中前面的节点可能是冗余节点，waitStatus = 0；或者是已经加入的节点，waitStatus = 0；或者是已经阻塞的节点，waitStatus = SIGNAL=-1，在遍历到头节点时，一定会跳出循环。
6.parkAndCheckInterrupt
回到AQS#acquireQueued()，判断前继节点是否为头节点，进行处理，并执行parkAndCheckInterrupt()。
private final boolean parkAndCheckInterrupt() {
LockSupport.park(this);
return Thread.interrupted();
}
该方法中使用LockSupport的park方法阻塞线程，进入等待状态。并使用Thread.interrupted()判断当前线程是否被中断，并清除中断标记。
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
如果该线程被中断，则标记中断标记为true；
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
回到acquire中，如果acquireQueued也返回true则会执行selfInterrupt。
static void selfInterrupt() {
Thread.currentThread().interrupt();
}
设置当前线程中断状态。
最后的队列状态如下：
(1) 除了头节点非阻塞，其余节点全部为阻塞状态
(2) 除了尾节点，其余节点都满足waitStatus==SIGNAL，表示释放后需要唤醒后继节点
7.释放锁
public final boolean release(int arg) {
if (tryRelease(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
释放锁的代码如上，先调用tryRelease()尝试释放锁。成功则获取头节点，如果头节点不为空并且状态不为0，则调用unparkSuccessor(h)。
private void unparkSuccessor(Node node) {
/*
* If status is negative (i.e., possibly needing signal) try
* to clear in anticipation of signalling. It is OK if this
* fails or if status is changed by waiting thread.
* status为负，则把预期的SIGNAL状态设置为0
*/
int ws = node.waitStatus;
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
/*
* Thread to unpark is held in successor, which is normally
* just the next node. But if cancelled or apparently null,
* traverse backwards from tail to find the actual
* non-cancelled successor.
* 当前node是释放锁的node，则在队列中后面的节点，一般是需要解除阻塞的节点
* 但是这些节点也可能是CANCELED状态或者为空，
* 所以需要从尾部开始遍历，找到距离node节点最近，并且waitStatus<= 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);
}
8.为什么要从尾部遍历？
为什么不能从尾节点向前遍历？如上注释中可以看出，队列中的节点会出现CANCELLED状态或者null状态
(1) null状态的产生
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;
}
}
}
}
在enq时，如果走到下面的else中，cas操作可能失败，这时，t.next = node这句代码不会被执行，旧的尾节点没有指向新的节点。
队列变成如下状态：
在上图中，可能需要释放的节点为node2，如果向后遍历，该节点的next为null，将找不到节点，但是实际tail节点是可以唤醒的。
(2) CANCELED状态
中间节点可能被状态改变成了CENCELED
node1的状态为CANCELED，这种状态从tail往前遍历也是能够找到最近的state<=0，并且不为node本身，这样的节点的。
根据上述(1),(2)两种状态，需要从后开始遍历。这步操作主要还是为了高效地找到node节点后面，离node节点最近的可以唤醒的节点。
9.整体调试
使用如下代码进行debug：
public class AQS {
private static Lock lock = new ReentrantLock();
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
new Thread(new ReentrantLockTask(), "thread" + i).start();
}
}
public static class ReentrantLockTask implements Runnable{
@Override
public void run() {
System.out.println("Thread " + Thread.currentThread().getName() + " started. ");
try {
lock.lock();
System.out.println("Thread " + Thread.currentThread().getName() + "get lock.------");
} finally {
lock.unlock();
}
}
}
}
总的来说，流程如下：
假设thread0首先获得锁
1.thread0获取锁，执行任务中
2.thread1调用NonfairSync#lock()尝试compareAndSetState（0，1）失败，调用NonfairSync#acquire(1)
3.tryAcquire(1)失败，调用acquireQueued(addWaiter(Node.EXCLUSIVE), 1)，先调用addWaiter(Node.EXCLUSIVE)，将添加Node封装本线程，到AQS的队列中
4.执行acquireQueued(node, 1),轮询判断前一个节点是否头节点，尝试获取锁
成功：设置头节点为当前节点
失败：shouldParkAfterFailedAcquire(p, node)判断是否需要阻塞线程，内部通过状态判断，waitStatus为-1返回true，执行parkAndCheckInterrupt()，阻塞当前线程LockSupport.park(this)。
代码wait在wait标记注释。
private final boolean parkAndCheckInterrupt() {
LockSupport.park(this);
// wait处
return Thread.interrupted();
}
5.thread1执行完成，则执行unlock()，tryRelease(1)释放锁成功，获取队列头节点h，调用unparkSuccessor(h)设置状态为0默认状态。调用LockSupport.unpark(s.thread)解除队列头部状态为可以唤醒的线程的阻塞。
6.阻塞的线程从wait的代码行往下执行，判断Thread.interrupted()是否为true，回到acquireQueued，继续获取锁。设置头节点为本节点，依次执行下面代码，完成同步和锁的获取。
最后，附上我参考过的大佬文章，写的比较深入：
https://monkeysayhi.github.io/2017/12/05/%E6%BA%90%E7%A0%81%7C%E5%B9%B6%E5%8F%91%E4%B8%80%E6%9E%9D%E8%8A%B1%E4%B9%8BReentrantLock%E4%B8%8EAQS%EF%BC%881%EF%BC%89%EF%BC%9Alock%E3%80%81unlock/