关于java:深入了解ReentrantLock中的公平锁和非公平锁的加锁机制

29次阅读

共计 5653 个字符,预计需要花费 15 分钟才能阅读完成。

送大家以下 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 队列

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

正文完
 0