跳到主要内容
约 9 分钟3 张卡

锁与无锁

锁和无锁算法都是用来协调多个线程访问共享状态的。锁让线程排队,一次只放一个进去修改;无锁算法不让线程等待,而是用 CAS(比较当前值、相同才更新的原子操作)直接尝试更新,失败了就重来。

「无锁一定比锁快」并不成立。锁的代价是等待和调度,无锁的代价是失败重试和缓存争用,哪个更便宜取决于竞争强度和每次计算的成本。做选择时,既要理解两种成本的来源和无锁算法的保证,也要用测量结果来判断,不能只凭直觉。

1. 面试核心​

先记住这几条,再读正文
  • 锁通过互斥保护临界区,等待者依赖持有者释放才能继续。
  • CAS 失败后,线程要重新读取状态、重新计算新值;竞争越强、计算越贵,重试成本越高。卡 · 锁的竞争成本
  • 在执行前提满足时,lock-free 保证系统整体有操作完成,wait-free 还保证每个操作的步数有界。卡 · 无锁算法的进度保证
  • 分片让不同任务更新不同的状态,批处理把多次更新合并执行,两者都能减少共享位置的竞争,但要明确合并和读取的语义。
  • 不同线程更新各自的变量,如果这些变量在同一个缓存行上,仍会因伪共享产生缓存竞争。卡 · 伪共享与缓存行竞争

2. 锁的竞争成本​

锁通过互斥保证同一时刻只有一个线程修改共享状态。被锁保护的那段代码叫临界区,其他线程要等持有者释放锁才能进入。

lock.lock();
try {
updateState();
} finally {
lock.unlock();
}

示例把一次状态变更放在锁内,finally 保证正常返回和抛异常时都会释放锁。

没有竞争时,取锁走的是一条很短的路径,成本很低。竞争持续时,等待者要么自旋(原地反复尝试),要么挂起(暂停执行,等被唤醒),不同的锁实现会组合使用这两种策略。成本主要来自三处:

  • 获取和释放锁本身要执行原子操作,协调多个线程对锁状态的访问。
  • 多个 CPU 核心修改同一份共享状态,需要协调各自缓存里的副本,缓存行在核心之间来回迁移。缓存行是 CPU 缓存传输和维护一致性的基本单位。
  • 等待者排队、挂起再被唤醒,会增加调度和上下文切换的开销。

锁的好处也很明显:一个临界区里可以完成多字段、多步骤的更新,维持业务约束;还能配合条件队列,让线程在资源没就绪时等待,条件满足了再继续。

3. 无锁更新的重试成本​

无锁更新的思路是先算、再提交:用 CAS 检查共享状态在计算期间有没有被别人改过。没改过就提交成功;别的线程先完成了更新,当前线程就丢掉这次的结果,读取新状态重来。

while (true) {
State current = state.get();
State next = current.advance();
if (state.compareAndSet(current, next)) {
return;
}
}

这个循环要求 State 不可变、advance() 没有副作用。这样即使 CAS 失败、next 被丢掉,浪费的也只是一次计算,重新读取后可以安全地再算一次。

成本就藏在这里。竞争越密集,多个线程争同一个缓存行的次数越多,失败的计算也越多。如果 advance() 本身很贵,大量 CPU 时间就会花在最终作废的结果上,线程看起来一直在忙,有效进展却不多。所以衡量无锁算法,要看成功操作的吞吐,同时观察重试次数。

完整的无锁数据结构还有更难的部分:节点什么时候可以移除、回收或复用,其他线程是不是还在访问它。Java 堆上的对象由 GC 负责回收,省掉了手动释放内存的问题,但节点复用仍然要遵守算法的约束。ABA 和更新函数的副作用限制见 CAS。

4. 无锁算法的进度保证​

「无锁」在理论上有精确的含义,它描述的是进度保证:线程持续获得执行机会时,哪些操作一定能完成。从弱到强有三种:

性质保证范围
obstruction-free一个操作独自执行足够久时可以完成
lock-free并发执行中,系统整体持续有操作完成
wait-free每个操作在自身有界步数内完成

上一节的 CAS 循环是典型的 lock-free:某个线程 CAS 失败,一定是因为别的线程成功了,所以系统整体总有进展。但它不保证每个线程都能完成,一个线程可能运气不好、一直失败,也就是饥饿。wait-free 更进一步,限制每个操作自身的步数,单个操作也有完成保证。这里的步数上界,要在算法规定的执行前提下理解,比如底层的原子操作本身能够完成。

这些性质说的是执行步数,不是现实时间的延迟上限。线程长时间得不到调度,即使算法是 wait-free,也要等拿到 CPU 才能继续。

