送大家以下 java 学习材料，文末有支付形式
前言
ReentrantLock 和 synchronized 一样都是实现线程同步，然而像比 synchronized 它更加灵便、弱小、减少了轮询、超时、中断等高级性能，能够更加精细化的控制线程同步，它是基于 AQS 实现的锁，他反对偏心锁和非偏心锁，同时他也是可重入锁和自旋锁。
本章将基于源码来摸索一下 ReentrantLock 的加锁机制，文中如果存在了解不到位的中央，还请提出宝贵意见独特探讨，不吝赐教。
偏心锁和非偏心锁的加锁机制流程图：
一、ReentrantLock 的偏心锁
应用 ReentrantLock 的偏心锁，调用 lock 进行加锁，lock 办法的源码如下：
`final void lock() {`
`acquire(1);`
`}`
`public final void acquire(int arg) {`
`if (!tryAcquire(arg) &&`
`acquireQueued(addWaiter(Node.EXCLUSIVE), arg))`
`selfInterrupt();`
`}`
能够看到，FairLock 首先调用了 tryAcquire,tryAcquire 源码如下：
`/**`
`* Fair version of tryAcquire. Don't grant access unless`
`* recursive call or no waiters or is first.`
`*/`
`protected final boolean tryAcquire(int acquires) {`
`final Thread current = Thread.currentThread();`
`int c = getState();`
`if (c == 0) {`
`// 如果队列中不存在期待的线程或者以后线程在队列头部，则基于 CAS 进行加锁 `
`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;`
`}`
从源码中能够看到，当 state 为 0，即没有线程获取到锁时，FairLock 首先会调用 hasQueuedPredecessors() 办法查看队列中是否有期待的线程或者本人是否在队列头部，如果队列中不存在期待的线程或者本人在队列头部则调用 compareAndSetState() 办法基于 CAS 操作进行加锁，如果 CAS 操作胜利，则调用 setExclusiveOwnerThread 设置加锁线程为以后线程。
当 state 不为 0，即有线程占用锁的时候会判断占有锁的线程是否是以后线程，如果是的话则能够间接获取到锁，这就是 ReentrantLock 是可重入锁的体现。
如果通过调用 tryAcquire 没有获取到锁，从源码中咱们能够看到，FairLock 会调用 addWaiter() 办法将以后线程退出 CLH 队列中，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;`
`// 基于 CAS 将以后线程节点退出队列尾部 `
`if (compareAndSetTail(pred, node)) {`
`pred.next = node;`
`return node;`
`}`
`}`
`// 如果 CAS 操作失败，则调用 enq 自旋退出队列 `
`enq(node);`
`return node;`
`}`
`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;`
`}`
`}`
`}`
`}`
在 addWaiter 办法中，会 CAS 操作将以后线程节点退出队列尾部，如果第一次 CAS 失败，则会调用 enq 办法通过自旋的形式，屡次尝试进行 CAS 操作将以后线程退出队列。
将以后线程退出队列之后，会调用 acquireQueued 办法实现 [以后线程] 的自旋加锁，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)) {`
`setHead(node);`
`p.next = null; // help GC`
`failed = false;`
`return interrupted;`
`}`
`if (shouldParkAfterFailedAcquire(p, node) &&`
`parkAndCheckInterrupt())`
`interrupted = true;`
`}`
`} finally {`
`if (failed)`
`cancelAcquire(node);`
`}`
`}`
在 acquireQueued 办法中每次自旋首先会调用 predecessor() 办法获取，以后线程节点的前节点，如果发现前节点是 head 节点，则阐明以后线程节点处于对头（head 是傀儡节点），那么则调用 tryAcquire 尽心加锁。
如果以后线程节点不在队列头部，那么则会调用 shouldParkAfterFailedAcquire 办法判断以后线程节点是否能够挂起晓得前节点开释锁时唤醒本人，如果能够挂起，则调用 parkAndCheckInterrupt 实现挂起操作。另外，关注后端架构师公众号，回复“面试”，送你一份面试题宝典！
shouldParkAfterFailedAcquire源码如下：
`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;`
`}`
shouldParkAfterFailedAcquire源码中，如果以后线程节点的前节点的 waitStatus 状态为 SIGNAL（-1） 时，表明前节点曾经设置了开释锁时唤醒（unpark）它的后节点，那么以后线程节点能够安心阻塞（park），期待它的前节点在 unlock 时唤醒本人持续尝试加锁。
如果前节点的 waitStatus 状态 >0, 即为CANCELLED (1)，表明前节点曾经放弃了获取锁，那么则会持续往前找，找到一个可能在 unlock 时唤醒本人的线程节点为止。如果前节点 waitStatus 状态是CONDITION（-2），即处于期待条件的状态，则会基于 CAS 尝试设置前节点状态为 SIGNAL（被动干涉前节点达到唤醒本人的目标）。
parkAndCheckInterrupt源码：
`private final boolean parkAndCheckInterrupt() {`
`LockSupport.park(this);`
`return Thread.interrupted();`
`}`
二、ReentrantLock 的非偏心锁
和偏心锁加锁机制不同的是，非偏心锁一上来不论队列中是否还存在线程，就间接应用 CAS 操作进行尝试加锁（这就是它的非偏心的体现），源码如下：
`final void lock() {`
`if (compareAndSetState(0, 1))`
`setExclusiveOwnerThread(Thread.currentThread());`
`else`
`acquire(1);`
`}`
`public final void acquire(int arg) {`
`if (!tryAcquire(arg) &&`
`acquireQueued(addWaiter(Node.EXCLUSIVE), arg))`
`selfInterrupt();`
`}`
如果 CAS 操作失败（一上来就吃了个闭门羹），则调用 acquire 办法进行后续的尝试和期待。从源码中能够看到，首先回调用 tryAcquire 办法进行再次尝试加锁或者锁重入，NoFairLockd 的 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;`
`}`
能够看到 NoFairLock 的 tryAcquire 办法和 FairLock 的 tryAcquire 办法惟一不同之处是 NoFairLock 中尝试加锁前不须要调用 hasQueuedPredecessors 办法判断队列中是否存在其余线程，而是间接进行 CAS 操作加锁。
那么如果再次尝试加锁或者锁重入失败，则会进行后续的和偏心锁齐全一样的操作流程（不再赘述），即：退出队列（addWaiter）–> 自旋加锁(acquireQueued)。
三、unlock 解锁
说完了偏心锁和非偏心锁的加锁机制，咱们再顺带简略的看看解锁源码。unlock 源码如下：
`public void unlock() {`
`sync.release(1);`
`}`
`public final boolean release(int arg) {`
`// 尝试开释锁 `
`if (tryRelease(arg)) {`
`Node h = head;`
`// 锁开释成后唤醒后边阻塞的线程节点 `
`if (h != null && h.waitStatus != 0)`
`unparkSuccessor(h);`
`return true;`
`}`
`return false;`
`}`
总结 本文次要摸索了偏心锁和非偏心锁的加锁流程，他们获取锁的不同点和相同点。整篇文章波及到了以下几点：
- 偏心锁、非偏心锁加锁过程
- 自旋锁的实现以及自旋过程中的阻塞唤醒
- 可重入锁的实现
- CLH 队列
注：文中如果存在了解不到位的中央还请提出宝贵意见，不吝赐教。