知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 活锁与饥饿 > 导读:本文从"死锁排查完了、线程栈里也没有锁等待,可 CPU 还是打满、任务就是不动"这个具体痛点出发,把死锁/活锁/饥饿三者的本质区别、活锁的典型场景与破解之道、饥饿的成因与公平锁的取舍、以及它们和死锁排查思路的差异逐一讲透,最后给出生产实践建议。适合已经了解 Java 线程与锁、想把并发问题定位清楚的同学。 ## 一、先建立全局认知 ### Q:死锁、活锁、饥饿,到底差在哪? A:结论先行——它们都会让"任务完不成",但**线程状态**和**根因**完全不同:死锁是线程互相等待、**全部阻塞**、谁也走不了;活锁是线程**都在运行**、状态不停变化、却始终没有进展;饥饿是**某些线程长期抢不到资源**、一直被排在后面。 | 维度 | 死锁(Deadlock) | 活锁(Livelock) | 饥饿(Starvation) | |------|------------------|------------------|--------------------| | 线程是否在运行 | 都阻塞,几乎不占 CPU | 都在运行,通常高 CPU | 部分线程长期得不到调度/资源 | | 是否"卡住" | 彻底卡死 | 看似在忙,实则无进展 | 特定线程卡在等待 | | 状态是否变化 | 基本不变 | 频繁变化、来回震荡 | 变化很慢甚至停滞 | | 是否能自愈 | 几乎不会 | 可能,取决于退避/仲裁 | 可能,取决于调度与抢占 | | 典型现象 | 线程栈互相持有锁 | CPU 高但业务吞吐为 0 | 某类任务长期不执行 | | 排查手段 | jstack 直接报死锁 | 多次采样看栈在变、CPU 高 | 看调度/排队/线程池指标 | | 根因 | 循环等待 + 不可剥夺 | 对称的退让/重试 | 资源分配不公平 | 用一个路口类比:死锁是两辆车在十字路口互不相让、**都停着**;活锁是两辆车**同时**向前又同时倒车、来回让路,谁也没过去;饥饿是一直有小路口的车疯狂插队,某个方向的车永远等不到绿灯。 这里有三个术语,先把定义钉死: - **死锁(Deadlock)**:一组线程中每个线程都在等待一个只能由组内其他线程释放的资源,导致所有线程永久阻塞,系统无法推进。 - **活锁(Livelock)**:线程并未阻塞,仍在不断执行和改变状态,但这些动作只让彼此反复重试、始终无法完成任务,整体没有有效进展。 - **饥饿(Starvation)**:某个(些)线程因为资源分配策略不公平,长期无法获得所需资源,从而得不到执行机会或执行机会极少。 ### Q:为什么会有"线程活着、却毫无进展"这种事? A:结论先行——因为并发系统里很多"重试/让步"逻辑是**对称**的:两个或多个线程用同一套策略去对冲同一个冲突,就可能永远停在"互相谦让"或"反复撞车"的循环里;而饥饿则来自资源分配规则本身**不公平**,让弱的一方长期抢不过强的一方。 沿着这两条主线看: 1. **活锁来自对称性**。当"检测到冲突就退让/重试"的策略对双方都成立、且双方行为完全同步时,冲突会被无限重复。要跳出这个循环,要么**打破对称**(引入随机、优先级、仲裁),要么**改变策略**(加重试上限、升级为串行)。 2. **饥饿来自不公平**。锁的获取若允许"插队"(非公平锁)、调度若偏向高优先级线程、资源若被"强者"持续占据,弱线程就永远排在队尾。 理解这两条主线之后,所有的"解药"都有了统一的落点:活锁的解药是**造出差异与终点**,饥饿的解药是**让分配有边界、有公平、有隔离**。 ### Q:为什么说活锁通常比死锁更难定位? A:结论先行——因为死锁是"静止"的,`jstack` 一句话就能报出来;活锁是"运动"的,线程状态、调用栈、CPU 都在变,没有任何一个瞬间能直接指认"这里卡住了",只能靠时间维度上的对比来推断。 - **死锁有"指纹"**:互相等待的锁环会被 JVM 的死锁检测直接识别,`jstack` 打印 "Found one Java-level deadlock" 并列出线程与锁,定位几乎是确定性的。 - **活锁没有"指纹"**:它表现为"一直在重试/回滚,就是没成功",单次线程栈看起来完全正常(`RUNNABLE`,执行着普通的业务方法),你甚至可能误判为"系统只是有点忙"。要发现它,通常得结合**重试次数、冲突率、事务回滚率**这些业务指标。 - **两者的表现还可能被混淆**:活锁的 CPU 占用高,容易被当成"性能问题"去扩容,结果越扩越糟(见前面"重试风暴");饥饿则容易被当成"资源不够"去加线程,而根因其实是资源被长期占用或隔离不当。 关键点:定位活锁的关键是"看趋势而不是看快照"。适用/不适用:这条判断对进程内的活锁和分布式场景下的重试风暴都成立。 ## 二、活锁:场景与破解 ### Q:活锁的典型场景有哪些? A:结论先行——最常见的是三类:① 两个线程用对称的"先退让再重试"策略争抢同一个资源,结果一直互相让;② 消息/任务在并发冲突下被反复回滚、重投、再冲突;③ 网络或分布式系统里多个节点同时退避、又同时重试(以太网的二进制指数退避正是为打破它而生)。 展开这三类: 1. **对称重试互相冲突**。两个线程都需要"锁 A + 锁 B",一个先拿 A 再拿 B、另一个先拿 B 再拿 A,并且约定"拿不到第二把就释放已拿到的、等一下再重试"。如果两者的"等一下"时长和节奏完全一致,就可能在无限循环里每次都撞车——线程一直在跑,却没有一次真正拿到两把锁。 2. **消息反复重投被回滚**。消费端处理消息时,若遇到并发冲突就回滚事务并让消息重新投递;如果多个消费者总是同时抢到同一条消息、又同时回滚,就会形成"投递—冲突—回滚—重投"的活锁,消息延迟持续升高、积压却迟迟不降。 3. **退避策略同步化**。分布式节点检测到冲突后各自等待一个固定时长再重试。若所有节点等的是同一个固定值,它们会**再次同时**重试并再次冲突。以太网在冲突检测(CSMA/CD)里采用的**二进制指数退避(binary exponential backoff)**就是为打破这种同步化:每次冲突后把随机等待窗口翻倍,并在窗口内随机取值,从概率上把各节点的重试时间岔开。 ### Q:怎么解决活锁? A:结论先行——**打破对称、引入随机、设置终点**。具体是三条:随机退避(加抖动 jitter)、引入优先级/仲裁(让一方先走)、改变重试策略(重试上限 + 降级/串行化)。 - **随机退避**:把"固定等待"改成"随机等待"。这样两个线程下一次重试的时间几乎不会重合,冲突概率随重试次数快速下降;分布式场景常用"指数退避 + 抖动"。 - **引入优先级/仲裁**:用一条确定性的规则打破对称。例如用线程 ID、节点 ID 的字典序来裁决"谁必须先让步",让"让路"只发生在其中一方身上,另一方直接前进。 - **改变重试策略**:给重试设上限,达到上限后**放弃、降级或改为串行/单写者**处理;或者干脆把"并发写"改成"排他串行",从源头消除对称冲突。 - **配套让操作幂等 + 可终止**:重投类场景里让消息处理幂等,并配合死信队列,避免"永远在重投"。 一句话总结取舍:随机退避是"概率上错开",确定性仲裁是"规则上错开",重试上限是"给循环一个出口"。三者常常叠加使用——先随机错开降低冲突,再用上限兜底。 ### Q:重试风暴和活锁是什么关系?为什么"加机器"有时反而更糟? A:结论先行——活锁常常是"重试风暴"的一种表现:当大量线程或节点在同一时刻、用同一节奏争抢同一份资源并不断重试时,冲突率反而被推高;此时加机器会增加并发参与者,让"同时重试"的概率更大,冲突更严重。 关键在于**重试的时间是否同步**。假设有 N 个参与者,每个都在"冲突后等 T 毫秒再试一次": - 如果 T 是固定值,所有人在同一时刻重新涌入,下一轮冲突的概率与 N 正相关——机器越多,撞得越狠; - 如果 T 是"指数退避 + 随机抖动",重试时刻被随机打散,冲突概率随重试轮次快速下降,系统能收敛。 所以"加机器"能不能缓解,取决于退避策略:**同步固定退避下加机器可能加剧活锁,带随机的指数退避下加机器才更接近线性扩容。** 生产上的做法是:先给重试加随机与上限,再考虑扩容;同时用令牌、队列把"并发抢同一资源"改成"排队串行处理"。  *图:活锁、饥饿与退避策略:固定退避 vs 指数退避 + 抖动* ```text 固定退避(同步,每次都撞): 指数退避 + 抖动(错开,逐轮收敛): A: 冲突 → 等 100ms → 冲突 A: 冲突 → 等 37ms → 成功 B: 冲突 → 等 100ms → 冲突 B: 冲突 → 等 214ms → 成功 C: 冲突 → 等 100ms → 冲突 C: 冲突 → 等 82ms → 成功 ``` ### Q:给一个可运行的活锁演示,再给出修复方案。 A:结论先行——下面用经典的"两个人抢一把勺子、互相谦让"模型演示活锁:双方都饿、都遵守"让对方先吃"的规则,结果谁也没吃上;修复方式是**打破对称**,规定"两人都饿时按名字字典序,小的一方先吃"。 ```java public class LivelockDemo { static class Spoon { private Diner owner; // 勺子当前归谁 public Spoon(Diner d) { owner = d; } public Diner getOwner() { return owner; } public synchronized void setOwner(Diner d) { owner = d; } public synchronized void use() { System.out.println(owner.name + " 吃上了"); } } static class Diner { private final String name; private volatile boolean isHungry = true; public Diner(String name) { this.name = name; } public String getName() { return name; } public boolean isHungry() { return isHungry; } // 活锁版:只要对方还饿就让给对方 → 永远互相谦让 public void eatWith(Spoon spoon, Diner spouse) { while (isHungry) { if (spoon.getOwner() != this) { // 勺子不在我这,等一下再看 sleepBriefly(); continue; } if (spouse.isHungry()) { // 对方还饿 → 让给对方 System.out.println(name + ": 你先吃," + spouse.getName()); spoon.setOwner(spouse); continue; // 继续循环,等勺子回到自己手里 } spoon.use(); // 只有对方不饿了才吃 isHungry = false; spoon.setOwner(spouse); } } private void sleepBriefly() { try { Thread.sleep(1); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } } public static void main(String[] args) { Diner alice = new Diner("alice"); Diner bob = new Diner("bob"); Spoon spoon = new Spoon(alice); // 一开始勺子归 alice new Thread(() -> alice.eatWith(spoon, bob), "alice").start(); new Thread(() -> bob.eatWith(spoon, alice), "bob").start(); } } ``` 关键点/预期行为:两人都 `isHungry == true`,只要"对方还饿"就无条件让对方,于是 `owner` 在两人之间来回切换,控制台不断打印"你先吃",但**谁都吃不上**——线程持续在运行,CPU 有占用,进展为零。这就是活锁的典型形态:状态一直在变,任务始终完不成。 修复(打破对称):把"对方饿就让"改成"**只有在按规则我该让时才让**": ```java // 修复版:双方都饿时按名字字典序裁决,小的一方先吃 public void eatWithFixed(Spoon spoon, Diner spouse) { while (isHungry) { if (spoon.getOwner() != this) { sleepBriefly(); continue; } // 只有当"我名字更大"时才让步;字典序小的一方永不让步 → 对称被打破 if (spouse.isHungry() && name.compareTo(spouse.getName()) > 0) { spoon.setOwner(spouse); continue; } spoon.use(); isHungry = false; spoon.setOwner(spouse); } } ``` 预期行为:`alice` 的 `name.compareTo("bob") < 0`,让步条件不成立 → alice 直接吃;吃完 `isHungry` 变为 false,再把勺子给 bob,bob 随后吃上。适用/不适用:用"字典序/ID 大小"这类**确定性规则**打破对称,简单可靠,适合节点数少、规则好定义的场景;节点很多时更常用"随机退避"来降低冲突概率,两者也可以叠加使用。 ## 三、饥饿:成因与公平性取舍 ### Q:饥饿的典型成因有哪些? A:结论先行——四类最常见:线程优先级差异、非公平锁的"插队"、大量小任务持续抢占资源、以及线程池核心线程被长任务占满导致后续任务排不上。 1. **线程优先级**:`Thread.setPriority(int)` 只是给调度器一个**提示**。Javadoc 明确指出线程优先级的行为依赖平台,不同操作系统的支持程度和表现并不一致。所以既不能指望"高优先级一定先跑",也不能指望"给低优先级线程提权"就能救活被饿的线程。 2. **非公平锁的插队**:`synchronized` 与默认构造的 `ReentrantLock`(`new ReentrantLock()`)都是**非公平**的。当一个线程释放锁时,正在排队等待的线程未必能先拿到锁——刚到的线程可能"插队"先抢到(barging)。如果某个线程不停地"释放后立刻重新获取",队里等待的线程就可能被长期插队。`ReentrantLock` 提供了 `new ReentrantLock(true)` 的公平模式来避免这一点。 3. **大量小任务持续抢占**:生产者以远高于消费的速率持续投递短任务,或一批高频定时任务争抢同一把锁,会让某些线程长期得不到执行机会。 4. **线程池核心线程被占满**:固定大小的线程池里,如果核心线程都被长任务(被挂起、长时间阻塞)占住,后续提交的任务会一直排在队列里执行不了——从"这些任务"的视角看,就是饥饿。 ### Q:公平锁的代价是什么?到底该不该用? A:结论先行——公平锁用"排队 + 更频繁的上下文切换"换取"不会有人被无限插队",因此**吞吐量通常低于非公平锁**,但能改善**尾延迟**、避免饿死。绝大多数场景用默认的非公平锁即可;只有当你确实观察到"长期有人抢不到锁、尾延迟极高"时,才考虑切到公平模式。 为什么非公平通常更快:非公平锁允许"刚被释放的锁被正在运行的线程立刻抢到",这**省掉了一次线程唤醒和上下文切换**(即 park/unpark 与调度开销),所以整体吞吐更高。代价是队首线程可能被插队、等待时间不确定。 什么时候该用公平锁: - 对**排队公平性/等待时间上界**有明确要求(例如需要按提交顺序处理请求); - 已经实测到**饥饿**,且切换公平模式后问题确有缓解。 否则不要为了"看起来更公平"而默认开公平锁——它会实打实地增加上下文切换、降低吞吐。结论:**默认非公平,按需上公平。** ### Q:读写锁(ReentrantReadWriteLock)里也会出现饥饿吗? A:结论先行——会。非公平的读写锁在持续有读请求涌入时,写线程可能长期拿不到写锁,形成**写者饥饿**;公平模式通过排队可以缓解,代价是吞吐下降。 - 非公平读写锁里,读锁之间不互斥。如果读请求源源不断,新来的读线程可能不断"插队"成功,写线程排在后面迟迟等不到"当前没有读者"的那个瞬间。 - `ReentrantReadWriteLock` 提供公平模式(`new ReentrantReadWriteLock(true)`):会按到达顺序排队,避免写者被无限饿死,但会牺牲一部分吞吐。 - 更细的取舍可以看 `StampedLock`:它支持乐观读,写线程的等待通常更可控,但它**不可重入**,使用时要注意不要在持锁期间再次获取锁。 适用/不适用:读多写少、且写不能长期被拖延的场景,应优先考虑公平模式或换用 `StampedLock`;如果写本来就很频繁,读写锁的收益可能抵不过它的复杂度,普通互斥锁反而更简单。 ### Q:给一个可运行的饥饿演示。 A:结论先行——用线程优先级来演示饥饿不稳定、不好复现;用"**固定大小线程池的核心线程被长任务占满**"来演示饥饿最稳定:核心线程全部被占后,后续的小任务只能排队,迟迟不执行。 ```java import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; import java.util.concurrent.TimeUnit; public class StarvationDemo { public static void main(String[] args) throws Exception { ExecutorService pool = Executors.newFixedThreadPool(2); // 只有 2 个核心线程 // 提交 2 个"长任务",把核心线程全部占满 for (int i = 0; i < 2; i++) { int id = i; pool.submit(() -> { System.out.println("长任务 " + id + " 开始,长期占用线程"); try { Thread.sleep(Long.MAX_VALUE); // 模拟长期阻塞/挂起 } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }); } Thread.sleep(200); // 等长任务确实跑起来 // 提交一个很轻的小任务:核心线程已满,它只能排队 Future<String> small = pool.submit(() -> "小任务完成"); Thread.sleep(500); System.out.println("小任务已完成? " + small.isDone()); // 预期 false → 饥饿 // 收尾:强制停机,避免程序不退出 pool.shutdownNow(); pool.awaitTermination(1, TimeUnit.SECONDS); System.out.println("收尾后小任务已完成? " + small.isDone()); } } ``` 关键点/预期行为:`newFixedThreadPool(2)` 只有 2 个核心线程,且用的是无界队列。两个长任务把核心线程占满后,小任务只能进队列等待,`small.isDone()` 在 500ms 后仍为 false——这就是"任务饥饿"。适用/不适用:这个例子说明的是**资源被长期占满导致的饥饿**;`Executors.newFixedThreadPool` 使用无界队列,生产上更推荐直接用 `ThreadPoolExecutor` 明确指定队列容量与拒绝策略,避免任务无限堆积。另外,`Thread.sleep(Long.MAX_VALUE)` 被 interrupt 时会抛异常,所以 `shutdownNow()` 能让长任务退出,程序正常结束。 补充:如果你想观察"锁层面的饥饿",可以写一个持续**非公平**重入锁的线程——它 `unlock()` 后立刻 `lock()`,与一个等待线程竞争;在非公平模式下,等待线程可能长期抢不到锁。由于结果依赖调度时序,这里不给出"必然饿死"的断言,需结合你的 JDK 与运行环境实测确认。 ### Q:线程池层面的饥饿,除了"核心线程被长任务占满"还有哪些形态?怎么根治? A:结论先行——常见形态有三类:核心线程被长任务占满、同一线程池里长短任务混跑、以及队列策略不当导致任务迟迟排不上;根治手段是**隔离 + 边界 + 拒绝策略**。 - **长任务占用核心线程**:如前面的演示,长任务不结束,后续任务永远排队。做法是把长任务与短任务拆到不同线程池,给短任务一个"随时有线程可用"的池子。 - **长短任务混跑**:即使线程总数足够,长任务也会拉高短任务的排队等待;隔离之后,各自的尾延迟更可控。 - **队列策略不当**:用无界队列时,任务会一直堆积却永远不触发扩容(因为达到核心线程数后队列一直不满);用有界队列 + 合理拒绝策略,才能让"过载"及时暴露而不是悄悄排队。 - **核心线程数与队列要一起看**:`ThreadPoolExecutor` 的扩容逻辑是"核心线程满 → 入队 → 队列满 → 扩到最大线程数 → 拒绝",所以队列容量会直接影响"何时开始扩线程",配置时必须一起考虑。 ```text 隔离前: [ 线程池 A ] ← 短任务 + 长任务混跑 → 短任务被长任务拖住 隔离后: [ 线程池-短任务 ] ← 只跑短任务(随时有线程可用) [ 线程池-长任务 ] ← 只跑长任务(互相隔离) ``` 关键点:饥饿往往不是"线程不够",而是"资源被错误地共享"。隔离常常比单纯加线程更有效。适用/不适用:隔离会增加线程总数与管理成本,要结合资源上限与监控;对于彼此无关、耗时相差数量级的任务,隔离收益最明显。 ## 四、与死锁排查的差异 & 生产实践 ### Q:活锁/饥饿和死锁的排查手段有什么不同? A:结论先行——死锁能靠 `jstack` **直接报出来**("Found one Java-level deadlock"),而活锁/饥饿**不会**被报成死锁;它们要靠"多次采样 + CPU 占用 + 线程状态变化 + 业务指标"来推断。 - **死锁**:`jstack <pid>` 通常会直接给出 "Found one Java-level deadlock" 并打印互相等待的线程与锁;`jconsole`/`VisualVM`/`Arthas` 也能看到明显的锁等待环。特征:线程处于 `BLOCKED`/`WAITING`,CPU 往往不高。 - **活锁**:`jstack` 抓到的栈**每次都在变**,且线程多为 `RUNNABLE`;用 `top -Hp <pid>` 看线程 CPU 不低,但业务吞吐接近 0。诊断靠**间隔多次 dump 对比**:栈在动、状态在变,却没有"完成"的痕迹。可以配合日志里"重试/回滚"的高频打印来佐证。 - **饥饿**:特征是**特定任务长期不执行**,而线程池/队列指标异常(队列持续增长、活跃线程数长期打满、拒绝次数上升)。`jstack` 里等待的线程可能一直停在 `WAITING`/`TIMED_WAITING` 或锁等待上,但**没有死锁环**。要靠**线程池监控**(活跃线程数、队列长度、任务平均等待时长、拒绝计数)来定位。 一个实用判断链:**CPU 高 + 吞吐低 + 线程栈在变 → 怀疑活锁;CPU 不高 + 特定任务不执行 + 队列持续增长 → 怀疑饥饿;CPU 不高 + 线程互相等待 + jstack 报死锁 → 死锁。** ### Q:线上遇到"疑似活锁/饥饿",给一条可操作的排查路径。 A:结论先行——先看 CPU 与吞吐的关系,再间隔多次 dump 看线程栈是否在变,最后结合线程池与业务指标定位;不要只抓一次栈就下结论。 1. **看 CPU**:`top -Hp <pid>` 找出占用高的线程。CPU 高但吞吐为 0,偏向活锁;CPU 不高但任务不推进,偏向饥饿或死锁。 2. **间隔多次 dump**:连续抓 2~3 次 `jstack <pid>`(间隔几秒),对比线程栈——栈在同一位置不动,偏死锁/饥饿;栈在不停变化但始终没有"完成"的痕迹,偏活锁。 3. **看线程状态**:大量 `BLOCKED`/`WAITING` 指向锁竞争或死锁;大量 `RUNNABLE` 且 CPU 高,指向活锁或忙等。 4. **看线程池/队列指标**:活跃线程数、队列长度、任务等待时长、拒绝次数;队列持续增长说明消费能力不足或任务被饿死。 5. **看业务日志**:重试/回滚/冲突的高频打印是活锁的强信号;"任务 X 长时间未开始"是饥饿的强信号。 6. **验证假设**:临时加大退避随机性、切公平锁、隔离线程池,观察指标是否改善——这是区分"活锁"与"饥饿"最直接的实验。 关键点:活锁/饥饿的排查靠"**时间维度上的对比**",单次快照往往看不出问题。适用/不适用:这套路径在 Java 进程内适用;排查跨节点的分布式活锁,还需要结合链路追踪与各节点重试日志一起看。 ### Q:生产上有哪些实践建议? A:结论先行——**让重试带上随机和上限、让关键锁带超时、让线程池带边界、让指标可观测**。 - **重试三件套**:随机抖动(jitter)+ 指数退避 + 重试上限;超限后进死信/降级,不要无限重试。 - **用带超时的锁**:用 `tryLock(timeout)` 替代无限等待;对可能长时间持锁的临界区,尽量缩短,避免在锁内做远程调用或 IO。 - **打破对称**:需要多个线程协作写同一资源时,用确定性规则(ID 排序、指定单写者)打破"互相谦让"。 - **线程池边界化**:用 `ThreadPoolExecutor` 显式指定核心/最大线程数、有界队列、拒绝策略;把长任务与短任务隔离到不同线程池,避免短任务被长任务饿死。 - **公平性按需选**:默认用非公平锁;确有饿死/尾延迟问题时再切公平模式,并压测对比吞吐。 - **可观测性**:为线程池暴露"活跃线程数、队列长度、任务等待时长、拒绝数"等指标并设置告警;在关键重试路径上打点,统计重试次数与耗时。 - **排查准备**:保留"间隔多次 jstack + top -Hp"的取证习惯,不要只抓一次就下结论。 ## 小结 - 死锁、活锁、饥饿都表现为"任务完不成",但死锁是**都阻塞、彻底卡死**,活锁是**都在跑、没进展**,饥饿是**特定线程长期抢不到资源**。 - 活锁的本质是**对称的退让/重试**;破解靠**打破对称**:随机退避、优先级/仲裁、重试上限与策略变更。 - 饥饿的常见成因是**不公平的分配**:线程优先级、非公平锁插队、小任务持续抢占、线程池核心线程被占满。 - 公平锁更公平但吞吐更低;默认非公平锁足够,只有出现饥饿/尾延迟时才考虑切公平。 - 死锁能被 `jstack` 直接报出;活锁/饥饿要靠"多次采样 + CPU + 线程池指标"来推断——**CPU 高而吞吐低多怀疑活锁,特定任务不执行多怀疑饥饿**。 ## 思考题 1. 两个线程都遵循"检测到冲突就退避 100ms 再重试"的规则,为什么可能永远冲突?改动哪个参数最有效? 2. 为什么默认的非公平锁吞吐量通常比公平锁高?它在什么情况下会让某个线程饥饿? 3. 某服务的线程池队列持续增长、活跃线程数长期打满,但 `jstack` 里没有任何死锁——你更怀疑是活锁还是饥饿?怎么进一步确认? 4. 以太网的二进制指数退避为什么能缓解活锁?它和"固定时长退避"相比,关键差别在哪?
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入