在实际多线程开发中，很多开发者都遇到过这样的困惑：明明给关键线程设置了最高优先级，但程序运行效果却不如预期，甚至出现性能问题。这往往是因为对Java线程优先级的理解不够深入，只停留在简单的1-10数字设置上。本文将彻底解析线程优先级的正确用法，帮你避开常见的3个坑点，并提供实战场景下的最佳实践。
无论你是正在准备Java面试的求职者，还是在实际项目中需要优化多线程性能的开发者，掌握线程优先级的正确使用都能让你的代码更加健壮和高效。
1. 线程优先级基础概念
1.1 什么是线程优先级
线程优先级是Java为每个线程分配的一个整数值，范围从1（Thread.MIN_PRIORITY）到10（Thread.MAX_PRIORITY），默认值为5（Thread.NORM_PRIORITY）。这个数值的作用是向线程调度器提供建议，帮助调度器决定在多个可运行线程中优先选择哪个线程执行。
需要明确的是，线程优先级只是一个"建议"而非"命令"。不同的操作系统和JVM实现可能对优先级的处理方式不同，这也是很多开发者误解的根源。
1.2 优先级常量定义
Java Thread类中预定义了三个常用的优先级常量：
JAVA
复制
1
public class Thread implements Runnable {
2
public final static int MIN_PRIORITY = 1;
3
public final static int NORM_PRIORITY = 5;
4
public final static int MAX_PRIORITY = 10;
5
}
在实际编码中，建议使用这些常量而不是直接使用数字，这样代码可读性更好，也避免了魔法数字的问题。
1.3 优先级的作用机制
线程调度器在决定下一个要运行的线程时，会考虑各个线程的优先级。理论上，优先级高的线程有更大的机会被选中执行。但这种选择不是绝对的，特别是在以下情况下：
系统资源紧张时，调度器可能无法完全遵循优先级设置
不同操作系统的线程调度策略差异很大
高优先级线程可能因为等待I/O或其他资源而让出CPU
2. 设置和获取线程优先级的方法
2.1 setPriority()方法详解
setPriority(int newPriority)方法是设置线程优先级的核心方法。该方法被声明为final，意味着不能被子类重写。
JAVA
复制
1
public final void setPriority(int newPriority) {
2
// 方法实现细节
3
}
使用示例：
JAVA
复制
1
Thread thread = new Thread(() -> {
2
// 线程执行的任务
3
});
4
thread.setPriority(Thread.MAX_PRIORITY); // 设置为最高优先级
重要注意事项：
优先级必须在1-10范围内，否则会抛出IllegalArgumentException
设置优先级最好在线程启动前进行
优先级设置对已经运行的线程也可能生效，但具体效果取决于JVM实现
2.2 getPriority()方法使用
getPriority()方法用于获取线程的当前优先级：
JAVA
复制
1
public final int getPriority() {
2
return priority;
3
}
实际应用示例：
JAVA
复制
1
Thread currentThread = Thread.currentThread();
2
int priority = currentThread.getPriority();
3
System.out.println("当前线程优先级：" + priority);
2.3 完整的基础示例
下面是一个完整的示例，演示如何创建多个不同优先级的线程并观察其行为：
JAVA
复制
1
public class BasicPriorityDemo {
2
3
static class PriorityThread extends Thread {
4
public PriorityThread(String name) {
5
super(name);
6
}
7
8
@Override
9
public void run() {
10
for (int i = 0; i < 5; i++) {
11
System.out.println(getName() + " [优先级:" + getPriority() + "] 执行第" + (i+1) + "次");
12
try {
13
// 短暂休眠，让其他线程有机会执行
14
Thread.sleep(10);
15
} catch (InterruptedException e) {
16
e.printStackTrace();
17
}
18
}
19
}
20
}
21
22
public static void main(String[] args) {
23
System.out.println("主线程优先级：" + Thread.currentThread().getPriority());
24
25
PriorityThread lowPriorityThread = new PriorityThread("低优先级线程");
26
PriorityThread normalPriorityThread = new PriorityThread("普通优先级线程");
27
PriorityThread highPriorityThread = new PriorityThread("高优先级线程");
28
29
// 设置优先级
30
lowPriorityThread.setPriority(Thread.MIN_PRIORITY);
31
normalPriorityThread.setPriority(Thread.NORM_PRIORITY);
32
highPriorityThread.setPriority(Thread.MAX_PRIORITY);
33
34
// 启动线程
35
lowPriorityThread.start();
36
normalPriorityThread.start();
37
highPriorityThread.start();
38
}
39
}
运行这个程序，你可能会发现高优先级线程的执行次数更多，但这并不是绝对的。多次运行可能会得到不同的结果，这正说明了优先级只是建议性的。
3. 线程优先级的3个常见坑点
3.1 坑点一：优先级不保证执行顺序
这是最常见的误解。很多开发者认为设置高优先级就能确保线程优先执行，但实际上这取决于操作系统的线程调度策略。
问题示例：
JAVA
复制
1
public class PriorityMisunderstandingDemo {
2
3
public static void main(String[] args) {
4
Thread t1 = new Thread(() -> {
5
for (int i = 0; i < 1000000; i++) {
6
// 密集计算任务
7
}
8
System.out.println("高优先级线程完成");
9
});
10
11
Thread t2 = new Thread(() -> {
12
for (int i = 0; i < 1000000; i++) {
13
// 密集计算任务
14
}
15
System.out.println("低优先级线程完成");
16
});
17
18
t1.setPriority(Thread.MAX_PRIORITY);
19
t2.setPriority(Thread.MIN_PRIORITY);
20
21
t1.start();
22
t2.start();
23
}
24
}
在这个例子中，低优先级线程有可能先于高优先级线程完成，特别是在多核CPU环境下。
解决方案：
不要依赖优先级来控制执行顺序，如果需要严格的执行顺序，应该使用同步机制如CountDownLatch、CyclicBarrier等。
3.2 坑点二：平台依赖性导致的行为差异
不同的操作系统对线程优先级的支持程度不同，这会导致相同的代码在不同平台上表现不一致。
Windows vs Linux差异：
Windows系统有较多的优先级级别，能够较好地区分不同优先级
Linux系统的线程优先级区分相对较弱，高优先级的效果不明显
测试代码：
JAVA
复制
1
public class PlatformDependencyDemo {
2
3
public static void main(String[] args) {
4
System.out.println("操作系统: " + System.getProperty("os.name"));
5
6
Thread[] threads = new Thread[10];
7
for (int i = 0; i < threads.length; i++) {
8
final int threadNum = i;
9
threads[i] = new Thread(() -> {
10
long count = 0;
11
for (int j = 0; j < 10000000; j++) {
12
count++;
13
}
14
System.out.println("线程" + threadNum + " [优先级:" +
15
Thread.currentThread().getPriority() + "] 完成");
16
});
17
threads[i].setPriority(i % 10 + 1); // 设置不同优先级
18
}
19
20
for (Thread thread : threads) {
21
thread.start();
22
}
23
}
24
}
跨平台建议：
避免编写依赖特定优先级行为的代码
如果必须使用优先级，要进行充分的跨平台测试
考虑使用更可控的并发工具替代优先级控制
3.3 坑点三：优先级反转问题
优先级反转是实时系统中的经典问题，在Java中也可能出现。当高优先级线程等待低优先级线程持有的资源时，如果中间有中等优先级线程运行，就会导致高优先级线程被无限期推迟。
优先级反转示例：
JAVA
复制
1
public class PriorityInversionDemo {
2
3
private static final Object lock = new Object();
4
5
public static void main(String[] args) throws InterruptedException {
6
Thread lowPriorityThread = new Thread(() -> {
7
synchronized (lock) {
8
System.out.println("低优先级线程获取锁");
9
try {
10
Thread.sleep(5000); // 模拟长时间操作
11
} catch (InterruptedException e) {
12
e.printStackTrace();
13
}
14
System.out.println("低优先级线程释放锁");
15
}
16
});
17
18
Thread mediumPriorityThread = new Thread(() -> {
19
// 中等优先级线程执行计算密集型任务
20
long start = System.currentTimeMillis();
21
while (System.currentTimeMillis() - start < 10000) {
22
// 模拟计算
23
}
24
System.out.println("中等优先级线程完成");
25
});
26
27
Thread highPriorityThread = new Thread(() -> {
28
synchronized (lock) {
29
System.out.println("高优先级线程获取锁");
30
}
31
});
32
33
lowPriorityThread.setPriority(Thread.MIN_PRIORITY);
34
mediumPriorityThread.setPriority(Thread.NORM_PRIORITY);
35
highPriorityThread.setPriority(Thread.MAX_PRIORITY);
36
37
lowPriorityThread.start();
38
Thread.sleep(100); // 确保低优先级线程先获取锁
39
mediumPriorityThread.start();
40
highPriorityThread.start();
41
}
42
}
在这个例子中，高优先级线程需要等待低优先级线程释放锁，但中等优先级线程可能抢占CPU，导致高优先级线程长时间等待。
解决方案：
使用锁的超时机制
避免在长时间操作中持有锁
考虑使用优先级继承机制（Java原生不支持，需要手动实现）
4. 实战场景下的正确用法
4.1 GUI应用程序中的优先级使用
在图形界面应用中，响应性至关重要。UI线程应该设置为较高优先级，确保用户交互得到及时响应。
JAVA
复制
1
public class GUIApplicationDemo {
2
3
public static void main(String[] args) {
4
// UI线程 - 高优先级
5
Thread uiThread = new Thread(() -> {
6
Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
7
while (true) {
8
// 处理UI事件
9
processUIEvents();
10
try {
11
Thread.sleep(16); // 约60FPS
12
} catch (InterruptedException e) {
13
break;
14
}
15
}
16
});
17
18
// 后台任务线程 - 普通优先级
19
Thread backgroundThread = new Thread(() -> {
20
Thread.currentThread().setPriority(Thread.NORM_PRIORITY);
21
while (true) {
22
// 执行后台计算
23
performBackgroundCalculation();
24
try {
25
Thread.sleep(1000);
26
} catch (InterruptedException e) {
27
break;
28
}
29
}
30
});
31
32
uiThread.start();
33
backgroundThread.start();
34
}
35
36
private static void processUIEvents() {
37
// 模拟UI事件处理
38
}
39
40
private static void performBackgroundCalculation() {
41
// 模拟后台计算
42
}
43
}
4.2 实时数据处理场景
在实时数据处理系统中，数据采集线程通常需要高优先级，确保数据不丢失。
JAVA
复制
1
public class RealTimeDataProcessingDemo {
2
3
private static volatile boolean running = true;
4
private static final BlockingQueue dataQueue = new LinkedBlockingQueue<>();
5
6
static class Data {
7
private final long timestamp;
8
private final double value;
9
10
public Data(long timestamp, double value) {
11
this.timestamp = timestamp;
12
this.value = value;
13
}
14
}
15
16
public static void main(String[] args) {
17
// 数据采集线程 - 最高优先级
18
Thread dataAcquisitionThread = new Thread(() -> {
19
Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
20
while (running) {
21
Data data = readSensorData();
22
try {
23
dataQueue.put(data);
24
} catch (InterruptedException e) {
25
break;
26
}
27
}
28
});
29
30
// 数据处理线程 - 普通优先级
31
Thread dataProcessingThread = new Thread(() -> {
32
while (running) {
33
try {
34
Data data = dataQueue.take();
35
processData(data);
36
} catch (InterruptedException e) {
37
break;
38
}
39
}
40
});
41
42
dataAcquisitionThread.start();
43
dataProcessingThread.start();
44
45
// 运行一段时间后停止
46
try {
47
Thread.sleep(10000);
48
} catch (InterruptedException e) {
49
e.printStackTrace();
50
}
51
running = false;
52
}
53
54
private static Data readSensorData() {
55
// 模拟读取传感器数据
56
return new Data(System.currentTimeMillis(), Math.random());
57
}
58
59
private static void processData(Data data) {
60
// 模拟数据处理
61
System.out.println("处理数据: " + data.value + " @ " + data.timestamp);
62
}
63
}
4.3 批量处理任务优化
在批量处理系统中，可以动态调整优先级来优化整体性能。
JAVA
复制
1
public class BatchProcessingOptimization {
2
3
public static void main(String[] args) throws InterruptedException {
4
ExecutorService executor = Executors.newFixedThreadPool(4);
5
6
List
7
8
for (int i = 0; i < 10; i++) {
9
final int taskId = i;
10
Future future = executor.submit(() -> {
11
Thread currentThread = Thread.currentThread();
12
13
// 第一阶段：数据准备 - 高优先级
14
currentThread.setPriority(Thread.MAX_PRIORITY);
15
System.out.println("任务" + taskId + " 数据准备阶段");
16
prepareData(taskId);
17
18
// 第二阶段：批量处理 - 普通优先级
19
currentThread.setPriority(Thread.NORM_PRIORITY);
20
System.out.println("任务" + taskId + " 处理阶段");
21
processBatch(taskId);
22
23
// 第三阶段：结果写入 - 低优先级
24
currentThread.setPriority(Thread.MIN_PRIORITY);
25
System.out.println("任务" + taskId + " 结果写入阶段");
26
writeResults(taskId);
27
});
28
futures.add(future);
29
}
30
31
// 等待所有任务完成
32
for (Future future : futures) {
33
future.get();
34
}
35
36
executor.shutdown();
37
}
38
39
private static void prepareData(int taskId) {
40
try { Thread.sleep(100); } catch (InterruptedException e) {}
41
}
42
43
private static void processBatch(int taskId) {
44
try { Thread.sleep(200); } catch (InterruptedException e) {}
45
}
46
47
private static void writeResults(int taskId) {
48
try { Thread.sleep(50); } catch (InterruptedException e) {}
49
}
50
}
5. 高级特性与最佳实践
5.1 线程组与优先级继承
线程组可以统一管理一组线程的优先级，但要注意优先级继承的规则。
JAVA
复制
1
public class ThreadGroupPriorityDemo {
2
3
public static void main(String[] args) {
4
// 创建线程组并设置最大优先级
5
ThreadGroup highPriorityGroup = new ThreadGroup("高优先级组");
6
highPriorityGroup.setMaxPriority(Thread.MAX_PRIORITY);
7
8
ThreadGroup normalPriorityGroup = new ThreadGroup("普通优先级组");
9
normalPriorityGroup.setMaxPriority(Thread.NORM_PRIORITY);
10
11
// 在线程组中创建线程
12
Thread t1 = new Thread(highPriorityGroup, () -> {
13
System.out.println("线程" + Thread.currentThread().getName() +
14
" 优先级: " + Thread.currentThread().getPriority());
15
});
16
17
Thread t2 = new Thread(normalPriorityGroup, () -> {
18
System.out.println("线程" + Thread.currentThread().getName() +
19
" 优先级: " + Thread.currentThread().getPriority());
20
});
21
22
// 注意：线程启动后修改线程组的最大优先级不会影响已启动的线程
23
t1.start();
24
t2.start();
25
}
26
}
5.2 结合Java并发工具的使用
在现代Java开发中，更推荐使用并发工具包(java.util.concurrent)而不是直接操作线程优先级。
JAVA
复制
1
public class ConcurrentToolsWithPriority {
2
3
public static void main(String[] args) {
4
// 使用优先级队列的线程池
5
ThreadPoolExecutor executor = new ThreadPoolExecutor(
6
2, 4, 60, TimeUnit.SECONDS,
7
new PriorityBlockingQueue
8
@Override
9
public int compare(Runnable r1, Runnable r2) {
10
// 根据任务优先级排序
11
int p1 = (r1 instanceof PriorityTask) ? ((PriorityTask) r1).getPriority() : 5;
12
int p2 = (r2 instanceof PriorityTask) ? ((PriorityTask) r2).getPriority() : 5;
13
return Integer.compare(p2, p1); // 降序排列，高优先级在前
14
}
15
})
16
);
17
18
// 提交不同优先级的任务
19
for (int i = 0; i < 10; i++) {
20
int priority = (i % 3 == 0) ? Thread.MAX_PRIORITY :
21
(i % 3 == 1) ? Thread.NORM_PRIORITY : Thread.MIN_PRIORITY;
22
executor.execute(new PriorityTask("任务" + i, priority));
23
}
24
25
executor.shutdown();
26
}
27
28
static class PriorityTask implements Runnable {
29
private final String name;
30
private final int priority;
31
32
public PriorityTask(String name, int priority) {
33
this.name = name;
34
this.priority = priority;
35
}
36
37
public int getPriority() {
38
return priority;
39
}
40
41
@Override
42
public void run() {
43
System.out.println(name + " [优先级:" + priority + "] 开始执行");
44
try {
45
Thread.sleep(1000);
46
} catch (InterruptedException e) {
47
Thread.currentThread().interrupt();
48
}
49
System.out.println(name + " 执行完成");
50
}
51
}
52
}
5.3 监控和调试技巧
在实际项目中，监控线程优先级的变化对于调试性能问题很有帮助。
JAVA
复制
1
public class ThreadPriorityMonitor {
2
3
public static void main(String[] args) {
4
// 创建监控线程
5
Thread monitorThread = new Thread(() -> {
6
while (true) {
7
printThreadPriorities();
8
try {
9
Thread.sleep(5000);
10
} catch (InterruptedException e) {
11
break;
12
}
13
}
14
});
15
monitorThread.setDaemon(true);
16
monitorThread.start();
17
18
// 创建一些测试线程
19
for (int i = 0; i < 3; i++) {
20
Thread worker = new Thread(() -> {
21
while (true) {
22
try {
23
Thread.sleep(1000);
24
} catch (InterruptedException e) {
25
break;
26
}
27
}
28
});
29
worker.setPriority(Thread.MIN_PRIORITY + i * 4);
30
worker.setName("Worker-" + i);
31
worker.start();
32
}
33
34
try {
35
Thread.sleep(15000);
36
} catch (InterruptedException e) {
37
e.printStackTrace();
38
}
39
}
40
41
private static void printThreadPriorities() {
42
System.out.println("=== 线程优先级监控 ===");
43
System.out.println("时间: " + new Date());
44
45
Map
46
for (Thread thread : allThreads.keySet()) {
47
if (thread.isAlive()) {
48
System.out.printf("线程: %-20s 优先级: %2d 状态: %s%n",
49
thread.getName(), thread.getPriority(), thread.getState());
50
}
51
}
52
System.out.println();
53
}
54
}
6. 性能测试与对比分析
6.1 优先级对性能的影响测试
通过实际测试来验证不同优先级设置对程序性能的影响。
JAVA
复制
1
public class PriorityPerformanceTest {
2
3
private static final int TASK_COUNT = 1000000;
4
5
public static void main(String[] args) throws InterruptedException {
6
testWithPriority(Thread.MIN_PRIORITY, "低优先级");
7
testWithPriority(Thread.NORM_PRIORITY, "普通优先级");
8
testWithPriority(Thread.MAX_PRIORITY, "高优先级");
9
}
10
11
private static void testWithPriority(int priority, String description)
12
throws InterruptedException {
13
System.out.println("=== " + description + "测试 ===");
14
15
long startTime = System.currentTimeMillis();
16
17
Thread[] threads = new Thread[4];
18
AtomicLong totalCount = new AtomicLong(0);
19
20
for (int i = 0; i < threads.length; i++) {
21
threads[i] = new Thread(() -> {
22
Thread.currentThread().setPriority(priority);
23
long count = 0;
24
for (int j = 0; j < TASK_COUNT; j++) {
25
count++;
26
// 模拟一些计算
27
Math.sqrt(j);
28
}
29
totalCount.addAndGet(count);
30
});
31
threads[i].start();
32
}
33
34
for (Thread thread : threads) {
35
thread.join();
36
}
37
38
long endTime = System.currentTimeMillis();
39
long duration = endTime - startTime;
40
41
System.out.println(description + "任务完成时间: " + duration + "ms");
42
System.out.println("总计算量: " + totalCount.get());
43
System.out.println();
44
}
45
}
6.2 不同工作负载下的表现
测试CPU密集型、I/O密集型和混合型任务在不同优先级下的表现差异。
JAVA
复制
1
public class WorkloadPriorityTest {
2
3
public static void main(String[] args) throws InterruptedException {
4
System.out.println("=== CPU密集型任务测试 ===");
5
testCPUIntensiveWorkload();
6
7
System.out.println("=== I/O密集型任务测试 ===");
8
testIOIntensiveWorkload();
9
10
System.out.println("=== 混合型任务测试 ===");
11
testMixedWorkload();
12
}
13
14
private static void testCPUIntensiveWorkload() throws InterruptedException {
15
testWorkload("CPU密集型", () -> {
16
// CPU密集型计算
17
long result = 0;
18
for (int i = 0; i < 1000000; i++) {
19
result += i * i;
20
}
21
});
22
}
23
24
private static void testIOIntensiveWorkload() throws InterruptedException {
25
testWorkload("I/O密集型", () -> {
26
try {
27
// 模拟I/O操作
28
Thread.sleep(10);
29
} catch (InterruptedException e) {
30
Thread.currentThread().interrupt();
31
}
32
});
33
}
34
35
private static void testMixedWorkload() throws InterruptedException {
36
testWorkload("混合型", () -> {
37
// 混合计算和I/O
38
long result = 0;
39
for (int i = 0; i < 100000; i++) {
40
result += i * i;
41
}
42
try {
43
Thread.sleep(1);
44
} catch (InterruptedException e) {
45
Thread.currentThread().interrupt();
46
}
47
});
48
}
49
50
private static void testWorkload(String workloadType, Runnable task)
51
throws InterruptedException {
52
int[] priorities = {Thread.MIN_PRIORITY, Thread.NORM_PRIORITY, Thread.MAX_PRIORITY};
53
String[] priorityNames = {"低优先级", "普通优先级", "高优先级"};
54
55
for (int i = 0; i < priorities.length; i++) {
56
long startTime = System.currentTimeMillis();
57
58
Thread thread = new Thread(() -> {
59
Thread.currentThread().setPriority(priorities[i]);
60
for (int j = 0; j < 100; j++) {
61
task.run();
62
}
63
});
64
65
thread.start();
66
thread.join();
67
68
long endTime = System.currentTimeMillis();
69
System.out.println(workloadType + " - " + priorityNames[i] +
70
": " + (endTime - startTime) + "ms");
71
}
72
System.out.println();
73
}
74
}
7. 常见问题排查与解决方案
7.1 优先级设置不生效的问题排查
当发现线程优先级设置没有达到预期效果时，可以按照以下步骤排查：
JAVA
复制
1
public class PriorityTroubleshooting {
2
3
public static void main(String[] args) {
4
// 1. 检查当前操作系统对优先级的支持
5
System.out.println("操作系统: " + System.getProperty("os.name"));
6
System.out.println("JVM版本: " + System.getProperty("java.version"));
7
8
// 2. 验证优先级设置是否正确
9
Thread testThread = new Thread(() -> {
10
System.out.println("线程初始优先级: " + Thread.currentThread().getPriority());
11
});
12
13
testThread.setPriority(8);
14
System.out.println("设置后的优先级: " + testThread.getPriority());
15
16
// 3. 检查线程是否已经启动
17
testThread.start();
18
19
// 4. 监控线程实际运行时的优先级
20
Thread monitor = new Thread(() -> {
21
while (testThread.isAlive()) {
22
System.out.println("运行中优先级: " + testThread.getPriority());
23
try {
24
Thread.sleep(100);
25
} catch (InterruptedException e) {
26
break;
27
}
28
}
29
});
30
monitor.setDaemon(true);
31
monitor.start();
32
33
try {
34
testThread.join();
35
} catch (InterruptedException e) {
36
e.printStackTrace();
37
}
38
}
39
}
7.2 死锁和资源竞争问题
高优先级线程在竞争资源时可能引发特殊类型的死锁问题。
JAVA
复制
1
public class PriorityDeadlockDemo {
2
3
private static final Object lockA = new Object();
4
private static final Object lockB = new Object();
5
6
public static void main(String[] args) throws InterruptedException {
7
Thread highPriorityThread = new Thread(() -> {
8
Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
9
synchronized (lockA) {
10
System.out.println("高优先级线程获取lockA");
11
try {
12
Thread.sleep(100); // 模拟处理时间
13
} catch (InterruptedException e) {
14
e.printStackTrace();
15
}
16
synchronized (lockB) {
17
System.out.println("高优先级线程获取lockB");
18
}
19
}
20
});
21
22
Thread lowPriorityThread = new Thread(() -> {
23
Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
24
synchronized (lockB) {
25
System.out.println("低优先级线程获取lockB");
26
try {
27
Thread.sleep(100); // 模拟处理时间
28
} catch (InterruptedException e) {
29
e.printStackTrace();
30
}
31
synchronized (lockA) {
32
System.out.println("低优先级线程获取lockA");
33
}
34
}
35
});
36
37
highPriorityThread.start();
38
lowPriorityThread.start();
39
40
// 等待一段时间后检测死锁
41
Thread.sleep(1000);
42
43
if (highPriorityThread.isAlive() && lowPriorityThread.isAlive()) {
44
System.out.println("可能发生死锁！");
45
System.out.println("高优先级线程状态: " + highPriorityThread.getState());
46
System.out.println("低优先级线程状态: " + lowPriorityThread.getState());
47
}
48
}
49
}
解决方案：
使用锁超时机制：tryLock(timeout, unit)
避免嵌套锁，按固定顺序获取锁
使用更高级的并发工具
7.3 性能优化检查清单
在实际项目中使用线程优先级时，可以参考以下检查清单：
优先级设置合理性检查
是否真正需要设置优先级？
优先级差异是否过大？
是否考虑了平台差异性？
资源竞争分析
高优先级线程是否会长时间持有锁？
是否存在优先级反转的风险？
是否有可能导致饥饿现象？
监控和测试
是否在不同平台上测试过？
是否有监控线程状态的机制？
性能测试结果是否符合预期？
备选方案考虑
是否可以考虑使用并发工具替代？
任务拆分是否更有效？
异步处理是否更适合？
通过系统性地掌握线程优先级的原理、坑点和实战技巧，你可以在适当的场景下合理使用这一特性，避免常见的错误用法。记住，线程优先级是一个需要谨慎使用的工具，理解其局限性比掌握其用法更为重要。