知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 无锁编程与并发设计模式 > 导读:本文从"听说无锁比加锁快,于是想把锁都去掉"这个常见冲动出发,把无锁(lock-free)与无等待(wait-free)的概念边界、CAS 循环与 ABA 问题、无锁栈与无锁队列的结构要点,以及七种经典并发设计模式(保护性暂挂、放弃、不可变对象、线程封闭、生产者消费者、读写锁、两阶段终止)逐项讲透,最后给出"什么时候该用无锁、什么时候老老实实用锁"的取舍原则。适合会写 `synchronized`、想建立并发设计判断力的 Java 后端同学。 ## 一、先建立全局认知 ### Q:阻塞(blocking)、无锁(lock-free)、无等待(wait-free)到底怎么区分? A:结论先行——它们描述的是**"当多个线程争抢同一份共享状态时,进度如何被保证"**:阻塞策略下,抢不到的一方可能被挂起等待;无锁策略保证**整个系统**总有线程能取得进展;无等待策略进一步保证**每个线程**都能在有限步内完成。此外还有一个更弱的概念:无障碍(obstruction-free)。 先给术语定义(这一组术语常被混用,务必分清): - **阻塞(blocking)**:线程拿不到锁就被挂起,直到锁可用。进度取决于持有者何时释放。 - **无障碍(obstruction-free)**:只要某线程**独占执行**(其他线程都暂停),它就能在有限步内完成。 - **无锁(lock-free)**:系统层面**至少有线程**能持续取得进展(不会出现全体卡死);但**单个线程可能被"饿死"**——反复重试、始终失败。 - **无等待(wait-free)**:**每个线程**都能在有界步骤内完成,天然没有饥饿。 用一张对比表理清: | 特性 | 阻塞 | 无障碍 | 无锁 | 无等待 | | --- | --- | --- | --- | --- | | 是否挂起线程 | 会 | 不会 | 不会 | 不会 | | 系统级进度保证 | 取决于锁 | 无 | 有 | 有 | | 单线程进度保证 | 无 | 无(需独占) | 无 | 有 | | 是否存在饥饿 | 可能有 | 可能有 | 可能有 | 无 | | 实现难度 | 低 | 中 | 高 | 很高 | **为什么这个区分重要?** 因为它决定了你能否宣称"我的方案不会死锁/不会卡住"。CAS 循环是典型的无锁但**非**无等待:某个线程可能一直重试失败。所以"无锁"≠"没有等待",只是"没有整体卡死"。 ### Q:无锁一定比加锁快吗? A:结论先行——**不一定**。无锁的优势主要在"低竞争、临界区极短"时才明显;高竞争下 CAS 自旋会造成大量无效重试和缓存一致性流量,反而可能比加锁更慢。"无锁更快"是一个需要条件成立的结论,不是普适规律。 为什么高竞争下会变慢?因为 CAS 失败意味着这次尝试白做,且失败往往伴随缓存行在多个 CPU 核之间来回同步(缓存一致性协议开销)。竞争越激烈,失败率越高,无效工作量越大。而锁在高竞争下会让拿不到锁的线程**挂起**(不再消耗 CPU),有时反而是更好的选择。 **正确心态**:把无锁当成一种**在特定条件下消除阻塞和死锁的取舍**,而不是一种"性能银弹"。绝大多数业务代码应该优先使用 `java.util.concurrent`(JUC)提供的、经过充分验证的并发结构,而不是自己手写无锁算法。 ### Q:无锁和"乐观/悲观"是什么关系? A:结论先行——无锁通常建立在**乐观策略**之上:先假设没人跟我抢,把改动算好,再用 CAS 一次性验证"期间没人改过",成功则生效、失败则重试。加锁则更接近**悲观策略**:先拿到独占权,再动手。  *图:无锁编程与并发设计模式:悲观加锁 vs 乐观 CAS* ```text 悲观(加锁): 抢占锁 ──> 独占临界区执行 ──> 释放锁 “先假设会冲突” 乐观(CAS 循环): 读取当前值 ──> 计算新值 ──> CAS 尝试提交 ▲ │失败则重试 └──────────────────────────┘ “先假设不冲突,冲突了再重来” ``` 需要补充:乐观/悲观是**策略**,无锁是**进度保证属性**,两者不是同一个维度。你可以用乐观策略配合锁(如 `StampedLock` 的乐观读),也可以写一个无锁算法但内部仍用忙等。理解这一点,能避免把不同层次的概念混为一谈。 ## 二、理解 CAS 核心机制 ### Q:CAS 是什么?无锁的"读—改—写"循环怎么写? A:结论先行——CAS(Compare-And-Swap,比较并交换)是一条原子指令语义:**"如果当前值等于我期望的旧值,就把它设为新值,并告诉我是否成功"**。无锁更新就是把"读旧值 → 算新值 → CAS 提交"做成一个循环,CAS 失败就重新读取再试。 ```text CAS 语义(以 int 为例): compareAndSet(expect, update): if (当前值 == expect) { 当前值 = update; return true; } else { return false; } // 什么都不做 以上判断与赋值是一个不可分割的原子操作 ``` 在 Java 中,最常用的入口是原子类: ```java import java.util.concurrent.atomic.AtomicInteger; // 目标:演示 CAS 循环——手写一个“有限次重试的自增” public class CasLoop { private final AtomicInteger value = new AtomicInteger(0); // 等价于 value.incrementAndGet() 的语义,用于说明 CAS 循环结构 public int increment() { while (true) { int old = value.get(); // 1. 读取当前值 int next = old + 1; // 2. 计算期望的新值 if (value.compareAndSet(old, next)) { // 3. 尝试原子提交 return next; // 成功:返回 } // 失败:说明期间有别人改过,回到步骤 1 重试 } } public static void main(String[] args) { CasLoop c = new CasLoop(); System.out.println(c.increment()); // 预期输出 1 } } ``` 关键点与预期行为: - `AtomicInteger.compareAndSet(expect, update)` 返回 `boolean`:成功 `true`,失败 `false`。 - 失败**不是错误**,是"竞争发生了"的正常信号,重试即可。 - 实际开发中应直接用 `value.incrementAndGet()` 这类内置方法(内部就是 CAS 循环),不要重复造轮子。 **为什么能保证无锁**:即使某个线程反复失败,**系统里总有一个线程能成功提交**,不会全体卡死。 **适用与不适用**:适合单个变量、状态转换简单的场景(计数器、状态标志、单指针更新);不适合需要同时保证多个变量一致性的场景(见后文代价一节)。 ### Q:什么是 ABA 问题? A:结论先行——ABA 问题是 CAS 的一个经典缺陷:某线程读到值 `A`,准备 CAS 时,值在它背后经历了 `A → B → A` 的变化又变回了 `A`;由于 CAS 只比较"值是否相等",它无法察觉这个中间过程,会错误地认为"没人改过"。解决办法是给值**附加一个版本号或标记**。 在 Java 里,因为对象由 GC 管理,不会出现 C/C++ 那种"内存被释放后重新分配、地址值复用"的指针 ABA;但**逻辑上的 ABA 依然会发生**(值或引用绕了一圈又回到原样)。 ```java import java.util.concurrent.atomic.AtomicStampedReference; // 目标:用“值 + 版本戳”检测 ABA public class AbaDemo { public static void main(String[] args) { AtomicStampedReference<String> ref = new AtomicStampedReference<>("A", 0); int[] stamp = new int[1]; String cur = ref.get(stamp); // cur = "A", stamp[0] = 0 // 期间别人把 A->B->A 改了一圈,但版本戳会变化 ref.compareAndSet("A", "B", 0, 1); ref.compareAndSet("B", "A", 1, 2); // 用旧版本戳 0 去提交,会失败——正确识别出“中间被改过” boolean ok = ref.compareAndSet(cur, "C", 0, 3); System.out.println("cas=" + ok + ", now=" + ref.getReference()); // 预期输出:cas=false, now=A } } ``` 关键点: - `AtomicStampedReference.get(int[] stampHolder)` 同时取出引用和版本戳;`compareAndSet` 需要**同时匹配引用和版本戳**。 - 如果只关心"有没有被改过"而不需要计数版本,可以用 `AtomicMarkableReference`(带一个 `boolean` 标记)。 - **使用边界**:加版本戳能解决检测问题,但每次 CAS 都要多比对一份状态;且并不是所有 ABA 都有害——如果值回到 `A` 在业务上就等价于"没变过",那可以不管 ABA。是否处理,要结合语义判断。 ### Q:CAS 的代价有哪些? A:结论先行——主要有三条代价:**自旋开销(高竞争下批量无效重试)、只能保证单个变量/单个内存位置的原子性、以及算法复杂度和正确性验证成本高**。 **代价一:自旋开销。** CAS 失败要重试。竞争越激烈,重试越多,CPU 空转越多;而且重试会加剧缓存行争用,形成"越忙越慢"的负反馈。 **代价二:单变量原子性。** CAS 一次只能原子更新**一个**内存位置。如果你有两个字段需要"要么都改、要么都不改",单纯 CAS 做不到。常见绕过办法是把多个字段**打包成一个不可变对象**,用 `AtomicReference` 对"整个对象引用"做一次 CAS——这样"多字段一致性"就被转成"单引用原子性"。示例: ```java import java.util.concurrent.atomic.AtomicReference; // 目标:用“不可变快照 + 单次 CAS”维护一对必须一致的坐标 public class Point { private record Pos(int x, int y) {} // 不可变 private final AtomicReference<Pos> pos = new AtomicReference<>(new Pos(0, 0)); // 把 (x,y) 一起改成 (newX,newY),二者必须同时生效 public void move(int newX, int newY) { while (true) { Pos old = pos.get(); if (pos.compareAndSet(old, new Pos(newX, newY))) { return; // 成功:两个字段一起换掉 } } } public Pos current() { return pos.get(); } } ``` 关键点:`record` 天然不可变,替换引用即替换整个状态;读取方永远看到"一致的 (x,y)",不会看到半个更新。 **代价三:复杂性与验证成本。** 无锁算法很难写对、更难测对(要覆盖各种交织)。**因此除非有明确收益,否则优先复用 JUC 里已验证的实现。** ## 三、两种典型无锁数据结构 ### Q:无锁栈(Treiber stack)是怎么实现的? A:结论先行——Treiber 栈(Treiber stack)用一个 `AtomicReference` 指向栈顶,入栈/出栈都是"读栈顶 → 构造新链 → CAS 换栈顶",失败就重试。它是理解无锁最经典的入门结构。 ```java import java.util.concurrent.atomic.AtomicReference; // 目标:无锁栈(Treiber stack) public class TreiberStack<E> { private static final class Node<E> { final E item; Node<E> next; // 注意:非 final,入栈时可复用节点 Node(E item, Node<E> next) { this.item = item; this.next = next; } } private final AtomicReference<Node<E>> top = new AtomicReference<>(); public void push(E item) { Node<E> newHead = new Node<>(item, null); Node<E> oldHead; do { oldHead = top.get(); // 读当前栈顶 newHead.next = oldHead; // 新节点指向旧栈顶 } while (!top.compareAndSet(oldHead, newHead)); // 尝试替换栈顶 } public E pop() { Node<E> oldHead, newHead; do { oldHead = top.get(); if (oldHead == null) return null; // 空栈 newHead = oldHead.next; // 新栈顶 = 旧栈顶的下一个 } while (!top.compareAndSet(oldHead, newHead)); return oldHead.item; } } ``` 关键点: - 只有 `top` 一个共享变量需要原子更新,这就是它能用一次 CAS 搞定的原因。 - CAS 失败说明"读到的栈顶已过期",重试即可。 - **适用**:单指针更新的简单结构(栈、单链表头插)。 - **不适用**:`pop()` 若 `oldHead.next` 被并发修改会有 ABA 风险;真实的 `ConcurrentStack` 类实现会更复杂(需要处理 ABA 与内存回收,Java 里主要靠 GC 兜底)。**生产上不要直接用上面这个简化版原样上阵,优先用 JUC 提供的结构。** ### Q:Michael-Scott 队列的关键点是什么? A:结论先行——Michael-Scott 队列(Michael-Scott queue)是经典的无锁 FIFO 队列算法,核心技巧是:**用一个"哑结点(dummy node)"让 `head` 和 `tail` 永不指向同一个真实数据节点**,并用"**帮助(helping)**"策略让线程顺手把落后的 `tail` 推进,从而避免一个慢线程把整个队列卡住。 结构要点(伪代码,不必完整实现):  *图:无锁队列结构及入队、出队的两步 CAS* ```text 队列结构: head ──> [dummy] ──> [data1] ──> [data2] <── tail (head 指向哑结点,tail 指向最后一个节点或倒数第二个) 入队 enqueue(newNode): loop: tail = this.tail # 读尾 next = tail.next # 读尾的后继 if tail != this.tail: continue # 尾被别人改过,重读 if next == null: # 尾确实在链尾 if CAS(tail.next, null, newNode): # 第一步:挂上新节点 break else: CAS(this.tail, tail, next) # 帮助:把落后的 tail 推到 next CAS(this.tail, tail, newNode) # 第二步:把 tail 推到新节点(失败也没关系,别人会帮) 出队 dequeue(): loop: head = this.head tail = this.tail next = head.next if head != this.head: continue # head 被别人改过,重读 if next == null: return null # 空队列 if head == tail: # tail 落后,先帮忙推进 CAS(this.tail, tail, next) else: value = next.item if CAS(this.head, head, next): # 把 head 推到 next(相当于出队) head.next = null # 便于 GC 回收旧节点(可选) return value ``` 关键点: - **哑结点**让"空队列"和"只有一个元素"的判断统一,简化边界。 - **两段式 CAS + helping**:先挂节点、再推进 `tail`;即使推进 `tail` 失败,其他线程也会帮忙推进,因此不会有线程因为别人停顿而永久卡住。 - **适用**:需要高频、无阻塞的 FIFO 场景;JDK 的 `ConcurrentLinkedQueue` 就属于这一族算法(实现细节与上面伪代码不完全相同)。 - **不适用/注意**:算法细节极易写错,**不要在业务里手写**,直接用 `ConcurrentLinkedQueue` 等 JUC 实现。 ## 四、七种经典并发设计模式 ### Q:Guarded Suspension(保护性暂挂)是什么? A:结论先行——当某个**前置条件(guard)不满足**时,让线程**等待**,直到条件成立再继续;它把"条件不满足"从"抛异常/返回失败"变成"挂起等待",是 `wait/notify` 最典型的使用范式。Java 内置的 `BlockingQueue.take()` 就是它的工业化实现。 ```java import java.util.LinkedList; import java.util.Queue; // 目标:手写一个“有数据才取”的队列,演示保护性暂挂 public class GuardedQueue<E> { private final Queue<E> queue = new LinkedList<>(); public synchronized E take() throws InterruptedException { while (queue.isEmpty()) { // 关键:用 while 而非 if wait(); // 条件不满足 → 暂挂 } return queue.poll(); } public synchronized void put(E item) { queue.add(item); notifyAll(); // 条件可能成立 → 唤醒等待者 } } ``` 关键点: - 必须用 **`while` 而不是 `if`**:一方面防止**虚假唤醒(spurious wakeup)**,另一方面唤醒后条件可能又被其他线程改变,需要重新检查。 - 修改共享状态、检查条件、`wait/notify` 都必须在**同一把锁**内。 - **适用**:生产者消费者、等待某个资源就绪。 - **不适用**:无界等待会导致线程长期挂起;生产上优先用 `BlockingQueue` 的 `take()`/`poll(timeout)`,它们处理了超时与中断。 ### Q:Balking(放弃)是什么? A:结论先行——Balking 指:**如果当前状态不适合执行,就干脆放弃本次操作直接返回**,而不是像保护性暂挂那样等待。典型场景是"已经在做了就别重复做"。 ```java import java.util.concurrent.atomic.AtomicBoolean; // 目标:自动保存——若已有一次保存在进行,则本次直接放弃 public class AutoSaver { private final AtomicBoolean saving = new AtomicBoolean(false); public boolean save(String data) { if (!saving.compareAndSet(false, true)) { return false; // 状态不适合 → 直接放弃(balk) } try { doSave(data); return true; } finally { saving.set(false); // 务必复位,否则再也保存不了 } } private void doSave(String data) { /* 实际写盘 */ } } ``` 关键点: - "放弃"是有意为之的语义,调用方应能接受"本次没做"。 - `finally` 里复位标志非常关键,否则会永久卡在"正在保存"状态。 - **适用**:去重、幂等触发、防抖、单飞(single-flight)场景。 - **不适用**:调用方期望"一定要完成"的任务——那种应该排队或等待。 ### Q:Immutable Object(不可变对象)是什么? A:结论先行——不可变对象指**创建后状态永不改变**的对象。它的并发价值在于:**不可变对象天然线程安全**,可以被多线程自由共享而无需加锁;而且只要正确发布,不存在"看到半个更新"的问题。 实现要点: ```java import java.util.List; // 目标:不可变对象——所有字段 final、不提供修改方法、防御性拷贝 public final class Config { // 类 final,禁止子类改变语义 private final int limit; // 字段 final private final List<String> tags; public Config(int limit, List<String> tags) { this.limit = limit; this.tags = List.copyOf(tags); // 防御性拷贝 + 不可变视图 } public int limit() { return limit; } public List<String> tags() { return tags; } // 返回的集合本身不可修改 } ``` 关键点: - 类与字段用 `final`,不提供 setter;构造完成后状态不再变化。 - 对可变入参做**防御性拷贝**(如 `List.copyOf`),避免外部持有引用后偷偷改。 - `record`(JDK 16 起正式)是表达不可变数据的简洁方式。 - **注意**:`final` 字段带来**初始化安全性(initialization safety)**,但仍需保证对象被**安全发布**(例如通过 `volatile`、`static` 初始化器或并发容器),否则别的线程可能拿到"看起来是 null 的半成品"引用。 - **适用**:配置、值对象、并发共享的数据快照。 - **不适用**:需要高频原地修改的累积状态——那样应使用可变对象配锁,或"不可变快照 + CAS 替换引用"。 ### Q:Thread Confinement(线程封闭)是什么? A:结论先行——线程封闭指把某份数据**只暴露给单个线程访问**,从根上避免共享,于是无需加锁。两种常见形态:**栈封闭(stack confinement)**和 **ThreadLocal 封闭**。 **栈封闭**:数据只作为局部变量存在于某个方法栈上,天然不被其他线程看到。 ```java // 目标:栈封闭——collection 是局部变量,仅当前线程可见 public int sumSizes() { var local = new java.util.ArrayList<String>(); // 仅本线程可访问 local.add("a"); local.add("b"); return local.size(); } ``` **ThreadLocal 封闭**:每个线程各自持有一份副本,互不干扰。 ```java // 目标:ThreadLocal 封闭——每线程一个独立计数器 public class PerThreadCounter { private static final ThreadLocal<int[]> COUNT = ThreadLocal.withInitial(() -> new int[1]); public void inc() { COUNT.get()[0]++; } public int get() { return COUNT.get()[0]; } public void clear() { COUNT.remove(); } // 用完清理,避免残留 } ``` 关键点与注意: - 栈封闭最安全,优先考虑。 - `ThreadLocal` 封闭在**线程池**环境下必须记得 `remove()`,否则上一次任务的状态会残留到下一次任务。 - **版本提示**:在虚拟线程(Virtual Thread)大量使用的场景下,`ThreadLocal` 的规模与"线程复用"假设都会变化,应改用**作用域值(ScopedValue)**承载请求上下文;相关 API 的成熟度与形态**需结合所用 JDK 版本确认**。 - **适用**:非线程安全对象(如 `SimpleDateFormat` 旧代码、JDBC 连接上下文)的隔离使用。 - **不适用**:需要跨线程共享的可变状态——那是封闭解决不了的。 ### Q:Producer-Consumer(生产者消费者)是什么? A:结论先行——生产者和消费者通过一个**共享缓冲区**解耦:生产者放入数据,消费者取出数据,双方通过缓冲区的**阻塞语义**协调节奏。它同时解决了"速度不匹配"和"解耦"两个问题。 ```java import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.BlockingQueue; // 目标:用有界阻塞队列实现生产者消费者 public class Pipeline { public static void main(String[] args) throws InterruptedException { BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(16); // 有界! Thread producer = new Thread(() -> { try { for (int i = 1; i <= 100; i++) { queue.put(i); // 队列满 → 阻塞(背压) } } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }); Thread consumer = new Thread(() -> { try { while (true) { Integer v = queue.take(); // 队列空 → 阻塞 if (v == 100) break; } } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }); producer.start(); consumer.start(); producer.join(); consumer.join(); } } ``` 关键点: - **一定要用有界队列**:无界队列会在生产快于消费时无限堆积,最终 OOM;有界队列会通过 `put` 阻塞形成**天然的背压(backpressure)**。 - `put`/`take` 都可响应中断,正确处理 `InterruptedException` 是必须的。 - 生产上优先用 `BlockingQueue` 家族(`ArrayBlockingQueue`、`LinkedBlockingQueue` 等)而不是手写 `wait/notify`。 - **适用**:任务流水线、异步解耦、削峰填谷。 - **不适用**:对顺序与分区严格一致性有要求的场景(多消费者会打乱顺序),需要额外设计。 ### Q:Read-Write Lock(读写锁)是什么? A:结论先行——读写锁把访问分成"读"和"写"两类:**读锁可被多个线程同时持有,写锁独占**(读与写、写与写互斥)。它适合**读多写少**的场景,让并发读不被彼此阻塞。 ```java import java.util.HashMap; import java.util.Map; import java.util.concurrent.locks.ReentrantReadWriteLock; // 目标:读多写少场景——读并发,写独占 public class ReadMostlyCache<K, V> { private final Map<K, V> map = new HashMap<>(); private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); private final ReentrantReadWriteLock.ReadLock readLock = lock.readLock(); private final ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock(); public V get(K key) { readLock.lock(); // 多个读可并发进入 try { return map.get(key); } finally { readLock.unlock(); // 必须 finally 释放 } } public void put(K key, V value) { writeLock.lock(); // 写独占 try { map.put(key, value); } finally { writeLock.unlock(); } } } ``` 关键点与注意: - 读锁之间不互斥,写锁与任何锁互斥,因此"读多写少"时吞吐更好。 - **不要在持有写锁时去申请读锁以外的东西再回头申请写锁**,容易形成死锁;`ReentrantReadWriteLock` 支持写锁降级为读锁(先持有写锁,再申请读锁,再释放写锁),但**不支持读锁升级为写锁**。 - 高竞争写入时,读写锁的复杂度开销可能不划算,此时普通 `synchronized` 或 `ReentrantLock` 更简单可靠。 - **适用**:缓存、配置读取、读远多于写的共享结构。 - **不适用**:写操作频繁的场景(写锁会不断阻塞所有读)。 ### Q:Two-Phase Termination(两阶段终止)是什么? A:结论先行——两阶段终止把"优雅停止一个线程"拆成两阶段:**第一阶段发出"请停止"信号(设置标志 + 中断),第二阶段等待线程自己走到安全点、清理资源后结束**。它是替代不安全的 `Thread.stop()` 的正确做法。 ```java // 目标:两阶段终止——先请求,再等待 public class Worker extends Thread { private volatile boolean shutdownRequested = false; // 阶段一:收到终止请求 public void shutdown() { shutdownRequested = true; interrupt(); // 唤醒可能正阻塞在该线程上的代码 } @Override public void run() { try { while (!shutdownRequested) { // 检查标志 doWork(); // 可中断的工作 } } catch (InterruptedException e) { // 被中断 → 退出循环 } finally { cleanup(); // 阶段二:清理资源 } // 线程自然结束 } private void doWork() throws InterruptedException { Thread.sleep(10); } private void cleanup() { /* 释放资源 */ } } ``` 关键点: - `volatile` 保证 `shutdownRequested` 对工作线程**可见**。 - 仅设标志不够:若线程正阻塞在 `sleep`/`wait`/IO 上,需要 `interrupt()` 把它唤醒。 - 捕获 `InterruptedException` 后**要退出循环**,或在无法退出时重新设置中断标志(`Thread.currentThread().interrupt()`)。 - 外界应通过 `join(timeout)` 等待线程真正结束,确认"第二阶段"完成。 - **适用**:需要优雅停机、释放资源、避免状态损坏的常驻线程。 - **不适用**:无状态、可随时硬杀的纯计算线程——此时直接 `shutdownNow` 也无妨。 ## 五、取舍原则 ### Q:什么时候该用无锁,什么时候老老实实用锁? A:结论先行——**默认用锁(或 JUC 现成结构),只在"共享状态简单、竞争不激烈、且有明确收益"时才考虑无锁,且几乎总是使用 JUC 提供的实现而不是手写。** 优先用锁(或 JUC): - 临界区里要维护**多个变量的不变式**(如"余额 + 流水"必须一致)。 - 需要**条件等待**(等某个条件成立才继续)——这是 CAS 循环难以优雅表达的。 - 临界区较长或包含 IO——无锁自旋会烧 CPU,锁的挂起反而更合适。 - 高竞争场景——CAS 重试会放大无效工作。 - 你需要的是"**正确且好维护**",而不是极致性能。 可以考虑无锁(优先用现成实现): - 状态是**单个变量或单个引用**(计数器、状态标志、指针更新)。 - 竞争**低**,临界区**极短**,加锁的挂起/唤醒开销显得突出。 - 需要避免**死锁 / 锁护送(lock convoy)/ 优先级反转**等阻塞问题。 - 已经有经过验证的无锁结构可用:`AtomicInteger`、`AtomicLong`、`AtomicReference`、`LongAdder`(高并发计数)、`ConcurrentLinkedQueue`、`ConcurrentHashMap` 等。 几条实用建议: 1. **先正确,再快。** 先用锁写出正确版本,压测确认真的是瓶颈,再评估无锁。 2. **优先复用 JUC。** 手写无锁算法极难验证,容易在罕见交织下出错。 3. **能不可变就不共享,能封闭就不加锁。** 不可变对象与线程封闭往往比"无锁"更简单也更安全。 4. **警惕虚假的"无锁更快"。** 无锁是有条件的取舍,不是普适优化。 ## 小结 - 进度保证从弱到强:阻塞 → 无障碍 → 无锁 → 无等待;**无锁不等于无等待**,单个线程仍可能饥饿。 - 无锁建立在乐观策略上:读 → 算 → CAS 提交,失败重试;CAS 有自旋开销、只保证单变量原子性、且实现复杂。 - ABA 问题用"值 + 版本戳/标记"解决(`AtomicStampedReference`/`AtomicMarkableReference`);多字段一致性可用"不可变快照 + 单引用 CAS"。 - 无锁栈(Treiber)靠单指针 CAS;无锁队列(Michael-Scott)靠哑结点 + 帮助推进;生产上优先用 JUC 实现。 - 七种并发设计模式各有适用面:保护性暂挂(等条件)、放弃(不合适就不做)、不可变对象(免锁共享)、线程封闭(不共享)、生产者消费者(解耦 + 背压)、读写锁(读多写少)、两阶段终止(优雅停机)。 - 取舍:**默认用锁与 JUC**,只在状态简单、低竞争、有收益时才考虑无锁。 ## 思考题 1. 为什么 CAS 循环是"无锁"却不是"无等待"?请举一个线程可能长期失败的场景。 2. ABA 问题在 Java 里(有 GC)和 C/C++ 里的表现形式有何不同?为什么 Java 仍要处理它? 3. "用不可变对象替换可变共享状态"为什么能免掉锁?它和"不可变快照 + CAS"是什么关系? 4. 生产者消费者里,为什么强调**有界**队列?无界队列在生产快于消费时会发生什么? 5. 两阶段终止里,只设置 `volatile` 标志、不调用 `interrupt()`,在什么情况下会失效?为什么? 6. 你手上有一段"读多写少"的缓存代码,是选读写锁、`ConcurrentHashMap`、还是无锁快照?请说明权衡依据。
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入