共计 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;`
`}`
总结 本文次要摸索了偏心锁和非偏心锁的加锁流程,他们获取锁的不同点和相同点。整篇文章波及到了以下几点:
- 偏心锁、非偏心锁加锁过程
- 自旋锁的实现以及自旋过程中的阻塞唤醒
- 可重入锁的实现
- CLH 队列
注:文中如果存在了解不到位的中央还请提出宝贵意见,不吝赐教。