# 50. LockSupport机制分析
# 标准答案
✅ LockSupport的核心实现机制:
基本原理:
- 基于Parker对象实现
- 使用许可证机制
- 支持中断操作
- 不会抛出异常
核心特性:
- 可以先unpark后park
- 不需要获取锁
- 不会产生死锁
- 精确的线程控制
应用场景:
- AQS框架实现
- 线程同步工具
- 调度控制
- 超时等待
# 答案解析
# 1️⃣ 基本使用示例
public class LockSupportExample {
private static Thread mainThread;
public static void main(String[] args) {
mainThread = Thread.currentThread();
new Thread(() -> {
try {
TimeUnit.SECONDS.sleep(3);
System.out.println("Unparking main thread");
LockSupport.unpark(mainThread);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}).start();
System.out.println("Parking main thread");
LockSupport.park();
System.out.println("Main thread resumed");
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 2️⃣ 超时等待实现
public class TimeoutParkExample {
private static class ParkWithTimeout {
private final Thread thread;
private volatile boolean completed;
public ParkWithTimeout() {
this.thread = Thread.currentThread();
}
public boolean await(long timeout, TimeUnit unit) {
long deadline = System.nanoTime() + unit.toNanos(timeout);
while (!completed && System.nanoTime() < deadline) {
LockSupport.parkNanos(deadline - System.nanoTime());
if (Thread.interrupted()) {
return false;
}
}
return completed;
}
public void signal() {
completed = true;
LockSupport.unpark(thread);
}
}
public static void main(String[] args) {
ParkWithTimeout parker = new ParkWithTimeout();
new Thread(() -> {
try {
TimeUnit.SECONDS.sleep(2);
parker.signal();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}).start();
boolean success = parker.await(3, TimeUnit.SECONDS);
System.out.println("Wait result: " + success);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
# 常见误区
- ❌ 误区1:认为park/unpark必须成对使用
- ❌ 误区2:忽视中断处理
# 典型场景与解决方案
# ✅ 条件等待实现
public class ConditionExample {
private static class Condition {
private volatile boolean flag;
public void await() {
while (!flag) {
LockSupport.park();
}
}
public void signal() {
flag = true;
LockSupport.unpark(Thread.currentThread());
}
public void reset() {
flag = false;
}
}
private final Condition condition = new Condition();
public void waitForCondition() {
condition.await();
}
public void signalAll() {
condition.signal();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
# 企业实战经验
# Situation(业务背景)
需要实现精确的线程控制和调度。
# Task(核心任务)
使用LockSupport实现线程协调机制。
# Action(解决方案)
- 实现超时等待
- 处理中断情况
- 避免死锁风险
- 添加监控指标
# Result(结果)
- 线程调度更精确
- 系统响应更可靠
- 死锁风险降低
# 深入追问
🔹 为什么LockSupport比wait/notify更可靠?
- 不需要获取锁
- 支持先unpark
- 不会抛出异常
🔹 如何处理park的线程中断?
- 检查中断标志
- 实现超时机制
- 提供恢复机制
# 相关面试题
- LockSupport的底层实现原理?
- 如何避免线程永久挂起?
- park和wait的区别是什么?