Java并发篇--ReentrantLock原理

ReentrantLock原理

在这里插入图片描述

非公平锁实现原理

加锁解锁流程

先从构造器开始看,默认为非公平锁

public ReentrantLock() {sync = new NonfairSync();
}

NonfairSync 继承自 AQS

没有竞争时

在这里插入图片描述

第一个竞争出现时

在这里插入图片描述

Thread-1执行了

1.CAS尝试将state由0改为1,结果失败

2.进入tryAcquire逻辑,这时state已经是1,结果仍然失败

3.接下来进入addWaiter逻辑,构造Node队列

· 图中黄色三角表示该Node的waitStatus状态,其中0为默认正常状态

· Node的创建是懒惰的

· 其中第一个Node称为Dummy(哑元)或哨兵,用来占位,并不关联线程

在这里插入图片描述

当前线程进入acquireQueued逻辑

1.acquireQueued 会在一个死循环中布顿啊尝试获得锁,失败后进入park阻塞

2.如果自己是紧邻这head(排第二位),那么再次tryAcquire尝试获取锁,当然这时state仍为1,失败

3.进入shouldParkAfterFailedAcquire逻辑,将前驱node,即head的waitStatus改为-1,这次返回false

在这里插入图片描述

4.shouldParkAfterFailedAcquire执行完毕回到acquireQueued,再次tryAcquire尝试获取锁,当然这时state仍为1,失败

5.当再次进入shouldParkAfterFailedAcquire时,这时因为前驱node的waitStatus已经是-1,这次返回true

6.进入parkAndCheckInterrupt,Thread-1 park(灰色表示)

在这里插入图片描述

再次有多个线程经历上述过程竞争失败,变成这个样子

在这里插入图片描述

Thread-0释放锁,进入tryRelease流程,如果成功

· 设置 exclusiveOwnerThread为null

· state = 0

在这里插入图片描述

当前队列不为null,并且head的waitStatus=-1,进入unparkSuccessor流程

找到队列中离head最近的一个Node(没取消的),unpark恢复其运行,本例中即为Thread-1

回到Thread-1 的 acquireQueued流程

在这里插入图片描述

如果加锁成功(没有竞争),会设置

· exclusiveOwnerThread为Thread-1,state=1

· head指向刚刚Thread-1所在的Node,该Node清空Thread

· 原本head因为从链表断开,而可以被垃圾回收

如果这时侯有其它线程来竞争(非公平的体现),例如这时有Thread-4来了

在这里插入图片描述

如果不巧又被Thread-4占了先

· Thread-4被设置为exclusiveOwnerThread,state=1

· Thread-1再次进行acquireQueued流程,获取锁失败,重新进入park阻塞

可重入原理

static final class NonfairSync extends Sync {// ...// Sync 继承过来的方法, 方便阅读, 放在此处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()) {// state++int nextc = c + acquires;if (nextc < 0) // overflowthrow new Error("Maximum lock count exceeded");setState(nextc);return true;}return false;}// Sync 继承过来的方法, 方便阅读, 放在此处protected final boolean tryRelease(int releases) {// state-- int c = getState() - releases;if (Thread.currentThread() != getExclusiveOwnerThread())throw new IllegalMonitorStateException();boolean free = false;// 支持锁重入, 只有 state 减为 0, 才释放成功if (c == 0) {free = true;setExclusiveOwnerThread(null);}setState(c);return free;}
}

可打断原理

不可打断模式(默认)

在此模式下,即使它被打断,仍会驻留在AQS队列中,等获得锁后方能继续运行(是继续运行!只是打断标记被设置为true)

// Sync 继承自 AQS
static final class NonfairSync extends Sync {// ...private final boolean parkAndCheckInterrupt() {// 如果打断标记已经是 true, 则 park 会失效LockSupport.park(this);// interrupted 会清除打断标记return Thread.interrupted();}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;failed = false;// 还是需要获得锁后, 才能返回打断状态return interrupted;}if (shouldParkAfterFailedAcquire(p, node) &&parkAndCheckInterrupt()) {// 如果是因为 interrupt 被唤醒, 返回打断状态为 trueinterrupted = true;}}} finally {if (failed)cancelAcquire(node);}}public final void acquire(int arg) {if (!tryAcquire(arg) &&acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) {// 如果打断状态为 trueselfInterrupt();}}static void selfInterrupt() {// 重新产生一次中断Thread.currentThread().interrupt();}
}

可打断模式

static final class NonfairSync extends Sync {public final void acquireInterruptibly(int arg) throws InterruptedException {if (Thread.interrupted())throw new InterruptedException();// 如果没有获得到锁, 进入 ㈠if (!tryAcquire(arg))doAcquireInterruptibly(arg);}// ㈠ 可打断的获取锁流程private void doAcquireInterruptibly(int arg) throws InterruptedException {final Node node = addWaiter(Node.EXCLUSIVE);boolean failed = true;try {for (;;) {final Node p = node.predecessor();if (p == head && tryAcquire(arg)) {setHead(node);p.next = null; // help GCfailed = false;return;}if (shouldParkAfterFailedAcquire(p, node) &&parkAndCheckInterrupt()) {// 在 park 过程中如果被 interrupt 会进入此// 这时候抛出异常, 而不会再次进入 for (;;)throw new InterruptedException();}}} finally {if (failed)cancelAcquire(node);}}
}

公平锁实现原理

static final class FairSync extends Sync {private static final long serialVersionUID = -3000897897090466540L;final void lock() {acquire(1);}// AQS 继承过来的方法, 方便阅读, 放在此处public final void acquire(int arg) {if (!tryAcquire(arg) &&acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) {selfInterrupt();}}// 与非公平锁主要区别在于 tryAcquire 方法的实现protected final boolean tryAcquire(int acquires) {final Thread current = Thread.currentThread();int c = getState();if (c == 0) {// 先检查 AQS 队列中是否有前驱节点, 没有才去竞争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;}// ㈠ AQS 继承过来的方法, 方便阅读, 放在此处public final boolean hasQueuedPredecessors() {Node t = tail;Node h = head;Node s;// h != t 时表示队列中有 Nodereturn h != t &&(// (s = h.next) == null 表示队列中还有没有老二(s = h.next) == null ||// 或者队列中老二线程不是此线程s.thread != Thread.currentThread());}
}