送大家以下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;``}`

总结 本文次要摸索了偏心锁和非偏心锁的加锁流程，他们获取锁的不同点和相同点。整篇文章波及到了以下几点：

  1. 偏心锁、非偏心锁加锁过程
  2. 自旋锁的实现以及自旋过程中的阻塞唤醒
  3. 可重入锁的实现
  4. CLH队列

注：文中如果存在了解不到位的中央还请提出宝贵意见，不吝赐教。