另外,用了 CAS 不等于算法就是 lock-free。单次 CAS 的原子性代替不了完整算法的进度证明:如果循环里还要等锁,或者执行没有完成边界的工作,就得重新分析。

5. 两类方案的常见错误​

选方案时,除了运行成本,还要考虑正确性和审查难度。两类实现需要处理的风险不同:

方案需要处理的风险
锁锁顺序、持锁 I/O、忘记释放、等待超时
无锁算法失败重试、局部饥饿、ABA、重复副作用

锁顺序不一致会导致死锁,持锁做 I/O 会让其他线程跟着一起等。锁还可能造成优先级反转:高优先级线程在等低优先级线程释放锁,而低优先级线程迟迟得不到执行机会。

无锁算法里,反复重试会拖慢单个线程;更新函数如果有外部副作用,失败重试还会让它重复执行。审查无锁结构,需要推导各种线程交错下的状态变化,这比审查一段临界区难得多。

所以业务需要同时更新多个字段时,一个短临界区更容易表达和审查一致性约束。需要复杂的并发结构时,优先用 JUC 里成熟的组件,不要自己重新实现无锁链表这类底层算法。

6. 降低竞争的方法​

与其在锁和 CAS 之间纠结,不如先减少共享:线程争用同一份状态的次数少了,两种方案都会变快。常用的做法有:

  • 把一个计数器拆成多个单元,各自累加、定期汇总,比如 LongAdder。
  • 按 key 分配状态的所有权,同一份数据固定由一个线程或任务修改。
  • 批量合并更新再提交,让多次业务操作共用一次同步。
  • 发布不可变快照,读者直接读快照,不和写者争锁。
  • 用成熟的并发容器管理单项操作,复用它们已经实现好的并发算法。

这些方法仍然要满足业务的一致性要求。比如分片统计需要汇总多个单元,读取方要能接受汇总过程中各单元还在变化;业务要求某一时刻的精确总量时,就需要更强的协调。

7. 伪共享与缓存行竞争​

把变量分给不同线程之后,还要看它们在内存里是不是挨着。CPU 以缓存行为单位协调写入,两个毫不相关的变量如果落在同一个缓存行上,一个核心写了其中一个,其他核心就得重新取得这个缓存行的数据或写权限,另一个变量也跟着受影响。

这种业务上没有共享、缓存层面却互相争用的现象,叫伪共享。它会让本来独立的更新也产生缓存竞争,抵消掉分片带来的收益。

解决办法是填充:在热点数据周围留出额外的空间,把各个单元隔开,降低它们落进同一个缓存行的概率。OpenJDK 21 的 Striped64.Cell(LongAdder 的累加单元)就用 @Contended 做了填充,代价是每个对象占用更多内存。

JMH 的 FalseSharing 示例对比了相邻字段和填充方案。实际的内存布局和处理器有关,所以收益要在目标机器和实际的对象布局下测量。

8. 竞争曲线基准​

同一种算法在低竞争和高竞争下表现可能完全不同,所以比较的不是一个数字,而是性能随竞争强度变化的曲线。线程数至少要覆盖 1、2、CPU 核心数和超额订阅。超额订阅是指可运行线程数超过可用核心数,线程要轮流使用 CPU。

设计基准时,要改变负载条件,并记录能解释结果的指标:

  • 改变读写比例和临界区长度,比较不同计算量下的表现。
  • 分别使用均匀 key 和热点 key,观察集中争用的影响。
  • 记录成功操作的吞吐和 p95/p99 延迟,不要把失败重试当成业务进展。
  • 记录 CAS 失败数、锁等待和 park 时长,解释时间花在了哪里。
  • 对照 CPU、上下文切换和对象分配率,检查重试或阻塞带来的额外成本。

JMH 是 JVM 上的微基准测试工具,用来测量局部代码的性能;JFR 和 async-profiler 是运行时分析工具,用来解释测出来的结果。只测单线程,只能看到无竞争时的开销,回答不了并发度提高后能不能扩展。具体采集方法见 锁竞争。

9. 常见问题​

9.1 自旋适合很短的临界区吗?​

只有在预计等待很短、竞争可控、CPU 又有富余时,自旋才值得考虑。如果持有者被调度出去了,等待者再怎么自旋也不能让它早一点释放锁,只是白白消耗 CPU。

所以还要看可运行线程是不是严重超过核心数。业务同步优先使用 JVM 和 JUC 现有的机制,自旋多久再挂起这类细节交给成熟实现处理。

9.2 公平锁会更快吗?​

10. 面试题卡片​

11. 参考资料​

来源:Coding 101 原文 · 免费阅读,引用请保留出处。内容使用说明