ReentrantLock的使用及底层实现原理
2023-12-06 本文已影响0人
我可能是个假开发
一、基本介绍
语法：
// 获取锁
reentrantLock.lock();
try {
// 临界区
} finally {
// 释放锁
reentrantLock.unlock();
}
特点：
- 可重入
- 可中断
- 可以设置超时时间
- 可以设置为公平锁
- 支持多个条件变量（类似Synchronized中的waitset，拿不到锁时进入的waitset中等待，可以支持多个waitset）
1.可重入
同一个线程如果首次获得了这把锁，那么因为它是这把锁的拥有者，因此有权利再次获取这把锁；如果是不可重入锁，那么第二次获得锁时，自己也会被锁挡住。
@Slf4j
public class ReentrantTest {
static ReentrantLock lock = new ReentrantLock();
public static void main(String[] args) {
method1();
}
public static void method1() {
lock.lock();
try {
log.debug("execute method1");
method2();
} finally {
lock.unlock();
}
}
public static void method2() {
lock.lock();
try {
log.debug("execute method2");
method3();
} finally {
lock.unlock();
}
}
public static void method3() {
lock.lock();
try {
log.debug("execute method3");
} finally {
lock.unlock();
}
}
}
20:22:29.392 [main] DEBUG juc.reentrant.ReentrantTest - execute method1
20:22:29.396 [main] DEBUG juc.reentrant.ReentrantTest - execute method2
20:22:29.396 [main] DEBUG juc.reentrant.ReentrantTest - execute method3
实现源码：
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) // overflow
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
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;
}
2.可打断
在等待锁的过程中，其他线程可以使用interrupt方法中止当前线程的等待。
可以防止死锁的发生，线程不用一直等下去。
@Slf4j
public class InterruptTest {
private static ReentrantLock reentrantLock = new ReentrantLock();
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(()->{
try {
//竞争锁失败进入阻塞队列，可以被其他线程调用interrupt方法打断
log.debug("t1线程开始抢锁");
reentrantLock.lockInterruptibly();
} catch (InterruptedException e) {
//抢锁失败进入了阻塞队列然后被打断了就进入这个catch块
e.printStackTrace();
log.debug("t1线程被打断，返回");
return;
}
try{
log.debug("t1线程抢锁成功");
}finally {
reentrantLock.unlock();
}
},"t1");
//主线程先抢锁
log.debug("main线程开始抢锁");
reentrantLock.lock();
log.debug("main线程抢锁成功");
//t1线程启动开始抢锁，抢锁失败
t1.start();
Thread.sleep(1000);
log.debug("main线程打断正在阻塞的t1线程");
t1.interrupt();
}
}
10:09:47.246 [main] DEBUG juc.reentrant.InterruptTest - main线程开始抢锁
10:09:47.248 [main] DEBUG juc.reentrant.InterruptTest - main线程抢锁成功
10:09:47.249 [t1] DEBUG juc.reentrant.InterruptTest - t1线程开始抢锁
10:09:48.250 [main] DEBUG juc.reentrant.InterruptTest - main线程打断正在阻塞的t1线程
10:09:48.251 [t1] DEBUG juc.reentrant.InterruptTest - t1线程被打断，返回
java.lang.InterruptedException
at java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireInterruptibly(AbstractQueuedSynchronizer.java:898)
at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireInterruptibly(AbstractQueuedSynchronizer.java:1222)
at java.util.concurrent.locks.ReentrantLock.lockInterruptibly(ReentrantLock.java:335)
at juc.reentrant.InterruptTest.lambda$main$0(InterruptTest.java:25)
at java.lang.Thread.run(Thread.java:748)
进入synchronized临界区的代码可以被打断，lockInterruptibly是获取锁失败被阻塞的过程可以被打断。
不可打断模式:
在此模式下，即使它被打断，仍会驻留在 AQS 队列中，一直要等到获得锁后方能得知自己被打断了
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; // help GC
failed = false;
// 需要获得锁后, 才能返回打断状态
return interrupted;
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
// 如果是因为 interrupt 被唤醒, 返回打断状态为 true
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
// 如果打断状态为 true
selfInterrupt();
}
static void selfInterrupt() {
// 重新产生一次中断
Thread.currentThread().interrupt();
}
可打断模式:
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 GC
failed = false;
return;
}
// 在 park 过程中如果被 interrupt 会进入此，这时候抛出异常, 不会再次进入 for (;;)
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
throw new InterruptedException();
}
} finally {
if (failed)
cancelAcquire(node);
}
}
3.设置超时时间
@Slf4j
public class TimeoutTest {
public static void main(String[] args) {
test1();
}
private static void test1() {
ReentrantLock lock = new ReentrantLock();
Thread t1 = new Thread(() -> {
log.debug("t1线程启动...");
try {
//获取不到会等待timeout时间，如果再抢不到就返回
if (!lock.tryLock(1, TimeUnit.SECONDS)) {
log.debug("尝试获取锁，等待 1s 后，失败，返回");
return;
}
} catch (InterruptedException e) {
log.debug("t1线程被打断，获取锁失败"，e);
return;
}
try {
log.debug("t1抢锁成功");
} finally {
lock.unlock();
}
}, "t1");
lock.lock();
log.debug("main抢锁成功");
t1.start();
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
private static void test2() {
ReentrantLock lock = new ReentrantLock();
Thread t1 = new Thread(() -> {
log.debug("t1线程启动...");
//获取不到不会等待
if (!lock.tryLock()) {
log.debug("t1线程抢锁失败，返回");
return;
}
try {
log.debug("获得了锁");
} finally {
lock.unlock();
}
}, "t1");
lock.lock();
log.debug("main线程抢锁成功");
t1.start();
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
使用锁超时解决哲学家就餐问题
public class DealPhilosopherMeal {
public static void main(String[] args) {
Chopstick c1 = new Chopstick("1");
Chopstick c2 = new Chopstick("2");
Chopstick c3 = new Chopstick("3");
Chopstick c4 = new Chopstick("4");
Chopstick c5 = new Chopstick("5");
new Philosopher("苏格拉底", c1, c2).start();
new Philosopher("柏拉图", c2, c3).start();
new Philosopher("亚里士多德", c3, c4).start();
new Philosopher("赫拉克利特", c4, c5).start();
new Philosopher("阿基米德", c5, c1).start();
}
}
/**
* 哲学家类
*/
@Slf4j
class Philosopher extends Thread {
Chopstick left;
Chopstick right;
public Philosopher(String name, Chopstick left, Chopstick right) {
super(name);
this.left = left;
this.right = right;
}
@Override
public void run() {
while (true) {
// 尝试获得左手筷子
if(left.tryLock()){
try {
// 尝试获得右手筷子
if (right.tryLock()) {
try{
eat();
}finally {
right.unlock();
}
}
}finally {
left.unlock();
}
}
// // 尝试获得左手筷子
// synchronized (left) {
// // 尝试获得右手筷子
// synchronized (right) {
// eat();
// }
// }
}
}
Random random = new Random();
private void eat(){
log.debug("eating...");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
/**
* 筷子类
*/
class Chopstick extends ReentrantLock {
String name;
public Chopstick(String name) {
this.name = name;
}
@Override
public String toString() {
return "筷子{" + name + '}';
}
}
11:21:48.096 [柏拉图] DEBUG juc.reentrant.Philosopher - eating...
11:21:48.097 [赫拉克利特] DEBUG juc.reentrant.Philosopher - eating...
11:21:49.104 [亚里士多德] DEBUG juc.reentrant.Philosopher - eating...
11:21:49.104 [阿基米德] DEBUG juc.reentrant.Philosopher - eating...
11:21:50.106 [柏拉图] DEBUG juc.reentrant.Philosopher - eating...
11:21:50.106 [赫拉克利特] DEBUG juc.reentrant.Philosopher - eating...
11:21:51.107 [苏格拉底] DEBUG juc.reentrant.Philosopher - eating...
11:21:51.107 [赫拉克利特] DEBUG juc.reentrant.Philosopher - eating...
11:21:52.110 [苏格拉底] DEBUG juc.reentrant.Philosopher - eating...
···
4.设置为公平锁
public ReentrantLock() {
sync = new NonfairSync();
}
/**
* Creates an instance of {@code ReentrantLock} with the
* given fairness policy.
*
* @param fair {@code true} if this lock should use a fair ordering policy
*/
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
默认为非公平锁，通过传递一个布尔参数来实现公平。
- 好处：可以解决饥饿问题
- 坏处：降低了并发度
实现原理：
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;
}
// （一）
public final boolean hasQueuedPredecessors() {
// The correctness of this depends on head being initialized
// before tail and on head.next being accurate if the current
// thread is first in queue.
Node t = tail; // Read fields in reverse initialization order
Node h = head;
Node s;
// h != t 时表示队列中有 Node
return h != t &&
// (s = h.next) == null 表示队列中还有没有老二或者队列中老二线程不是此线程
((s = h.next) == null || s.thread != Thread.currentThread());
}
5.支持多个条件变量
synchronized 中的条件变量，就是waitSet ，当条件不满足时进入 waitSet 等待，状态为waiting。
ReentrantLock 的条件变量比 synchronized 强大之处在于，它是支持多个条件变量，synchronized 是那些不满足条件的线程都在一个集合等消息，而 ReentrantLock 支持多个集合，唤醒时也是按集合来唤醒。
每个条件变量对应着一个等待队列，其实现类是 ConditionObject
使用要点：
- await 前需要获得锁
- await 执行后，会释放锁，进入 conditionObject 等待
- await 的线程被唤醒（或打断、或超时）去重新竞争 lock 锁
- 竞争 lock 锁成功后，从 await 后继续执行
基本使用：
public class TestAwait {
static ReentrantLock reentrantLock = new ReentrantLock();
public static void main(String[] args) throws InterruptedException {
Condition condition1 = reentrantLock.newCondition();
Condition condition2 = reentrantLock.newCondition();
reentrantLock.lock();
//进入条件变量中等待
condition1.await();
condition1.signalAll();
}
}
@Slf4j
public class TestAwaitSignal {
static boolean hasEat = false;
static boolean hasDrink = false;
static ReentrantLock room = new ReentrantLock();
//等喝的waitSet
static Condition drinkWaitSet = room.newCondition();
//等吃的waitSet
static Condition eatWaitSet = room.newCondition();
public static void main(String[] args) throws InterruptedException {
new Thread(() -> {
room.lock();
try {
log.debug("有吃的没？[{}]", hasEat);
while (!hasEat) {
log.debug("没吃的，先歇会！");
try {
eatWaitSet.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
if (hasEat) {
log.debug("有吃的，可以开始干活了");
} else {
log.debug("没干成活...");
}
}finally {
room.unlock();
}
}, "小红").start();
new Thread(() -> {
room.lock();
try {
log.debug("有喝的没？[{}]", hasDrink);
while (!hasDrink) {
log.debug("没喝的，先歇会！");
try {
drinkWaitSet.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
if (hasDrink) {
log.debug("有喝的，可以开始干活了");
} else {
log.debug("没干成活...");
}
}finally {
room.unlock();
}
}, "小明").start();
Thread.sleep(1000);
new Thread(() -> {
room.lock();
try {
hasDrink = true;
log.debug("喝的送到");
drinkWaitSet.signal();
} finally {
room.unlock();
}
}, "送喝的").start();
new Thread(() -> {
room.lock();
try {
hasEat = true;
log.debug("吃的送到");
eatWaitSet.signal();
} finally {
room.unlock();
}
}, "送吃的").start();
}
}
14:53:18.641 [小红] DEBUG juc.reentrant.TestAwaitSignal - 有吃的没？[false]
14:53:18.644 [小红] DEBUG juc.reentrant.TestAwaitSignal - 没吃的，先歇会！
14:53:18.644 [小明] DEBUG juc.reentrant.TestAwaitSignal - 有喝的没？[false]
14:53:18.644 [小明] DEBUG juc.reentrant.TestAwaitSignal - 没喝的，先歇会！
14:53:19.645 [送喝的] DEBUG juc.reentrant.TestAwaitSignal - 喝的送到
14:53:19.645 [小明] DEBUG juc.reentrant.TestAwaitSignal - 有喝的，可以开始干活了
14:53:19.646 [送吃的] DEBUG juc.reentrant.TestAwaitSignal - 吃的送到
14:53:19.646 [小红] DEBUG juc.reentrant.TestAwaitSignal - 有吃的，可以开始干活了
await流程
1.开始 Thread-0 持有锁，调用 await，进入 ConditionObject 的addConditionWaiter 流程，创建新的 Node 状态为 -2（Node.CONDITION），关联 Thread-0，加入等待队列尾部
1.png
2.进入 AQS 的 fullyRelease 流程，释放同步器上的锁
2.png
3.unpark AQS 队列中的下一个节点，竞争锁，假设没有其他竞争线程，那么 Thread-1 竞争成功
3.png
4.park 阻塞 Thread-0
4.png
signal 流程
1.Thread-1 要来唤醒 Thread-0
image.png
2.进入 ConditionObject 的 doSignal 流程，取得等待队列中第一个 Node，即Thread-0 所在 Node
image.png
3.执行 transferForSignal 流程，将该 Node 加入 AQS 队列尾部，将 Thread-0 的waitStatus 改为 0，Thread-3 的waitStatus 改为 -1
image.png
4.Thread-1 释放锁，进入 unlock 流程
二、固定顺序运行
让t2线程先执行：
1.使用wait/notify
@Slf4j
public class OrderRunTest {
static final Object lock = new Object();
// 表示 t2 是否运行过
static boolean t2RunFlag = false;
public static void main(String[] args) {
Thread t1 = new Thread(() -> {
synchronized (lock) {
while (!t2RunFlag) {
try {
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
log.debug("t1执行");
}
}, "t1");
Thread t2 = new Thread(() -> {
synchronized (lock) {
log.debug("t2执行");
t2RunFlag = true;
lock.notify();
}
}, "t2");
t1.start();
t2.start();
}
}
15:26:05.771 [t2] DEBUG juc.reentrant.OrderRunTest - t2执行
15:26:05.775 [t1] DEBUG juc.reentrant.OrderRunTest - t1执行
2.使用await/signal
@Slf4j
public class OrderRunTest2 {
static ReentrantLock reentrantLock = new ReentrantLock();
static Condition waitSet = reentrantLock.newCondition();
// 表示 t2 是否运行过
static boolean t2RunFlag = false;
public static void main(String[] args) {
Thread t1 = new Thread(() -> {
reentrantLock.lock();
try {
while (!t2RunFlag) {
try {
waitSet.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
log.debug("t1执行");
}finally {
reentrantLock.unlock();
}
}, "t1");
Thread t2 = new Thread(() -> {
reentrantLock.lock();
try {
log.debug("t2执行");
t2RunFlag = true;
waitSet.signal();
}finally {
reentrantLock.unlock();
}
}, "t2");
t1.start();
t2.start();
}
}
3.使用park/unpark
public class Test {
public static void main(String[] args) {
Thread t1 = new Thread(() -> {
LockSupport.park();
log.debug("1");
}, "t1");
t1.start();
new Thread(() -> {
log.debug("2");
LockSupport.unpark(t1);
},"t2").start();
}
}
三、交替运行
1.使用wait/notify
@Slf4j
public class RotateTest {
public static void main(String[] args) {
WaitNotify wn = new WaitNotify(1, 5);
new Thread(() -> wn.print("a", 1, 2)).start();
new Thread(() -> wn.print("b", 2, 3)).start();
new Thread(() -> wn.print("c", 3, 1)).start();
}
}
/*
输出内容 等待标记 下一个标记
a 1 2
b 2 3
c 3 1
*/
@Slf4j
class WaitNotify {
// 打印 a 1 2
public void print(String str, int waitFlag, int nextFlag) {
for (int i = 0; i < loopNumber; i++) {
synchronized (this) {
while(flag != waitFlag) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.print(str);
flag = nextFlag;
this.notifyAll();
}
}
}
// 等待标记
private int flag; // 2
// 循环次数
private int loopNumber;
public WaitNotify(int flag, int loopNumber) {
this.flag = flag;
this.loopNumber = loopNumber;
}
}
abcabcabcabcabc
2.使用await/signal
public class RotateTest1 {
public static void main(String[] args) throws InterruptedException {
AwaitSignal awaitSignal = new AwaitSignal(5);
Condition a = awaitSignal.newCondition();
Condition b = awaitSignal.newCondition();
Condition c = awaitSignal.newCondition();
new Thread(() -> awaitSignal.print("a", a, b), "t1").start();
new Thread(() -> awaitSignal.print("b", b, c), "t2").start();
new Thread(() -> awaitSignal.print("c", c, a), "t3").start();
Thread.sleep(1000);
awaitSignal.lock();
try {
a.signal();
} finally {
awaitSignal.unlock();
}
}
}
class AwaitSignal extends ReentrantLock{
// 循环次数
private int loopNumber;
public AwaitSignal(int loopNumber){
this.loopNumber = loopNumber;
}
/**
* 打印
* @param str 打印的字符
* @param current 当前条件变量
* @param next 下一个条件变量
*/
public void print(String str,Condition current,Condition next){
for (int i = 0; i < loopNumber; i++) {
lock();
try{
try {
current.await();
System.out.print(str);
next.signal();
} catch (InterruptedException e) {
e.printStackTrace();
}
}finally {
unlock();
}
}
}
}
3.使用park/unpark
@Slf4j
public class RotateTest2 {
static Thread t1;
static Thread t2;
static Thread t3;
public static void main(String[] args) {
ParkUnpark pu = new ParkUnpark(5);
t1 = new Thread(() -> pu.print("a", t2));
t2 = new Thread(() -> pu.print("b", t3));
t3 = new Thread(() -> pu.print("c", t1));
t1.start();
t2.start();
t3.start();
LockSupport.unpark(t1);
}
}
class ParkUnpark {
public void print(String str, Thread next) {
for (int i = 0; i < loopNumber; i++) {
LockSupport.park();
System.out.print(str);
LockSupport.unpark(next);
}
}
private int loopNumber;
public ParkUnpark(int loopNumber) {
this.loopNumber = loopNumber;
}
}
四、非公平锁实现原理
构造器默认为非公平锁实现：
public ReentrantLock() {
sync = new NonfairSync();
}
NonfairSync 继承自 AQS
没有竞争时：
final void lock() {
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
image.png
3.Thread-1 执行了:
- 1.CAS 尝试将 state 由 0 改为 1，结果失败
- 2.进入 tryAcquire 逻辑，这时 state 已经是1，结果仍然失败
- 3.进入 addWaiter 逻辑，构造 Node 队列
黄色三角表示该 Node 的 waitStatus 状态，其中 0 为默认正常状态
Node 的创建是懒惰的
第一个 Node 称为 Dummy（哑元）或哨兵，用来占位，并不关联线程
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(AbstractQueuedSynchronizer.Node.EXCLUSIVE), arg))
selfInterrupt();
}
3.png
4.当前线程进入 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（灰色表示）
final boolean acquireQueued(final AbstractQueuedSynchronizer.Node node, int arg) {
boolean failed = true;
try {
boolean interrupted = false;
for (;;) {
final AbstractQueuedSynchronizer.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);
}
}
4.png
5.再次有多个线程经历上述过程竞争失败:
image.png
Thread-0 释放锁，进入 tryRelease 流程:
- 设置 exclusiveOwnerThread 为 null
-
state = 0
image.png
- 当前队列不为 null，并且 head 的 waitStatus = -1，进入 unparkSuccessor 流程
- 找到队列中离 head 最近的一个 Node（没取消的），unpark 恢复其运行，本例中即为 Thread-1
回到 Thread-1 的 acquireQueued 流程:
-
如果加锁成功（没有竞争），会设置
1.exclusiveOwnerThread 为 Thread-1，state = 1
2.head 指向刚刚 Thread-1 所在的 Node，该 Node 清空 Thread
3.原本的 head 因为从链表断开，而可被垃圾回收
image.png
如果这时候有其它线程来竞争（非公平的体现），例如这时有 Thread-4 来了:
image.png
如果被 Thread-4 先占了:
- Thread-4 被设置为 exclusiveOwnerThread，state = 1
- Thread-1 再次进入 acquireQueued 流程，获取锁失败，重新进入 park 阻塞
是否需要 unpark 是由当前节点的前驱节点的 waitStatus == Node.SIGNAL 来决定，而不是本节点的waitStatus 决定
加锁源码：
static final class NonfairSync extends Sync {
private static final long serialVersionUID = 7316153563782823691L;
/**
* Performs lock. Try immediate barge, backing up to normal
* acquire on failure.
*/
final void lock() {
//首先用 cas 尝试（仅尝试一次）将 state 从 0 改为 1, 如果成功表示获得了独占锁
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
// 如果尝试失败，进入 ㈠
acquire(1);
}
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
}
// ㈠ AQS 继承过来的方法
public final void acquire(int arg) {
// ㈡ tryAcquire
if (!tryAcquire(arg) &&
// 当 tryAcquire 返回为 false 时, 先调用 addWaiter ㈣, 接着 acquireQueued ㈤
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
// ㈡ 进入 ㈢
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
// ㈢ Sync 继承过来的方法
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
// 如果还没有获得锁
if (c == 0) {
// 尝试用 cas 获得, 这里体现了非公平性: 不去检查 AQS 队列
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
// 如果已经获得了锁, 线程还是当前线程, 表示发生了锁重入
else if (current == getExclusiveOwnerThread()) {
// state++
int nextc = c + acquires;
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
// 获取失败, 回到调用处
return false;
}
// ㈣ AQS 继承过来的方法
private Node addWaiter(Node mode) {
// 将当前线程关联到一个 Node 对象上, 模式为独占模式
Node node = new Node(Thread.currentThread(), mode);
// Try the fast path of enq; backup to full enq on failure
// 如果 tail 不为 null, cas 尝试将 Node 对象加入 AQS 队列尾部
Node pred = tail;
if (pred != null) {
node.prev = pred;
if (compareAndSetTail(pred, node)) {
// 双向链表
pred.next = node;
return node;
}
}
// 尝试将 Node 加入 AQS, 进入 ㈥
enq(node);
return node;
}
// ㈥ AQS 继承过来的方法
private Node enq(final Node node) {
for (;;) {
Node t = tail;
if (t == null) { // Must initialize
// 还没有, 设置 head 为哨兵节点（不对应线程，状态为 0）
if (compareAndSetHead(new Node()))
tail = head;
} else {
// cas 尝试将 Node 对象加入 AQS 队列尾部
node.prev = t;
if (compareAndSetTail(t, node)) {
t.next = node;
return t;
}
}
}
}
// ㈤ AQS 继承过来的方法
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
boolean interrupted = false;
for (;;) {
final Node p = node.predecessor();
// 上一个节点是 head, 表示轮到自己（当前线程对应的 node）了, 尝试获取
if (p == head && tryAcquire(arg)) {
// 获取成功, 设置自己（当前线程对应的 node）为 head
setHead(node);
// 上一个节点 help GC
p.next = null; // help GC
failed = false;
// 返回中断标记 false
return interrupted;
}
// 判断是否应当 park, 进入 ㈦
if (shouldParkAfterFailedAcquire(p, node) &&
// park 等待, 此时 Node 的状态被置为 Node.SIGNAL ㈧
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
// ㈦ AQS 继承过来的方法
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;
// > 0 表示取消状态
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.
*/
// 这次还没有阻塞
// 但下次如果重试不成功, 则需要阻塞，这时需要设置上一个节点状态为 Node.SIGNAL
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
// ㈧ 阻塞当前线程
private final boolean parkAndCheckInterrupt() {
LockSupport.park(this);
return Thread.interrupted();
}
解锁源码：
public void unlock() {
sync.release(1);
}
public final boolean release(int arg) {
// 尝试释放锁, 进入 ㈠
if (tryRelease(arg)) {
// 队列头节点 unpark
Node h = head;
// 队列不为 null ；waitStatus == Node.SIGNAL 才需要 unpark
if (h != null && h.waitStatus != 0)
// unpark AQS 中等待的线程, 进入 ㈡
unparkSuccessor(h);
return true;
}
return false;
}
// ㈠
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;
}
// （二）
private void unparkSuccessor(Node node) {
/*
* If status is negative (i.e., possibly needing signal) try
* to clear in anticipation of signalling. It is OK if this
* fails or if status is changed by waiting thread.
*/
// 如果状态为 Node.SIGNAL 尝试重置状态为 0 不成功也可以
int ws = node.waitStatus;
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
/*
* Thread to unpark is held in successor, which is normally
* just the next node. But if cancelled or apparently null,
* traverse backwards from tail to find the actual
* non-cancelled successor.
*/
// 找到需要 unpark 的节点, 但本节点从 AQS 队列中脱离, 是由唤醒节点完成的
Node s = node.next;
// 不考虑已取消的节点, 从 AQS 队列从后至前找到队列最前面需要 unpark 的节点
if (s == null || s.waitStatus > 0) {
s = null;
for (Node t = tail; t != null && t != node; t = t.prev)
if (t.waitStatus <= 0)
s = t;
}
if (s != null)
LockSupport.unpark(s.thread);
}
