来源书籍

Java高并发核心编程.卷2,多线程、锁、JMM、JUC、高并发设计模式

Skill 版本:v23 编程语言类 经典原理(高信息浓度 + 高稳定性) 191 张卡片

尼恩 · 机械工业出版社(纸版);华章分社(电子版) · 2021 · ISBN 978-7-111-67988-2

类别清单覆盖

尚未完成类别清单核对。

全书导读

并发程序让多个执行任务在时间上重叠。它能改善吞吐或资源利用,但任务之间共享数据、等待结果和争用资源时,必须明确谁能修改什么、哪些动作不可分割、结果何时对其他线程可见。本书从Java线程出发,把这些约束连接到锁、原子操作、内存模型、并发容器和异步编排。

阅读时应区分三层:Java语言与API给出的契约、特定JDK实现这些契约的内部机制、演示程序在一次调度中的观察。底层代码与锁优化具有版本边界,例子也不能代替一般正确性证明。以下逐项讲解沿本地EPUB的325个正文spine项组织,保留历史覆盖与卡片已核验的勘误;小节编号及标题沿原书,页面位置用稳定section ID定位。

全书主线

第1章先认识线程、生命周期、线程池和线程局部存储,说明执行单元怎样创建、安排和结束。第2–4章转向共享状态:复合操作可能产生竞态,互斥锁和CAS处理不同的原子性问题,Java内存模型进一步约束跨线程可见性和顺序;“单个动作不可分割”并不自动意味着整个协议正确。

第5–7章展示工具如何实现和封装这些约束。显式锁提供可中断、超时、公平性、读写等选择;AQS把状态获取、排队、阻塞和唤醒组织成同步器骨架;并发容器则为具体数据结构提供不同范围的一致性和性能边界。不能把容器线程安全推广为任意多步业务操作都原子。

第8–10章把注意力转向任务协作。Master-Worker和ForkJoin拆分工作,Future表达未来结果,回调把后续动作交给完成通知,CompletableFuture再把依赖关系表示为阶段图。此时关键不仅是拿到结果,还包括执行器归属、阻塞传播、失败和取消如何经过链路,以及组合之后到底等待哪些任务。

前言

本卷讨论的是多个任务同时推进时,Java 程序怎样安排执行、保护共享数据并协调结果。全书先建立线程和线程池基础,再解释内置锁、CAS、内存可见性,最后进入 JUC 工具及异步协作。前言还说明适用读者、随书资料和章节安排,作用是建立阅读范围;其中只是提名技术主题,没有进一步展开可独立保留的新机制,因此不另设知识卡。

自序

作者把阅读技术书籍视为提高 Java 能力的一条经济途径,并结合个人工作经验解释为什么要系统学习底层机制。自序同时交代本卷与系列其他卷册的关系。这些意见可以作为作者的学习背景理解,文中没有把经验验证成普遍学习规律,故保留其读者导引作用,不另生成方法卡。

第1章 多线程原理与实战

多线程原理这一章从面试中的疑问打开问题:会调用线程 API,是否就能解释共享数据为何出错?本项只有章标题与故事引语,具体的执行单位、任务入口、调度和资源管理都在后续小节展开;没有新的技术论证,因而不另生卡。

1.1 两个技术面试故事

两个面试故事把“自增是否线程安全”与“为什么需要多线程”变成需要实际解释的问题。作者建议用多个线程累加同一变量,观察预期总数能否保留;故事在这里提出实验要求,并没有完成安全性证明。自增的读改写竞态在第 2 章说明,多线程的资源与调度意义则由紧接着的进程、线程讨论承接;本项不重复成卡。

1.2 无处不在的进程和线程

程序是保存在磁盘上的代码和数据;进程是程序装入内存、取得必要资源后的一次运行。同一程序能够多次启动,因此程序文件与运行实例并非一一对应。把进程认作运行实例,才能继续区分操作系统分配资源的对象,以及在这些资源中实际推进指令的线程。

原书依据 · 1 处

1.2.1 进程的基本原理

操作系统必须记住一次执行停在哪里,才能在切换后接着运行。进程的代码段保存指令,数据段保存操作数据,进程控制块 PCB 保存身份、调度、资源与执行上下文信息;切换时保存寄存器等状态,恢复时取回这些信息。Java 命令启动 JVM 是进程实例的例子,但不能由此推出 main 方法结束就必然退出 JVM,还要看用户线程的存活情况。

原书依据 · 1 处

1.2.2 线程的基本原理

线程是进程内部的一条执行流程,也是这里讨论的 CPU 调度粒度;进程仍承担资源归属。同一进程的线程共享堆及系统资源,因此能够直接访问共同数据,也会产生并发修改冲突。线程又各有自己的栈:方法调用进入时压入栈帧,退出时弹出,栈帧保存该次调用的局部变量、返回位置等执行信息。共享对象与私有调用状态必须分别理解。

原书依据 · 2 处

1.2.3 进程与线程的区别

进程与线程的差别可沿两条线观察:谁拥有资源,谁获得执行机会。不同进程通常有各自的内存与资源空间;同一进程里的线程共享这些资源,却分别保有执行上下文。共享使协作方便,也要求额外同步。这里归纳的是前面的定义,已由线程基础卡承接,不另设重复卡;切换成本取决于实际平台,不能把定性比较当成任何环境下的性能保证。

1.3 创建线程的4种方法

Thread 对象用来描述和操作一个 Java 线程,保存名称、状态等信息;它与线程要执行的任务逻辑可以分开组织。currentThread() 取得调用代码当前所在的线程。后续所谓几种“创建方式”,实际涉及如何提供任务入口、如何启动以及是否借助线程池;本项是这些概念的入口,没有展开新的启动机制,故不单独成卡。

1.3.1 Thread类详解

构造 Thread 只得到线程对象,调用 start() 才安排新线程执行,并在新线程中进入 run()。直接调用 run() 仍是当前线程中的普通方法调用。状态观察还要区分 Java 与操作系统的抽象:Java 的 RUNNABLE 同时包括已经拿到 CPU 的运行状态与尚在等 CPU 的就绪状态,所以看到这个枚举值并不能证明线程此刻正在消耗 CPU。

原书依据 · 2 处

1.3.2 创建一个空线程

空线程示例创建 Thread 并调用 start(),但没有提供用户任务,也没有重写执行入口,因此新线程不会做用户业务工作。这个小例子把“创建对象”“启动执行”和“执行什么”分开:启动仍然发生,缺少的是用户逻辑。其用途是演示前面的启动契约,无需为同一机制再建一张卡。

1.3.3 线程创建方法一:继承Thread类创建线程类

继承 Thread 的方式把业务逻辑写在子类重写的 run() 中,再对该子类实例调用 start()。前者定义任务入口,后者才触发并发执行。它适合说明线程对象与执行入口的关系;下一项会把入口抽为 Runnable,便于把任务逻辑与线程类分开。本项作为两种代码组织形式的对照由既有任务目标卡承接,不另成卡。

1.3.4 线程创建方法二:实现Runnable接口创建线程目标类

Runnable 只规定一个无返回值的 run() 执行目标。把 Runnable 实例交给 Thread 后,线程启动时由 Thread.run() 转调目标的 run(),任务类因此不必继承 Thread。多个线程是否共享状态,取决于它们是否持有同一个目标对象及其引用,而不是取决于“实现接口”这种语法形式。

原书依据 · 1 处

1.3.5 优雅创建Runnable线程目标类的两种方式

匿名类和 Lambda 都能提供一次性的 Runnable 目标。Lambda 能使用在这里,是因为 Runnable 是只有一个抽象方法的函数式接口,表达式的代码体对应 run() 的实现。@FunctionalInterface 用来让编译器检查这种约束,接口本身满足条件时可以省略注解。两种写法改变的是组织任务代码的方式,并不改变 start() 的启动责任。

原书依据 · 1 处

1.3.6 通过实现Runnable接口的方式创建线程目标类的优缺点

多个 Thread 若持有同一 Runnable 库存对象,就会共同读写库存。书中先用 get()>0 检查、再原子扣减:库存为 1 时,两线程都可能通过检查,随后扣成 0 与 −1,形成超卖。一次扣减原子不等于整个销售判断原子。要保持库存不为负的业务约束,应让所有销售线程用同一把锁保护“检查并扣减”,或使用等价的原子条件更新协议。

原书依据 · 2 处

1.3.7 线程创建方法三:使用Callable和FutureTask创建线程

Runnable.run() 不返回结果;Callable.call() 能返回 V,并声明异常,适合有计算结果的任务。Thread 的执行目标要求 Runnable,因此需要 FutureTask 桥接:它包装 Callable,能作为 Runnable 被执行,同时作为 Future 保存完成状态、结果或失败。调用方通过 get() 取值,尚未完成时等待。合法结果可以是 null,不能通过结果是否为空判断完成与否。

原书依据 · 2 处

1.3.8 线程创建方法四:通过线程池创建线程

线程池让工作线程完成一个任务后继续领取其他任务,减少反复创建与销毁线程的成本。调用方提交的是任务,执行由池管理。execute 提交 Runnable 而不返回句柄;submit 返回 Future,用于观察完成、取消或取得结果,返回句柄并不表示已经执行完。复用解决生命周期成本,容量上限仍需后续单独配置。

原书依据 · 2 处

1.4 线程的核心原理

线程何时执行还取决于底层调度。书中把 Java 线程管理与操作系统的线程执行能力联系起来,接着用时间片解释多个任务如何交替获得 CPU。Java 线程与本地线程的具体对应方式有平台和实现条件;这里复用历史调度论述,不把书中特定系统的一对一描述推广成跨版本规则,也不另生重复卡。

1.4.1 线程的调度与时间片

CPU 时间片是分配给可运行线程的一段执行时间。一个逻辑 CPU 在同一时刻只执行一个线程的指令,但可以快速在多个就绪线程间切换,使任务交错推进,这就是并发;同时并行执行则需要多个可用执行单元。分时和抢占策略影响机会怎样分配,时间片长度也由系统决定,不能从并发的外观反推各任务确实在同一瞬间执行。

原书依据 · 1 处

1.4.2 线程的优先级

线程优先级表达调度倾向,不能保证某线程必定先运行、获得更多时间或按期完成。书中的实验甚至出现更高优先级线程机会更少的结果,说明单次计数不能替代同步协议。实验还使用 stop() 强制结束线程;它可能在资源状态更新一半时终止执行,使共享对象或连接处于不一致状态,业务收尾应采用协作退出并安排清理。

原书依据 · 2 处

1.4.3 线程的生命周期

Java 用六个 Thread.State 描述生命周期:NEW 尚未启动,RUNNABLE 表示可执行,BLOCKED 表示等对象监视器,WAITING 表示无时限等待,TIMED_WAITING 表示限时等待,TERMINATED 表示结束。start() 把新建线程带入可执行阶段,run() 结束则终止;sleep 等操作会暂时等待。状态是 Java 的分类,RUNNABLE 内仍区分是否实际拿到 CPU,不能直接当作操作系统状态表。

原书依据 · 1 处

1.4.4 一个线程状态的简单演示案例

状态演示让工作线程在循环执行、限时暂停和退出之间变化,再从另一个观察位置读取状态,以便把生命周期名词对应到运行现象。观察本身也受调度时机影响:同一段程序在不同瞬间可能读到不同状态。示例所用 parkNanos 是一种限时等待操作,不与 sleep 的所有契约等同。这里重复验证已有状态模型,故不另生成示例卡。

1.4.5 使用Jstack工具查看线程状态

jstack 生成 JVM 某一瞬间各线程的状态与方法调用栈,用来寻找持续运行、阻塞或等待外部资源的位置。线程转储是快照,并不记录此前的完整过程;一次停在某处也不证明它始终卡在那里。应在不同时间重复取样,比较相同线程的栈和状态,再结合 CPU 等数据判断持续问题,并留意 JVM 版本造成的输出差异。

原书依据 · 1 处

1.5 线程的基本操作

Thread 的常用操作分为面向某个线程对象的实例方法,以及作用于调用者当前线程的静态方法。后续依次处理名称、暂停、中断、等待目标结束、调度提示和守护属性。这个分类有助于判断“谁调用、谁受影响”,但本项只有方法范围导语,具体行为在各小节展开,故不另外成卡。

1.5.1 线程名称的设置和获取

线程名称是日志和转储中辨认工作角色的线索。可以在构造器中提供名称,也可用 setName 修改、用 getName 获取;未命名时只有 Thread- 加编号,难以说明业务用途。名称允许重复,故它不等同唯一身份。给线程池工作线程设置有意义的名称后,仍需结合线程 ID 和调用栈定位具体实例。

原书依据 · 1 处

1.5.2 线程的sleep操作

Thread.sleep 使调用它的当前线程限时等待,可在收到中断时抛出 InterruptedException。时间到了以后,线程重新具备执行资格,还须等调度器分配 CPU,因此不能保证精确到点继续运行。休眠适合暂停执行,不应拿它代替线程之间真正的条件同步;“等一会儿对方应该完成了”没有建立完成关系。

原书依据 · 1 处

1.5.3 线程的interrupt操作

中断是协作信号:对正在运行的线程,interrupt() 通常只是设置标志,任务需检查 isInterrupted() 决定退出与清理。线程在 sleep、wait 或 join 中被中断时,会退出等待并抛 InterruptedException,同时清除中断标志。捕获后若上层仍需处理取消,应传播异常或恢复标志,不能吞掉后期待后续检查自动看见同一次请求。

原书依据 · 2 处

1.5.4 线程的join操作

当前线程调用 target.join(),等待的是 target 线程的终止,而不是把两个线程变成一个线程。目标结束后调用者继续;带超时的版本也可因超时返回。无时限等待属于 WAITING,限时等待可属于 TIMED_WAITING,中断等待会抛异常。join 不直接返回目标的计算结果;目标也必须按正确顺序启动,不能照抄书中缺少 start() 的伪代码。

原书依据 · 1 处

1.5.5 线程的yield操作

Thread.yield() 表示当前线程愿意让出执行机会,但其 Java 状态仍是 RUNNABLE。调度器可以立刻再次选择这个线程,所以让步不保证其他线程先运行,也不保证公平。它与 sleep 的限时等待不同,更不能作为共享数据可见或执行顺序的证明;书中的优先级实验只是当次观察。

原书依据 · 1 处

1.5.6 线程的daemon操作

守护线程提供后台辅助服务,当 JVM 不再有存活用户线程时,其工作不会被等待完成,因此不能承担必须落盘或完成的业务收尾。setDaemon 必须在 start() 前设置,启动后修改会抛 IllegalThreadStateException;新线程通常继承创建线程的守护属性。线程池若把工作线程都设成守护线程,同样要认真安排任务退出责任。

原书依据 · 2 处

1.5.7 线程状态总结

汇总线程状态时,应按等待的原因分类。RUNNABLE 同时涵盖就绪和实际执行;等待对象监视器才是 Java 的 BLOCKED;无超时的 wait、join、park 属于 WAITING,相应限时形式及 sleep 可进入 TIMED_WAITING。外部 I/O 的操作系统阻塞不能直接套成 Java BLOCKED。这里整理前面分散的边界,已有状态及等待卡覆盖,不增加重复卡。

1.6 线程池原理与实战

创建线程不仅要建立 Java 对象,还涉及执行资源、栈和底层调度安排;短任务每次都新建线程会反复付出这些成本。线程池把任务管理集中起来,通过长期复用工作线程减少开销,并使并发规模可配置。栈大小依平台和参数而变,不能照书中示例设成统一下限。本项展开已有复用动机,不另立卡片。

1.6.1 JUC的线程池架构

Executor 以 execute(Runnable) 把任务提交者与实际执行机制分开。ExecutorService 在此基础上提供 submit、Future 与关闭等管理能力;ThreadPoolExecutor 实现通用池化执行。ScheduledExecutorService 增加延时和周期调度,ScheduledThreadPoolExecutor 提供相应实现。区分接口承诺与实现类,才能按需要的能力选择依赖和生命周期管理方式。

原书依据 · 1 处

1.6.2 Executors的4种快捷创建线程池的方法

Executors 的 single、fixed、cached 和 scheduled 工厂封装不同的线程规模与调度策略,便于演示,但也隐藏队列和容量参数。周期任务还须分清起点:固定频率按原定启动时点递增,固定延迟从上一次执行结束后再计时。同一个周期任务执行过久时,固定频率的后续执行可能延迟,却不会因此并发重叠;选择取决于需要贴近计划时点还是保留完成后的间隔。

原书依据 · 1 处

1.6.3 线程池的标准创建方式

ThreadPoolExecutor 的参数共同决定工作量如何进入系统。工作线程未到核心数时优先创建;核心规模已满时尝试排队;队列接不下时才尝试增长至最大数,再无法接收则拒绝。保活时间决定空闲线程何时回收,工厂负责新线程属性。因而提高 maximumPoolSize 本身并不保证提高并发度,队列容量、任务时长与内存预算必须一起考虑。

原书依据 · 1 处

1.6.4 向线程池提交任务的两种方式

execute 不向提交者返回任务结果句柄,submit 则通过 Future 暴露结果与失败。submit 包装的任务若抛异常,失败保存在 Future 中,get() 时以 ExecutionException 交给调用方;提交本身成功并不代表业务执行成功。保留并观察 Future,或安排明确的错误处理责任,才能避免任务已失败而调用方只看见一次成功提交。

原书依据 · 1 处

1.6.5 线程池的任务调度流程

任务调度按“核心线程、排队、增长到最大线程数、拒绝”的次序处理。书中核心数为 1、最大数为 100、队列容量为 100 的例子,少量任务只会一个运行、其余排队;队列没满时,最大线程数再大也不会自动生效。该例用于验证参数之间的关系,已被容量卡实质保留,不再另生流程卡。

1.6.6 ThreadFactory(线程工厂)

ThreadFactory.newThread(Runnable) 集中决定新工作线程如何创建,可统一名称、优先级和守护属性。工厂返回 null 意味着没有成功取得新线程,可能使任务无法执行。设置有意义名称有助追踪,而守护属性影响 JVM 退出时是否等待这些工作完成;工厂的便利配置因此也要服从线程池的收尾约束。

原书依据 · 1 处

1.6.7 任务阻塞队列

阻塞队列既有储存任务的方式,也有直接移交的方式。有界 ArrayBlockingQueue 能把任务排在缓冲中;SynchronousQueue 容量为零,需要与取任务的一方配对。线程池提交时采用尝试入队或移交,若无人接手,会按池规则尝试扩线程再拒绝,并不等同普通 put 调用一直阻塞。队列类型因此会改变扩容与过载的路径。

原书依据 · 1 处

1.6.8 调度器的钩子方法

beforeExecute 和 afterExecute 为每个任务的执行边界提供扩展点,可用于计时、日志及上下文处理。工作线程会复用,前置钩子写入的任务级 ThreadLocal 状态,应在后置收尾中移除,否则下一任务可能读到旧值。钩子自己抛异常也可能终止工作线程,所以统计、清理与异常处理都需明确边界;只覆盖成功路径不足以保证任务隔离。

原书依据 · 1 处

1.6.9 线程池的拒绝策略

拒绝发生于线程与队列无法接收任务,或者执行器已经关闭。AbortPolicy 抛异常,DiscardPolicy 丢任务,DiscardOldestPolicy 丢队首后尝试提交,CallerRunsPolicy 在池未关闭时让提交线程执行,形成一定减速效果;池已关闭时它也会丢弃。拒绝策略决定过载最终落到调用方、等待还是丢失,必须与业务能否承受丢任务相匹配。

原书依据 · 1 处

1.6.10 线程池的优雅关闭

shutdown() 停止接收新任务,让已提交任务继续处理;shutdownNow() 尝试中断运行任务,并返回尚未开始的队列任务。中断只是请求,不保证任务立刻停止。这两个方法都不替调用方等待池完全终止;需要收尾时,应限时 awaitTermination,超时后再决定取消、告警或后续处理,不能把方法返回当成工作已经结束。

原书依据 · 1 处

1.6.11 Executors快捷创建线程池的潜在问题

快捷工厂的风险要按具体参数判断。fixed 和 single 的无界队列可能把持续过载积累成内存压力;cached 使用直接移交队列,繁忙时可能大量扩线程。scheduled 则以核心线程与无界延时队列工作,不能只看很大的 maximumPoolSize 就断言它与 cached 一样无限扩线程。应显式检查并发、队列和拒绝边界,避免把压力藏在默认配置里。

原书依据 · 1 处

1.7 确定线程池的线程数

线程数不是越多越好:太少可能使可用 CPU 闲置,太多又会增加调度、内存和竞争成本。决定初始规模前,要先判断任务主要在计算还是等待,再测真实吞吐、延迟及资源利用。后续三种负载提供估算思路;本项是选型问题的入口,已由任务类型与容量卡承接,不另成卡。

1.7.1 按照任务类型对线程池进行分类

IO 密集任务的大量时间花在等待数据,CPU 密集任务持续占用计算资源,混合任务则交替经历两者。分类看的是实际时间和瓶颈,不是类名或接口:同一种 Runnable 可能执行完全不同的工作。这个区分为线程数估算建立前提,本身不意味着任何固定数量,已有任务配置卡保留该框架,故不另建重复卡。

1.7.2 为IO密集型任务确定线程数

IO 等待期间线程暂时不能计算,增加同时在途的任务可能让其他线程利用这段空档,提升 CPU 利用率。但增加线程也会加重下游与内存压力,最优数量要根据等待占比和实际负载试验。书中 Netty Reactor 使用“核心数两倍”的可配置默认值,只能视为框架实例,不能推广成所有 IO 线程池的通用公式。

原书依据 · 1 处

1.7.3 为CPU密集型任务确定线程数

CPU 密集任务持续需要计算资源,可用核心数附近通常是线程数的估算起点;过多就绪线程并不能让同一 CPU 同时执行更多指令,反而增加切换与竞争。这里的原则与 IO 等待时增加在途任务的理由不同,最终仍要用实际硬件和负载测量吞吐与延迟;既有任务类型卡一并保留两种条件,不另生成第二张选型卡。

1.7.4 为混合型任务确定线程数

混合任务既有计算时间又有等待时间,可以依据等待与计算的比例估算初始并发:等待占比越高,填满 CPU 空档所需的在途任务可能越多。估算须以实际可用 CPU 和任务时长为基础,再经真实负载验证,不能直接当最优值。随书示例读取 mixed.thread.amount 却设置 mixed.thread,键不一致,不能据其输出证明覆盖生效;此内容并入已有选型卡。

1.8 ThreadLocal原理与实战

ThreadLocal 为“当前线程”关联一个值,使相同变量入口在不同线程中找到各自的绑定。它常用于隔离线程级状态和在线程内传递上下文,但不会自动深拷贝对象;若多个线程绑定同一个可变对象,仍然会共享对象内容。本项建立概念入口,隔离与生命周期在后续展开,已有卡承接而不另生卡。

1.8.1 ThreadLocal的基本使用

ThreadLocal.set 为当前线程绑定值,get 取得该线程的绑定,remove 移除它。withInitial 通过供应函数,在当前线程尚无绑定值时提供初始值,减少反复判空设置。初始化取决于当前绑定是否存在,remove 后再次 get 可以重新初始化。工作线程长期复用时,任务结束的清理仍必须显式安排。

原书依据 · 1 处

1.8.2 ThreadLocal的使用场景

ThreadLocal 的用途可以是每线程独立保存可变状态,也可以是让同一线程内多层函数读取请求上下文,减少逐层传参。两种用途都以当前线程查表为边界:普通 ThreadLocal 不会把值自动传播到异步任务线程。隔离还不等于复制共享对象;在线程池中若不 remove,旧上下文可能污染下一任务并使对象长期留存,因此设置、传递与清理需一起设计。

原书依据 · 2 处

1.8.3 使用ThreadLocal进行线程隔离

Session 示例让每个线程通过 ThreadLocal 找到自己绑定的会话引用,避免直接把同一个可变会话供所有线程使用。绑定值只是引用管理,不会自动完成会话关闭,更不能把框架会话和数据库连接的生命周期完全等同。这里演示前面已经保留的隔离方式,不增加新的机制卡;资源释放应服从具体框架约定。

1.8.4 使用ThreadLocal进行跨函数数据传递

跨函数传递示例用一个持有 ThreadLocal 的入口,让同一线程上的多个调用层读取同一会话状态。便利来自不必逐层传参,边界仍是执行线程:一旦切到其他线程,就不能假设上下文存在。标准 JDK ThreadLocal 没有接受名称字符串的构造器,原书相关写法不能原样复制;本项的同线程协议已由既有上下文卡承接。

1.8.5 ThreadLocal内部结构演进

书中 JDK 8 结构中,每个 Thread 持有自己的 ThreadLocalMap,表内以 ThreadLocal 实例为键、线程绑定值为值。相同 ThreadLocal 能在不同线程中找到不同值,是因为查的是不同线程的表,而不是因为一个全局表自动复制了数据。一个线程使用多个 ThreadLocal,则自己的表中有多个条目;线程池复用也会延长这些条目的生命周期。

原书依据 · 1 处

1.8.6 ThreadLocal源码分析

源码访问围绕当前线程的表展开:get 查对应键,没有绑定时调用初始化钩子;set 建立或更新条目;remove 删除当前线程的条目。withInitial 只是提供初值的便利入口。remove 后再次读取可以重新初始化,故不能把“首次调用”误解为线程一生只能调用一次。这里把已有映射与初始化机制对上代码路径,不重复生成源码卡。

1.8.7 ThreadLocalMap源码分析

ThreadLocalMap 的 Entry 对键使用弱引用,而对值仍有强引用;当键失去其他引用时,值可能随长寿命线程的表继续保留。get、set、remove 的清理路径并不保证任意一次操作立即清空所有失效条目;若键本身长期可达,弱键回收更不能代替清理。线程池任务应显式 remove 自己的上下文,避免旧值污染和可能的长期保留。这是隔离卡的生命周期补充,不另生重复卡。

1.8.8 ThreadLocal综合使用案例

SpeedLog 把多层调用的计时记录放在线程局部列表中:withInitial 建立列表,各层追加信息,结束时汇总并 remove。这个案例把初始化、同线程共享和任务收尾连成一次使用生命周期。原示例只展示正常路径,实际异常也必须能清理,不能以正常运行输出证明资源永远不会残留;三个机制均已有卡,故不另成综合代码卡。

第2章 Java内置锁的核心原理

内置锁是对象监视器提供的互斥机制:线程进入对应的 synchronized 同步区时取得锁,离开时释放,同一时刻只有一个线程持有同一对象的锁。保护共同状态的所有访问路径必须使用同一个锁对象;各锁各的对象,即使都写 synchronized,也不会自动形成互斥。后续从这个语义展开锁粒度、对象布局和线程协作。

原书依据 · 1 处

2.1 线程安全问题

线程安全要求共享对象在允许的并发调度下仍保持约定的正确行为。某次运行得到预期输出,只说明那次交错没有暴露问题;若存在另一种合法交错破坏结果,仍然不安全。这里先立正确性标准,下一项用共享自增给出具体反例,定义与竞态已被既有卡承接,不单独重复成卡。

2.1.1 自增运算不是线程安全的

自增包含读旧值、计算加一和回写等逻辑步骤。两个线程可能都读到相同旧值,各自写回同一个新值,于是执行了两次加一却只留下一个增量。要避免丢失更新,需要把整个读改写置于互斥范围或使用适当的原子更新。这里是逻辑分析,不能把它固定说成三条 JVM 指令,更不能断言每一步在所有类型上都具有相同的原子边界。

原书依据 · 1 处

2.1.2 临界区资源与临界区代码段

临界资源是多个线程共同访问、必须保持约束的状态,临界区是需要统一保护的那段操作代码。界定保护范围时要从业务不变量反推步骤,而非只挑一条赋值加锁。一个 AtomicInteger 只保证它支持的单次更新,不能把跨字段、先检查后修改的整个流程都变成原子操作。该边界是前项竞态机制的延伸,复用既有卡不另成卡。

2.2 synchronized关键字

synchronized(lock) 以具体对象 lock 的监视器保护代码段。竞争者只有使用相同的锁身份,才会在进入时互相等待;同名变量若指向不同对象,并没有建立共同保护。关键字提供锁定行为,选择哪个对象、覆盖哪些状态仍是设计者的责任。本项概述的对象锁机制在章首已有主讲位置,不另生成重复卡。

2.2.1 synchronized同步方法

实例方法加 synchronized,默认取得接收对象 this 的监视器。因此同一实例的同步调用互斥,不同实例并不会仅因属于同一个类就全部串行。是否安全仍要看共同访问的状态是否由这把锁统一保护;一次计数实验不构成所有调度下正确的证明。与静态方法的锁身份差别由后续对照卡保留,此项不再另成卡。

2.2.2 synchronized同步块

同步块允许只保护真正需要互斥的代码,也能为相互独立的状态选择不同锁,减少无关等待。但若两个字段必须一起保持某个约束,把它们拆给不同锁就可能暴露只更新一半的状态。先确认不变量独立,再谈缩小锁粒度。实例同步方法与覆盖整个方法的 synchronized(this) 行为接近,但字节码不同:方法使用同步标志,同步语句使用监视器进入和退出指令。

原书依据 · 1 处

2.2.3 静态的同步方法

static synchronized 锁住所属类的 Class 对象;实例 synchronized 方法锁住 this。两个锁对象不同,静态同步调用与实例同步调用不会仅因都有关键字而互斥。退出同步区时会释放监视器,异常退出也如此;释放锁只恢复其他线程的进入机会,不自动回滚已经修改一半的业务状态。判断安全性须同时核对锁身份与状态更新边界。

原书依据 · 1 处

2.3 生产者-消费者问题

生产者负责加入数据,消费者负责取出数据,中间用共享缓冲区衔接速度差。缓冲区既有内容一致性约束,也有容量条件:满时不应继续生产,空时不应继续消费。后续从不安全版本推进到同步和等待通知,分别解决互斥与何时继续的问题;本项是问题导语,既有生产消费卡已覆盖,不另生卡。

2.3.1 生产者-消费者模式

有界缓冲区限制积压数量,把生产与消费的速度差转化为等待。生产者在未满时入队,消费者在非空时出队;条件不满足时等待状态变化,避免空转。条件检查、等待和修改必须受同一同步机制协调,醒来后还要重查。后文的错误实现说明,仅给计数加原子类型、或者分设若干锁,都不能自动得到正确协议。

原书依据 · 1 处

2.3.2 一个线程不安全的实现版本

不安全版同时维护数据集合 dataList 和数量 amount。即使 amount 的单次增减使用原子变量,它与集合变化仍可能交错,使计数与实际内容不一致。满判断若用 amount>MAX_AMOUNT,等于容量上限时还会允许加入,另有边界错误。这个反例说明同步要覆盖共同不变量,已由复合竞态与生产消费卡承接,不把异常日志另做经验卡。

2.3.3 一个线程安全的实现版本

所谓安全版尝试用同一监视器保护入队、出队及计数变更,这体现了统一维护缓冲区不变量的方向。状态修改可以串行,外部生产与消费的耗时工作仍可分开执行。不过书中代码把 BlockingQueue.remove(0) 的布尔返回值当成 T,且无参 LinkedBlockingQueue 未设置目标容量,不能直接当作可运行的有界阻塞实现。这里保留同步原则,不新增代码模板卡。

2.4 Java对象结构与内置锁

Java 语义中的对象锁怎样在虚拟机里表示,需要先认识对象在内存中的布局。对象头包含运行时管理信息,书中随后用旧版 HotSpot 的对象头和锁记录解释加锁状态。这个短过渡仅建立“锁对象”与“对象表示”的联系,没有独立展开布局或加锁流程,故不另生卡。

2.4.1 Java对象结构

常见 HotSpot 对象由对象头、实例字段和必要的对齐填充组成,数组还记录长度。头部保存运行时元数据,实例区保存对象状态,填充满足内存对齐要求。指针压缩、虚拟机参数与 JDK 实现会改变宽度和偏移,故估算大小应先确认运行环境,再借 JOL 观察实际对象;书中的某次字节数不能当通用常量。

原书依据 · 1 处

2.4.2 Mark Word的结构信息

Mark Word 是书中旧版 HotSpot 对象头的一部分,其有限空间在不同状态下复用:可以表示身份哈希、年龄或锁相关信息。看位图时要先知道对象当前处于什么状态,不能把所有字段理解为同时存在。偏向锁图和四态编码属于特定实现,JDK 15 起偏向锁默认禁用;身份哈希还可能与旧版偏向表示发生冲突并触发撤销。

原书依据 · 1 处

2.4.3 使用JOL工具查看对象的布局

JOL 将运行时对象的头部、字段偏移和填充打印出来,使抽象布局能与具体实例对应。输出只反映这次 JVM 的版本、参数和当前对象状态;计算身份哈希后,旧版偏向对象的表示还可能变化。用 JOL 是核对环境的方法,不是从一个示例推出对象头永远 12 字节、对象永远 16 字节。本项由已有布局及对象头卡承接,不另成卡。

2.4.4 大小端问题

字节序说明一个多字节数值怎样沿地址存放。大端将高位字节放在低地址,小端将低位字节放在低地址;数值没变,逐字节观察时次序不同。解释 JOL 的原始头部字节时,须先确认运行平台的字节序,再还原字段值,不能把某次平台输出推广为全部 JVM 或全部协议的约定。

原书依据 · 1 处

2.4.5 无锁、偏向锁、轻量级锁和重量级锁

书中的无锁、偏向、轻量级和重量级四态,是旧版 HotSpot 优化同步成本的表示模型。偏向尝试减少同线程重复进入的成本,轻量路径与栈锁记录减少低竞争开销,监视器支持竞争中的等待与唤醒。实际路径依版本与竞争时序而变,并非每次都逐级经历四态;空闲监视器还可收缩回收,不能把“升级”理解为对象终身绝不回退。

原书依据 · 1 处

2.5 偏向锁的原理与实战

偏向锁针对的是同一个线程反复进入同一同步区的情况:既然没有其他竞争者,重复执行竞争操作可能是额外成本。它是书中旧版 HotSpot 的一种优化思路,下一项再解释怎样记录线程身份。这里仅给优化动机,收益还取决于实际争用模式和撤销成本,不单独生成重复卡。

2.5.1 偏向锁的核心原理

旧版偏向机制把偏向线程的身份信息记录到对象头中,同一线程再次进入时可利用身份匹配减少竞争操作。其他线程来访问时,原先的偏向不能直接当作对它的许可,需要处理撤销和后续锁路径。这是在有限对象头空间中编码运行状态的优化,非 synchronized 的语言契约;主机制由对象头和锁态卡承接,不额外成卡。

2.5.2 偏向锁的演示案例

偏向锁示例借 JOL 观察对象头中的偏向标记和线程信息,并展示重复进入时的输出。观测需先确认运行的旧版 VM、偏向参数和启动延迟;新版默认行为可能不同。原文还混用 counter 与 lock,调用前文未给出的辅助方法,不能直接当成完整可运行实验。机制与观测方法已有卡保留,本项不另制示例卡。

2.5.3 偏向锁的膨胀和撤销

偏向撤销发生于原先的单线程优化不再适用等情形:新线程参与竞争,或者旧版对象头需要容纳身份哈希。撤销与后续路径有额外成本,故必须连同重复进入节省的操作一起评价。不能由“很多同步块只有一个线程”这种无样本判断断言总收益必为正,也不能保证每次竞争走完全相同的膨胀顺序;本项复用已有两张锁态卡。

2.6 轻量级锁的原理与实战

轻量级路径的动机是在竞争不激烈、临界区较短时,减少为等待而付出的阻塞和唤醒成本。它与持续自旋、重量级监视器的取舍有关,但不能把所有轻量级实现一概等同为自旋锁。这里承接前面的成本问题并引出锁记录,尚未增加独立机制,因此不另生成卡片。

2.6.1 轻量级锁的核心原理

旧版 HotSpot 栈锁会在线程栈帧建立 Lock Record,保存对象原来的 Mark Word,再尝试用 CAS 将对象头关联到锁记录。保存旧头使释放时可以恢复原有元数据,解释了对象头有限空间怎样临时用于加锁。这个机制是具体版本的内部表示;自旋等待属于争锁策略,不能用它替代对锁记录与对象头关系的理解。

原书依据 · 1 处

2.6.2 轻量级锁的演示案例

轻量级锁演示以 JOL 输出观察旧版对象头的锁标记,再与栈帧锁记录模型对应。它展示的是一次运行状态,不能从启动间隔保证每次出现同样状态。示例中的线程永久循环及未给出的辅助方法使其不能原样自然退出,故只复用前项机制与布局观察方法,不另生成实践或代码模板卡。

2.6.3 轻量级锁的分类

自旋让等待线程暂时占用 CPU 重试,短等待时可能省去阻塞唤醒成本,等待很久时则会空耗资源。普通自旋与自适应自旋的差别,在于等待预算是否会结合先前结果等信息调整。书中的固定次数、启动参数及版本开关都有历史实现边界,不能直接当作当前调优建议;成本权衡已由既有锁态卡承接。

2.6.4 轻量级锁的膨胀

临界区较慢或竞争线程较多时,多个线程持续自旋可能浪费大量 CPU,转向阻塞等待才可能更经济。旧版实现可据争用情况让锁膨胀到监视器路径,但触发方式受具体 VM 策略影响,不是一个通用超时规则。这延续了自旋与阻塞的取舍,已有锁态卡覆盖,不另形成同义卡。

2.7 重量级锁的原理与实战

监视器可以理解为进入同步区所需的许可,同一时刻只允许一个持有者操作受保护代码。它还为线程主动放弃许可、等待条件改变提供基础。Java 每个对象都有关联监视器的语义抽象,并不表示对象创建时必须立即分配独立的 HotSpot ObjectMonitor;本项为下一项的互斥和协作机制导语,不另生卡。

2.7.1 重量级锁的核心原理

监视器管理两种不同原因的等待:一种是想进入同步区却没拿到锁,另一种是已经持锁但发现业务条件不满足,调用 wait() 暂时释放该监视器。notify() 选中等待者后,它还要重新竞争并取得锁才能从 wait 返回。书中 Cxq、EntryList 与 WaitSet 有助于读旧版实现,但具体迁移路径及公平次序不是 Java API 保证。

原书依据 · 1 处

2.7.2 重量级锁的开销

阻塞等待可能涉及操作系统调度与唤醒成本,自旋则直接消耗 CPU;两者的相对收益取决于等待时长和竞争程度。不能把每次重量锁操作都等同一次用户态到内核态切换,pthread_mutex_lock 也是线程库接口,是否进入内核要看实际路径。这里补充已有锁成本取舍,未提出新的同步协议,因此不另生卡。

2.7.3 重量级锁的演示案例

重量级锁示例通过争用和 JOL 输出观察监视器对应的旧版对象头状态。输出能够说明当次配置中发生了什么,却不能证明每次都按偏向、轻量、重量的固定顺序迁移。示例变量名、辅助方法及无限循环仍有缺陷,不能原样作为完整实验;布局与锁态卡已保留可复用机制,本项不另成卡。

2.8 偏向锁、轻量级锁与重量级锁的对比

横向看这三种旧版路径:偏向利用线程身份减少重复竞争,栈锁记录暂存对象头并配合原子操作,监视器处理竞争与条件等待。它们是降低不同条件下同步成本的实现选择,并不改变同一监视器互斥的语义。书中六步流程应读作历史模型,不能当作所有 JDK 的必经过程;相关机制已分别保留,故不重复制流程卡。

2.9 线程间通信

线程协作不仅是防止同时破坏共享数据,还要知道条件何时允许继续。例如消费者持锁后发现队列空了,继续抢锁并不能凭空产生数据。通信让参与线程获知共享状态的变化,为从无效争夺转向有条件等待提供依据。这个短导语的定义由下一项展开并保留,不另成卡。

2.9.1 线程间通信的定义

线程通信是多个线程在共同操作资源时,以状态变化协调后续动作的过程。等待通知是本章的具体方式:条件不满足的线程等待,改变状态的线程发出提示,使等待者有机会再检查。通知并不替代受保护的共享条件,也不保证资源仍可用。共享内存、管道流等在这里仅列名,未展开成独立机制。

原书依据 · 1 处

2.9.2 低效的线程轮询

轮询是反复查询条件,即使队列一直为空,消费者也持续检查而得不到数据;缓冲区一直满时生产者同样可能做无用工作。等待通知把“再次尝试”的时机与状态改变联系起来,减少空转,但必须建立可靠条件协议。wait 和 notify 属于具体对象监视器,不是能任意保存给线程的消息。本项作用由生产消费及等待卡承接,不另生成性能卡。

2.9.3 wait方法和notify方法的原理

调用对象的 wait、notify 或 notifyAll 前,线程必须持有同一个对象的监视器。wait 释放的是这个监视器,等待结束前还须重新取得;notify 只选一个等待者,不保证 FIFO,更不保证被选者马上运行。它不会把调用者当前持有的其他锁一并释放。无时限 wait 与限时重载的状态也需区分;持锁契约在此作为主讲保留。

原书依据 · 1 处

2.9.4 “等待-通知”通信模式演示案例

演示的关键时刻是通知方已经 notifyAll,却仍在同步块里:等待方还不能继续,须等通知方释放、自己重获监视器后才能从 wait 返回。通知与执行之间存在竞争过程。原书输出提及未给出的 flag 状态,且用 sleep 假定等待者先到、没有共享条件循环,不能作为稳健协议;这里复用已保留的等待机制,不另立示例卡。

2.9.5 生产者-消费者之间的线程间通信

书中生产消费通信版分设状态锁、未满锁和未空锁,却把条件检查放在等待锁外。消费者看到空后,生产者可能恰好入队并通知,消费者随后才 wait,于是错过唯一通知。应让条件检查、修改与进入等待处于同一同步协议下,避免这个窗口;若使用一把监视器,应在它的同步区内循环检查并等待,不能仅靠三把锁各自合法使用证明整体正确。

原书依据 · 1 处

2.9.6 需要在synchronized同步块的内部使用wait和notify

wait 和 notify 的持锁要求保证监视器操作合法,条件循环则保证恢复后重新判断业务是否可继续。等待者可能被伪唤醒,也可能在重新拿锁前被别人取走资源,所以需要 while 复查。while 本身仍不够:检查在锁外、等待在另一锁内,依然有丢失通知窗口。正确协议必须把检查、等待和修改统一起来,原书相关跨锁代码不能原样照搬。

原书依据 · 1 处

第3章 CAS原理与JUC原子类

前面的内置锁说明了互斥保护共享状态的办法,本章转向 CAS,即按预期旧值决定是否提交更新的原子原语,再讨论建立在其上的 JUC 原子类。比较锁等待与重试成本需要看实际竞争,不能断言一种方案在全部负载上更快。本项是后续概念与局限的章导语,没有独立新机制,故不另成卡。

3.1 什么是CAS

JUC 将底层原子更新能力封装为 Java 可以使用的并发 API。CAS 的关键问题是“当前值是否仍等于我的预期,若相同能否原子替换”,并把成功或失败返回给调用者处理。这里是接口背景导语,详细比较语义在下一项展开;API 存在并不意味着多个步骤的业务流程已经安全,不另重复成卡。

3.1.1 Unsafe类中的CAS方法

CAS 比较目标位置的当前值与预期值,相同则原子替换为新值并返回成功,不同则不修改并返回失败。Unsafe 的相关入口以对象、字段偏移、预期值和新值定位这次更新。它连接具体 JVM 的底层能力,native 调用却不代表跨平台总是一条 CPU 指令或绝对无锁。应用应优先使用公开原子类,内部接口和反射示例需按 JDK 版本核对。

原书依据 · 2 处

3.1.2 使用CAS进行无锁编程

一次 CAS 失败意味着预期条件没有满足;若新值由旧值计算而来,就应重新读取共享值、重新计算目标,再尝试提交。反复提交旧的 expected 和 newValue 会忽略已经发生的更新。这个读、算、提交循环可实现自增,但争用越高,失败重试成本可能越大;CAS 成功也只证明当前匹配,不能证明期间从未发生 ABA 变化。

原书依据 · 1 处

3.1.3 使用无锁编程实现轻量级安全自增

安全自增示例把读取计数、算出加一结果和 CAS 提交串成循环,只有成功才计入一次完成。它回应开章的共享自增问题,展示用条件提交替代未经同步的读改写。不过原文有未定义的 i++,文字次数与代码输出也不一致,不能将打印数字当成已验证性能证据;核心模式已由重读重算卡保留,不另制示例卡。

3.1.4 字段偏移量的计算

Unsafe 字段偏移用于标识对象中的更新位置,需与对象及相应访问 API 配合;实例字段和静态字段的定位方式不能混用。JOL 显示的某次 offset=12 是具体布局结果,不是所有对象的常量,也不应解释成在对象头后再加一次固定偏移。这里只补底层定位背景,已有 Unsafe 和对象布局卡承接,不另生成偏移数字卡。

3.2 JUC原子类

JUC 原子类把常用单值更新封装为可直接调用的操作,例如原子增量,避免每位调用者重新编写底层重试。其保证仍有明确范围:一个原子增量不会让前后额外条件判断自动成为同一次操作。选型还要看状态大小与争用成本,不能概括为原子类必胜 synchronized;本项是工具导语,没有新的独立卡。

3.2.1 JUC中的Atomic原子操作包

选原子工具先确定要原子改变的对象:基本值使用基础原子类,数组按元素更新,对象引用用引用原子类,对既有对象指定字段则用字段更新器。操作结果也要分清,getAnd… 返回更新前值,…AndGet 返回更新后值,compareAndSet 返回这一次是否成功。单次更新的原子范围不自动延伸到跨字段不变量,字段访问条件也须匹配工具要求。

原书依据 · 1 处

3.2.2 基础原子类AtomicInteger

AtomicInteger 提供 getAndSet、getAndIncrement、getAndAdd 等单值操作。方法名中的顺序有实际意义:getAnd… 交回旧值,…AndGet 交回更新后值,compareAndSet 交回成功布尔值。调用者若把旧值当新值,后续判断就会偏差。多线程累加得到预期总数可验证该次操作的计数用途,却不能证明外部条件检查或复杂业务流程原子;这些契约由选型卡统一承接,不再逐 API 成卡。

3.2.3 数组原子类AtomicIntegerArray

AtomicIntegerArray 按索引原子更新一个整型数组元素,其他数组原子类也以元素为操作边界。getAndAdd(i, delta)、compareAndSet(i, expect, update) 都要传索引,原书方法清单漏参不能照抄。第一个元素的原子更新与第二个元素的原子更新是两次操作;若业务要求两者之和始终固定,仍需额外的整体同步设计。

原书依据 · 1 处

3.2.4 AtomicInteger线程安全原理

书中 AtomicInteger 源码用可见的 value 字段结合 CAS 循环:读取 current,计算 next,提交失败后重读重算。volatile 负责相应读写的可见性与顺序约束,CAS 提供条件更新的原子性;仅有 volatile 不能让 ++ 的整个读改写自动原子。具体源码依 JDK 实现而变,这里串起已有机制并为第 4 章的可见性讨论设入口,不另生成重复卡。

3.3 对象操作的原子性

需要同时变更多个相关字段时,可以把它们组成完整状态对象,再一次性替换持有它的引用,让读取者选中旧状态或新状态。这个思路的前提是替换整体,通常应让已发布状态保持不可变;把 AtomicReference 包在可变对象外,再原地改多个字段,并没有形成事务。本项提出方向,由下一项引用边界卡完整保留,不另成卡。

3.3.1 引用类型原子类

AtomicReference 原子比较并替换的是引用位置,不是引用对象内部的全部字段。用 User 示例理解时,换成另一个 User 的引用可以是单次原子操作,而对原 User 的姓名和年龄分别赋值仍可能暴露中间状态。印戳引用与布尔标记引用额外携带比较信息,解决的是特定历史或状态协议,不能把它们理解为自动给整个对象加锁。

原书依据 · 1 处

3.3.2 属性更新原子类

字段更新器允许对既有对象的指定字段做原子更新,例如 AtomicIntegerFieldUpdater 针对可访问的 volatile int。这里的可见性取决于访问权限,并非字段一律必须 public。其他普通写入不会自动参与同一条件更新协议,更新器也不会顺带保护对象其余字段;该细化已并入原子类选型卡,不再另生工具列表卡。

3.4 ABA问题

CAS 只观察比较时的值,可能遗漏中间曾经发生又恢复的变化。ABA 就是这一风险的简称,下一项以链表栈说明为什么“值又相同”仍可能使旧计算失效。本项只有风险导语,没有独立交错或解决机制,故沿用后续历史信息卡,不重复成卡。

3.4.1 了解ABA问题

ABA 是状态从 A 变成 B 再回到 A,令旧预期比较仍通过,却掩盖中间变化。书中栈例里,线程 A 记住栈顶 E2 及旧后继 E1;另一线程弹出 E2、E1,压入 E3,再压回原 E2。A 仍能把栈顶 CAS 成过时 E1,使 E3 游离。必须复用同一 E2 节点才会发生引用匹配;新建一个同名节点不构成这个反例。

原书依据 · 1 处

3.4.2 ABA问题解决方案

用版本戳解决相关 ABA,思路是让一次比较同时包含当前值与变更代次:值即使恢复原样,戳也应显示它经历过更新。每次相关更新都必须遵守维护戳的协议,有限宽度的戳还需考虑回绕边界,不能只因“版本递增”就宣称永远不可能误判。该方案与前项风险由同一历史卡承接,不另建同义解法卡。

3.4.3 使用AtomicStampedReference解决ABA问题

AtomicStampedReference 将引用和整数 stamp 组成一个原子比较更新单元,只有两者都符合预期才提交新引用与新戳。读取及修改时要维护配对关系,不能读到来自不同轮次的引用和戳,也不能忘记随相关变化更新戳。书中类名、方法拼写及 stamp++ 传参有误,不能照抄;机制已由 ABA 卡保留,不另生错误代码示例卡。

3.4.4 使用AtomicMarkableReference解决ABA问题

AtomicMarkableReference 把引用与一个 boolean 标记一起比较更新,适合需要二态状态的协议。它不能计数任意次数的修改:标记翻转两次又回到旧值,旧比较可能再次匹配。单次 false 到 true 的示例只能证明那一轮旧比较失败,不能推出免疫一切 ABA。是否需要整数戳,要看业务是否必须识别多次变化历史。

原书依据 · 1 处

3.5 提升高并发场景下CAS操作的性能

多个线程同时争用一个原子值时,只有部分提交能立即成功,其余需要重试。高竞争可能把节省的锁等待变成 CPU 空转,所以“无锁”并不等于没有成本。接下来 LongAdder 用分散计数位置降低热点,但其语义不适合所有共享状态;本项是性能问题入口,已有自旋成本和分散热点卡承接,不另生卡。

3.5.1 以空间换时间:LongAdder

LongAdder 把集中更新一个数值的争用分散到 base 与多个 Cell,读取时再汇总,利用额外空间降低高竞争下的更新冲突。sum() 在没有并发更新时给出准确总和,更新进行中不是原子快照,因此适合统计计数,不能直接替代需要精确原子判断的余额或库存。书中速度倍数只是特定实验,不是通用性能承诺。

原书依据 · 1 处

3.5.2 LongAdder的原理

LongAdder 的更新值分散在 base 和 Cell 中,对已有 Cell 的更新仍采用 CAS;而创建 cells 数组、扩容或填入空槽属于结构修改。旧版实现先用 CAS 将 cellsBusy 从 0 改为 1 获得短暂结构控制,再检查和修改,结束后释放。未拿到结构控制时仍可尝试 base 等更新路径;它并没有把所有加法都重新串行化,并发求和仍不构成原子快照。

原书依据 · 1 处

3.6 CAS在JDK中的广泛应用

这一小节只有“接下来总结 CAS 的弊端与规避措施”的过渡句。标题指向后续应用,但本项没有展开新的容器算法或同步步骤,因此保持导航作用,不从标题补造内容,也不生成知识卡。

3.6.1 CAS操作的弊端和规避措施

CAS 的限制应分别处理:当前相同却遗漏历史,要设计版本或状态协议;多个字段共同约束,要整体替换不可变状态或另加同步;高争用重试,要评估分散热点等方案。LongAdder 适合可汇总统计,AQS 则是可排队并阻塞的同步器框架,内部仍可能用 CAS;它不是任意 CAS 热点的通用削峰开关。

原书依据 · 1 处

3.6.2 CAS操作在JDK中的应用

CAS 能成为更高层并发结构中的原子提交工具:原子类用它更新状态,AQS 等同步设施也用它维护内部状态或队列位置。但使用同一原语并不意味着这些类具有同样的等待和正确性协议,队列及锁的组织还需后续章节具体说明。这里是已有机制的应用连接,未展开独立算法,不把全部并发类一概归为同一种实现,故不另生卡。

第4章 可见性与有序性的原理

共享变量的并发正确性有三个不同问题:一次更新是否作为整体发生,某线程的写入能否被另一线程看到,以及程序要求的先后关系能否成立。前章的CAS只提供特定比较更新的原子能力,不能包办所有复合业务操作。本章从处理器缓存的背景走向Java内存模型,最终用先行发生关系判断程序保证;导言只建立问题框架,不另拆知识卡。

4.1 CPU物理缓存结构

高速缓存是在处理器与主存之间保存近期数据的存储层,用较低访问延迟缓解处理器等待主存的成本。书中的L1、L2、L3示意帮助理解速度、容量和共享范围的取舍,但层级是否共享及命中率随架构和负载变化。多核可能持有同一数据的副本,因此需要协调;这一硬件背景不能与JMM的“工作内存”逐项画等号。

对上述概念、机制与边界的进一步解释见缓存带来可见性。

原书依据 · 1 处

4.2 并发编程的三大问题

分析共享状态时,可以依次问:读改写会不会被其他更新交错破坏,读者是否有依据看到写者的结果,以及数据与信号之间是否建立了所需先后关系。三问分别对应原子性、可见性和有序性,它们互相关联却不能互相替代。这里组织后续三例,不新增分类清单卡。

4.2.1 原子性问题

原子性要求操作在并发观察中表现为一个整体。共享计数的sum++包含读取旧值、计算新值和写回;两个线程都读到同一旧值时,即使各自完成加一,仍可能覆盖彼此的更新。javap展示的是字节码,可辅助识别复合动作,却不能据四条字节码规定固定机器步骤或线程切换粒度。

对上述概念、机制与边界的进一步解释见并发三难题。

原书依据 · 1 处

4.2.2 可见性问题

可见性关注线程间的读能否按同步协议观察到另一线程的写。JMM用规则描述这种保证,“复制到工作内存、回刷主存”只是教学模型。书中的两线程自增还包含另一个问题:双方都可能先读到0,再各自写1;即使每次读写都可见,也不能把读、加、写合成原子更新。选择同步手段时必须先分清这两个问题。

对上述概念、机制与边界的进一步解释见可见性不能消除丢失更新。

原书依据 · 1 处

4.2.3 有序性问题

有序性关注共享操作之间的先后约束。书中让两个线程分别写一个变量、再读取对方变量,出现同时读到0的结果,暴露了两条路径缺少足够的跨线程同步关系。但同一输出可能对应多种被内存模型允许的执行,不能据一次实验认定发生了某一种CPU或编译器重排;修复应明确需要哪条先行关系。

对上述概念、机制与边界的进一步解释见观测到零零不证明发生重排。

原书依据 · 1 处

4.3 硬件层的MESI协议原理

缓存一致性协议处理多个核心缓存同一数据后怎样协调副本的问题。它为硬件层的共享访问提供基础,后续MESI状态将具体说明谁持有有效数据、何时其他副本失效。缓存属于处理器及其层级,线程可能迁移到其他核心,并不天然拥有一块固定私有缓存。本段为协议导引,不重复建立缓存概念卡。

4.3.1 总线锁和缓存锁

总线锁与缓存锁展示了协调共享访问的不同影响范围:粗粒度地限制总线访问会影响无关数据,而缓存一致性机制可围绕相关缓存行协调。书中把LOCK#、总线锁及缓存行锁混用,不能据其图示认定每次Java更新都锁总线。直写、回写则讨论缓存写入何时向下层传播,属于硬件策略背景;由于原文适用条件不完整,此处保留分层认识,不新增硬件通则卡。

4.3.2 MSI协议

MSI是用于协调缓存副本的协议模型,书中以“写入使其他副本失效”说明:其他核心不能继续把已经失效的旧副本当作有效数据使用,后续读取需要重新取得有效数据。本项完整状态表主要通过图表呈现,正文只提供读写示意,因此将状态定义与转换关系集中在下一项MESI讲解,不拆成缺少定义的独立卡。

4.3.3 MESI协议及RFO请求

MESI以缓存行为协调单位,为每行记录四种状态:Modified表示本核心持有已修改数据,Exclusive表示本核心独有且未修改,Shared表示可能有多个有效副本,Invalid表示本副本无效。当多个核心共享同一行而其中一个要写入时,需要取得写入所有权,使其他副本失效。协调粒度是整行,因此同一行上的不同变量也可能相互影响;该硬件机制仍不能代替Java层的同步规则。

对上述概念、机制与边界的进一步解释见MESI按缓存行协调副本。

原书依据 · 1 处

4.3.4 volatile的原理

volatile是Java为共享变量规定的同步语义:写与后续对同一volatile变量的读建立先行关系,并约束相关操作的可观察顺序。书中反汇编可用来观察特定JDK和处理器怎样实现该语义,却不能推出只有volatile才参与缓存一致性,或每次读写都固定采用某条指令并回刷主存。本项实现背景由后续volatile规则统一承接,不重复成卡。

4.4 有序性与内存屏障

内存屏障用于约束特定方向的内存操作顺序,让编译器和处理器的优化不能破坏所需同步语义。不同屏障限制的读写组合不同,不能笼统理解成屏障前全部指令完成、前后所有指令都不得移动。这里从可见性转向顺序约束,具体类型与发布例子在后文展开,不另拆导言卡。

4.4.1 重排序

重排序指编译器或处理器在保持规定行为的范围内改变操作的实现次序,处理器流水线和内存系统也会影响其他线程观察写入的顺序。单线程看起来等价的优化,不一定满足未经同步的线程对先后的想象。判断合法行为要同时考虑语言模型与同步关系,不能只看两个语句有没有数据依赖;本项与屏障及三难题共同解释同一边界,不新增卡。

4.4.2 As-if-Serial规则

As-if-Serial要求优化后的程序保持单线程可观察语义。例如先给a、b赋值,再计算a+b,不能把依赖尚未建立的计算变成错误结果;独立赋值则可能在实现中调整次序。这个要求不限于单核,也不能自动保证另一线程按源码顺序看见所有操作。异常路径同样须保持语义,但书中的JIT阈值和“补偿代码”解释不是统一规范,因此不另制实现细节卡。

4.4.3 硬件层面的内存屏障

硬件屏障可为某些读写顺序提供实现上的约束,其效果取决于屏障类型和处理器,不能一概描述成所有缓存失效或全部回写。发布数据时,更直接的Java推理是:先写数据,再写volatile标志;读线程先读到发布标志,再使用数据。书中却把数据x设为volatile、flag保持普通字段,不能用flag读写证明该发布关系,示例需要按同步对象重新理解。

对上述概念、机制与边界的进一步解释见屏障约束重排、发布标志应建立先行关系。

原书依据 · 2 处

4.5 JMM详解

Java内存模型是关于共享变量读写和同步行为的一组语言规则,回答“线程能观察到什么”;JVM运行时内存结构回答“虚拟机如何组织存储区域”。二者讨论层次不同。本项只作定义入口,后续两项展开这种区别,不单独成卡。

4.5.1 什么是Java内存模型

JMM为不同编译器、操作系统和处理器上的Java程序提供一致的并发推理规则。它规定共享变量的读写、同步动作及可观察行为,而不要求给每个线程分配一块真实“工作内存”。硬件缓存、寄存器以及虚拟机的堆栈结构是实现层对象;是否存在共享访问与同步缺口,应沿线程实际读写关系判断。

对上述概念、机制与边界的进一步解释见JMM规则不等于物理内存布局。

原书依据 · 1 处

4.5.2 JMM与JVM物理内存的区别

JMM、JVM运行时数据区和硬件内存架构可以分别理解为语义规则、虚拟机存储组织和实际机器实现。把它们都叫“内存”容易混淆:规范中的工作内存并不是CPU缓存的别名,i++也不必按固定三次物理搬运实现。复合更新为什么丢失,应看读改写之间的竞争;本项延续上一项分层区别,不重复成卡。

4.5.3 JMM的8个操作

书中用read/load、use/assign、store/write、lock/unlock八类抽象动作描述变量使用、传递和同步的约束。这些名称用于解释模型,不是开发者可逐条调用的硬件搬运指令,也不能由此规定所有JVM的物理步骤。由于原文混用了历史模型与未注明版次的“新版本简化”,这里保留其建模作用,以后续happens-before规则完成应用推理,不新增现行规范卡。

4.5.4 JMM如何解决有序性问题

逻辑内存屏障描述哪些读写不能越过哪些读写:LoadLoad、StoreStore、LoadStore和StoreLoad分别区分屏障两侧操作的类型。JVM可按目标平台选择实现,以满足Java同步语义,而不必把每类逻辑屏障机械翻成同名硬件指令。原文部分缓存刷新表述过宽;这一实现分层由屏障卡承接,不重复转抄屏障表。

4.5.5 volatile语义中的内存屏障

volatile写之前的普通写与volatile读之后的普通读,可以通过相应同步关系连接,使发布者的准备结果对观察者可见。书中用保守的屏障插入策略说明实现怎样防止破坏这种语义的重排,但具体指令及省略优化依平台与JVM而定,不能从表格推出所有部署中的固定读写成本。本项与后续规则描述同一保证,不重复成卡。

4.6 Happens-Before规则

Happens-Before(先行发生,简称HB)是判断动作之间可见性与顺序保证的推理关系。开发者可以组合程序顺序、volatile、监视器及线程生命周期规则,证明某个写入对之后的读可见,无需先猜测缓存和指令怎样运行。它不等于墙上时钟上的先后;此处引出规则组,具体关系在后续说明,不另制导言卡。

4.6.1 Happens-Before规则介绍

HB的价值在于把局部规则接成完整证明:同一线程的前后动作提供程序顺序边,同一volatile变量的写读、同一监视器的释放获取,以及线程启动和终止提供跨线程边,传递性再将这些边连接起来。书中列的是常用规则而非完整目录,程序顺序规则也不额外要求两个动作存在数据依赖。

对上述概念、机制与边界的进一步解释见HB是推理工具。

原书依据 · 1 处

4.6.2 规则1:顺序性规则

程序顺序规则给同一线程中的动作建立HB先后,是组合跨线程证明的起点。它不要求处理器严格按源码逐条执行;只要符合规范允许的可观察行为,内部优化仍可发生。另一线程不能只凭这条规则推定看见所有写入,还需要连接线程间的同步边。本项细化前面的HB框架,不重复成卡。

4.6.3 规则2:volatile规则

对同一volatile变量的写先行发生于后续对它的读,这是把发布线程与观察线程连接起来的关键边。若先准备普通数据、再写volatile标志,而另一线程读到该标志后再读数据,便可继续用程序顺序与传递性推出数据可见。书中示例混用x与value,不能把原样代码当可编译证明;应以规则及实际读写对象为准。

对上述概念、机制与边界的进一步解释见volatile传递信号。

原书依据 · 1 处

4.6.4 规则3:传递性规则

传递性允许把已有先行关系连起来:若A先行发生于B,且B先行发生于C,就能推出A先行发生于C。发布数据的例子中,普通数据写先于volatile标志写,标志写先于观察者的后续标志读,继而连接到数据读。这种推理的前提是每条边真实成立;普通标志的表面先后不能冒充同步边。本项细化HB推理,不另拆卡。

4.6.5 规则4:监视锁规则

监视器的释放先行发生于之后对同一监视器的成功获取,因此前一个临界区的写入可以通过这把锁发布给后一个临界区。关键是同一把锁与成功获取,不能只因两段代码都加了某种锁就认定有关联。锁内部仍可保持语义地优化,同一线程也可能重入;本项为HB提供另一类跨线程边,不重复成卡。

4.6.6 规则5:start()规则

线程启动规则把启动前的准备工作发布给子线程:父线程先写好数据,再调用该子线程的start,子线程中的动作便位于这条先行关系之后。这解释了为什么启动前初始化与启动后继续修改的保证不同,后者仍需另建同步关系。原书片段省略了部分对象上下文,取其规则而不将片段当完整程序;该规则已并入HB卡。

4.6.7 规则6:join()规则

线程终止规则为等待结果提供反向连接:一个线程成功等待另一个线程结束后,可以观察到目标线程完成前的动作。join因此既是等待控制,也可成为结果发布协议的一部分。但限时join可能因超时返回,中断也可能提前结束等待,不能把所有返回路径都当作目标已完成;本项与启动规则共同补全生命周期的HB边,不另成卡。

4.7 volatile不具备原子性

volatile保证相应读写的可见性与顺序约束,却不能把“读旧值—计算—写新值”合成一个原子动作。计数、自增或检查后更新等复合操作仍需按整个不变量选择原子变量、锁或完整同步协议,并非所有volatile变量都必须配显式锁。此项回收本章的三维分析,与已有丢失更新卡合并,不重复成卡。

4.7.1 volatile变量的自增实例

自增实验让多个任务同时修改volatile long,用最终计数暴露读改写竞争。若两个任务先读同一旧值,各自计算后写回,结果就可能少于总执行次数。统计必须在全部任务完成后进行,并传播任务失败;书中文字次数与代码常量不一致,展示片段又省略等待,列出的差值只能视为特定演示,不是可复现的性能或正确性证明,因此不另制实验数字卡。

4.7.2 volatile变量的复合操作不具备原子性的原理

volatile自增失败的核心原因是多次操作之间仍可交错,而不是需要假定某一种“尚未回刷主存”的机器时序。一个线程读到值后,另一线程可能完成自己的读改写,前者随后回写基于旧值的结果,覆盖一次更新。同步边界应覆盖完整复合动作;书中read/load等抽象动作不能当成所有实现必经的物理流程。本项对前例作解释,保留在已有原子性边界卡中。

第5章 JUC显式锁的原理与实战

显式锁通过Java API执行获取和释放,把等待、取消和超时等策略交给调用方选择。与synchronized自动安排监视器进入退出相比,接口更灵活,也要求程序负责释放路径。是否更快取决于具体JDK、实现和竞争负载;本章从使用合同进入分类与实现背景,导言不另成卡。

5.1 显式锁

Lock是显式同步接口,适用于需要限时尝试、可取消等待或多个条件等待队列的路径。选择这些能力时,应先明确获取失败、超时和中断后业务怎样继续;锁的能力并不能代替调用方的协议。不同实现还可能有不同调度与中断保证,因此不能从“显式锁”名称推出统一性能优越性。本项预览功能,具体模板与Condition在后文承接。

5.1.1 显式锁Lock接口

Lock提供多种获取合同:lock等待获取,tryLock立即给出是否成功,限时tryLock允许等待到超时,可中断获取允许等待者响应取消信号。成功获取之后,临界区需要在finally中解锁;没有取得锁时,调用方应走后备路径而不是无条件unlock。方法能力与公平、调度保证须结合具体实现阅读。

对上述概念、机制与边界的进一步解释见显式锁需模板。

原书依据 · 1 处

5.1.2 可重入锁ReentrantLock

可重入表示同一线程已持有某把锁时,可以在嵌套调用中再次获取它。ReentrantLock用持有计数记录进入层数:同线程加锁增加计数,解锁减少计数,归零后其他线程才能获取。它仍是独占锁,重入只允许原持有线程再次进入,不能理解成允许其他线程共享临界区。

对上述概念、机制与边界的进一步解释见可重入锁允许自己再进。

原书依据 · 1 处

5.1.3 使用显式锁的模板代码

可靠的显式锁模板先确认获取成功,再进入try执行临界区,并在finally释放。tryLock返回false时表示本次没有取得锁,应重试、降级或返回,不能照常运行受保护代码。把可能失败或抛异常的获取过程放进无条件解锁的finally范围,会让未持锁线程错误调用unlock。本项具体化接口使用约定,与显式锁模板卡合并。

5.1.4 基于显式锁进行“等待-通知”方式的线程间通信

Condition是与某把显式锁绑定的等待通知对象。await让当前线程释放锁并等待条件,signal通知等待者去重新竞争锁,通知本身不立即交出锁。可靠协议把业务谓词的检查和修改放在同一把锁内,并用while反复检查后再await;只靠sleep安排通知顺序会丢失信号。一个锁可有多个Condition来区分等待原因,该机制在AQS条件队列中继续展开,本项不重复成卡。

5.1.5 LockSupport

LockSupport提供面向指定线程的park/unpark,是很多同步器阻塞与唤醒的基础。每线程至多保留一个许可,unpark可以先发生并预存许可,多次调用不能累积为多个许可;park也可能因中断或无理由返回,所以唤醒后须重新检查条件。park不抛中断异常,而sleep遇中断会抛异常并清除标志;这些差异决定上层等待循环怎样编写。

对上述概念、机制与边界的进一步解释见LockSupport是地基。

原书依据 · 1 处

5.1.6 显式锁的分类

锁的分类来自不同问题:重入性问持有者能否再进,共享与独占问允许多少持有者,公平性问竞争授予策略,中断性问等待能否取消,乐观与悲观描述冲突处理思路。这些维度可组合,不能把ReentrantLock使用CAS就直接称为乐观锁,也不能把共享获取等同只读。分类在具体案例中已有解释,此处不再建立术语清单卡。

5.2 悲观锁和乐观锁

悲观处理倾向于先取得排他访问再操作,乐观处理倾向于在提交时检查冲突并处理失败。共享/独占则是在问同时允许多少持有者,属于另一维度。原文此项只有独占锁与悲观锁的一句联系,没有展开可用于选型的机制,因此保留这一概念分层,后续结合CAS和等待成本讨论,不独立成卡。

5.2.1 悲观锁存在的问题

当多个线程竞争同一把锁时,未取得锁的线程可能阻塞,释放和唤醒又带来调度及上下文切换成本。若高优先级线程等待低优先级持有者,还可能出现优先级反转。成本取决于争用程度、临界区长度和调度环境,不能把它当每次加锁的固定代价,也不能据此无条件改成自旋。

对上述概念、机制与边界的进一步解释见锁竞争会带来阻塞与调度成本。

原书依据 · 1 处

5.2.2 通过CAS实现乐观锁

CAS把“当前值仍等于预期旧值才更新”作为一次原子提交。调用方可以先读取、计算,再尝试CAS;失败说明预期状态不再成立,需要重读并重新计算后重试。它减少先占锁的需要,但自旋会付出失败重试成本,单有CAS也不证明整个算法具备无锁进展保证。本项复用前章CAS知识,不重复成卡。

5.2.3 不可重入的自旋锁

自旋锁以反复检查或CAS尝试等待所有权,避免立即阻塞,却在等待期间持续消耗执行资源。不可重入版本若让持有者再次获取同一锁,就可能一直等待自己释放。书中学习代码把while(owner.compareAndSet(null,t))条件写反,CAS失败时反而退出,不能作为正确互斥实现照抄;此处只承接自旋成本与重入性的对照,不新增实现卡。

5.2.4 可重入的自旋锁

可重入自旋锁除了记录owner,还需识别当前线程是否已持有锁:若是,则增加重入计数,逐层释放到最后一次才清除所有者;其他线程继续竞争所有权。这与阻塞锁的重入语义相通,等待方式却不同。书中示例沿用反向CAS循环,未持锁时可能返回,不能用其证明锁正确;概念由可重入卡承接,不另制学习代码卡。

5.2.5 CAS可能导致“总线风暴”

多个核心频繁对同一热点状态做CAS,会造成缓存一致性通信和失败重试,竞争越多,空转的收益可能越低。把等待者排队,可减少同一时刻反复争用同一位置的线程数。书中“总线风暴”是对争用成本的简化解释,不能理解成每次CAS都锁物理总线,也不能把volatile一律等同于lock前缀指令。

对上述概念、机制与边界的进一步解释见自旋怕总线风暴。

原书依据 · 1 处

5.2.6 CLH自旋锁

CLH把竞争者排成链:线程通过CAS重试加入队尾,再观察前驱节点的释放状态,而不是所有线程持续CAS同一个owner。这样把等待观察分散到前驱状态上,但仍是自旋,长时间等待仍耗CPU,NUMA下访问远端前驱也可能有额外成本。AQS借鉴排队思想并加入可阻塞等待,不能与纯自旋CLH等同;书中学习版的性能倍数不作通用承诺。

对上述概念、机制与边界的进一步解释见CLH排队降竞争。

原书依据 · 1 处

5.3 公平锁与非公平锁

公平性关注竞争时的获取策略:公平策略偏向已经排队的等待者,非公平策略允许后来者在空闲窗口直接竞争。ReentrantLock可选择公平模式,默认使用非公平模式。这一选择不决定操作系统何时运行线程,后续实战分别展示现象,本导语不另成卡。

5.3.1 非公平锁实战

非公平锁在资源刚空闲时,允许尚未排队的新线程直接尝试获取,即使已有等待线程尚未恢复运行,也可能先被后来者抢到。结果可能有利于吞吐,却不保证先申请者先成功。书中的一组输出只是一次运行样本,线程启动顺序也不等于竞争次序;本项与公平性边界卡合并,不用日志建立调度规律卡。

5.3.2 公平锁实战

公平ReentrantLock在竞争中倾向授予等待最久的线程,但获取策略不等于CPU调度公平,也不是严格按方法调用时间执行。无参tryLock还可在锁空闲时越过等待者。书中公平演示实际使用自定义CLHLock,不能用它的一次输出验证ReentrantLock(true)合同;应把锁策略、获取方法与调度三个层次分开。

对上述概念、机制与边界的进一步解释见公平锁不约束线程调度。

原书依据 · 1 处

5.4 可中断锁与不可中断锁

可中断获取允许等待锁的线程响应中断并终止这次等待,不可中断获取则不会仅因等待期间收到中断就退出抢锁。区分应落在具体方法合同上,同一个ReentrantLock就有普通与可中断入口。这里引出取消等待的需要,后文用方法与异常路径说明,不另制分类卡。

5.4.1 锁的可中断抢占

lockInterruptibly在等待获取ReentrantLock时可因中断抛InterruptedException退出;限时tryLock还提供超时返回路径,适用于不应无限等待的业务。是否持锁决定是否解锁,而异常处理还要决定如何传播取消。中断锁内sleep时异常会清除标志,不能再凭随后isInterrupted断言此前未中断;方法语义应按实际路径判断。

对上述概念、机制与边界的进一步解释见可中断抢锁用于可取消等待。

原书依据 · 1 处

5.4.2 死锁的监测与中断

死锁可来自相反加锁顺序:线程甲持有A等待B,线程乙持有B等待A,双方都无法先释放自己等待对方所需的锁。ThreadMXBean可诊断这种等待环:findMonitorDeadlockedThreads检测对象监视器死锁,findDeadlockedThreads还涵盖ownable synchronizer,未发现时返回null且能力受JVM支持约束。检测不会自动解除死锁,中断也只有在相关等待采用可中断获取并正确清理时才能帮助退出。

对上述概念、机制与边界的进一步解释见反向获取锁会形成循环等待、死锁检测范围有边界。

原书依据 · 2 处

5.5 共享锁与独占锁

独占获取同一时刻只允许一个持有者,共享获取允许按同步器定义让多个线程成功。读写锁以共享读和独占写组合访问规则,Semaphore则以许可数限制并发占用。共享描述获取模式,不天然意味着临界区只能读;本项为后续不同工具提供比较轴,其定义已由具体工具卡承接,不另制分类卡。

5.5.1 独占锁

独占锁保护一个同一时刻只能由一个持有线程进入的临界区,其他线程必须等待或按所选方法失败退出。synchronized和ReentrantLock都提供这种互斥能力;持有者自己的重入是独立能力,不算多个线程共享。公平性又是竞争授予策略,不能从“独占”推出唤醒或调度次序,因此此处不新增重复定义卡。

5.5.2 共享锁Semaphore

Semaphore维护一组可取得和归还的许可。任务在进入受限资源前acquire,占用结束后release,许可数控制同时最多有多少任务占用资源,而不是每秒放行次数。必须只归还成功取得的许可,并在finally处理任务失败或中断后的归还;银行窗口每次约一秒的输出只是模拟负载,不是速率合同。

对上述概念、机制与边界的进一步解释见Semaphore限制共享名额。

原书依据 · 1 处

5.5.3 共享锁CountDownLatch

CountDownLatch用一个只能向零减少的计数表达“这些前置工作都结束后再继续”。工作方调用countDown,等待方await,归零后等待者可以继续;归零状态保持,不能复位再用。它不保护共享数据,也不限制并发进入名额。任务异常时应避免遗漏倒数,并另行传播失败,不能让等待归零被误当作所有任务成功。

对上述概念、机制与边界的进一步解释见CountDownLatch一次性计数。

原书依据 · 1 处

5.6 读写锁

读写锁把访问分为两个相关模式:多个读者可同时持读锁,写者持写锁时排斥其他读者与写者。只读工作因而有机会并行,但读写比例、临界区长度与锁自身成本共同决定收益。这里建立两种模式的关系,具体ReentrantReadWriteLock和转换边界由后续承接,不重复成卡。

5.6.1 读写锁ReentrantReadWriteLock

ReentrantReadWriteLock把共享读锁和独占写锁绑定到同一受保护状态,多读可以并行,写入仍须与其他读写互斥。读占多数且读段有一定开销时可能受益;写频繁会减少读并行机会,也不能据此直接认定StampedLock更合适。选择要结合写比例、等待、重试成本和实测争用,而非一次线程输出。

对上述概念、机制与边界的进一步解释见读写锁看比例。

原书依据 · 1 处

5.6.2 锁的升级与降级

锁降级让写者在更新后继续以读锁保护后续读取:持写锁时先取得读锁,再释放写锁,避免保护中断。ReentrantReadWriteLock不支持持读锁直接升级为写锁;多个读者都等待写锁时可能互等,单个读者也不能等待自己持有的读锁消失。需要写入应释放读锁、取得写锁后重新检查条件;异常路径还须保证每种锁只释放自己成功取得的次数。

对上述概念、机制与边界的进一步解释见读写锁可降级但不支持升级。

原书依据 · 1 处

5.6.3 StampedLock

StampedLock以印戳标识获取与转换,还支持不持读锁的乐观读。正确思路是先取stamp,把允许暂时不一致的字段读入局部值,再validate;失败时用悲观读重新取得一致结果。校验只能确认快照区间,不能补救校验前已经执行的不安全操作,所以书中直接读取可变HashMap的例子不能照搬。该锁不可重入,嵌套获取还需另行设计。

对上述概念、机制与边界的进一步解释见乐观读必须验证快照。

原书依据 · 1 处

第6章 AQS抽象同步器的核心原理

AQS(AbstractQueuedSynchronizer,抽象队列同步器)把同步状态管理、等待排队、阻塞与唤醒组织成可复用框架。具体锁或同步工具定义什么叫获取成功、何时释放,AQS负责围绕失败获取者协调等待。它承接前章CAS热点竞争的问题,但不能把所有JUC工具都概括成相同队列削峰方案;本章导语不另拆卡。

6.1 锁与队列的关系

同步队列保存的是未成功取得资源的线程节点。AQS借鉴CLH的排队思想,用节点链接组织竞争者,失败者可挂起,释放者通知后继,后继醒来还要重新尝试获取。队列本身不保证严格FIFO成功获取,独占释放通常通知合适后继,共享模式则可能传播。AQS把这套等待协议与子类资源语义分开,成为锁与同步器可复用的骨架。

对上述概念、机制与边界的进一步解释见AQS是同步骨架、同步队列排失败者。

原书依据 · 2 处

6.2 AQS的核心成员

阅读AQS时可先识别三个对象:state表示同步器资源状态,Node记录等待线程及链接,模板方法负责获取失败后怎样排队、等待与重试。只有state的含义由具体同步器定义,队列状态不能直接当成业务资源状态。本项建立成员与流程的关系,后续逐个展开,不新增总览卡。

6.2.1 状态标志位

AQS的state是由同步器解释的共享状态,例如ReentrantLock用它记录持有计数。volatile让状态读写具备可见性,但“读取—判断—改变”仍是复合动作,竞争性迁移需要compareAndSetState等原子手段。setState本身是赋值操作,原书所谓“不保证原子性”应理解为它不完成带条件的原子迁移;owner则另行记录独占持有线程。

对上述概念、机制与边界的进一步解释见AQS状态迁移需要CAS。

原书依据 · 1 处

6.2.2 队列节点类

Node把等待线程、前驱后继链接与等待状态组合起来,服务于队列协议。书中版本的CANCELLED表示取消,SIGNAL用于请求前驱释放时通知,CONDITION表示条件等待,PROPAGATE参与共享传播;SHARED与EXCLUSIVE标识获取模式。节点等待状态与同步器state职责不同,前者协调等待者,后者表达资源是否可获取;这些内部字段须按目标JDK版本阅读。

对上述概念、机制与边界的进一步解释见AQS节点状态协调等待。

原书依据 · 1 处

6.2.3 FIFO双向同步队列

AQS没有预先创建一个存业务任务的队列容器,而以head、tail和Node链接组织同步竞争者。无竞争的快速获取可以完全不用等待节点;出现获取失败并需要排队的线程时,才懒初始化哑元头节点并追加等待者。懒初始化减少不必要结构,队列的存在只说明同步等待结构建立,不能据此推断锁一定公平。

对上述概念、机制与边界的进一步解释见AQS队列按竞争懒初始化。

原书依据 · 1 处

6.2.4 JUC显式锁与AQS的关系

ReentrantLock、Semaphore和CountDownLatch可以复用AQS等待框架,却分别把state解释为持有次数、许可或待完成计数,因此相同骨架能服务不同同步目标。应用不能由这层关系推断每个JUC类都直接继承AQS:书中将JDK8 FutureTask列入例子并不准确,CyclicBarrier也通过锁与Condition间接利用相关机制。本项是框架应用归纳,不重复成卡。

6.2.5 ReentrantLock与AQS的组合关系

ReentrantLock对外提供Lock API,内部持有一个Sync实例,把获取和释放委托给它;Sync继承AQS,FairSync与NonfairSync再选择不同获取策略。组合把面向调用者的锁接口与内部等待框架分开,继承则让策略钩子接入模板流程。重入计数属于资源语义,公平性属于获取策略,不能混为队列结构本身的属性。

对上述概念、机制与边界的进一步解释见可重入锁组合AQS。

原书依据 · 1 处

6.3 AQS中的模板模式

模板方法把可复用流程放在基类,允许子类提供某些变化步骤。AQS中,获取失败后入队、检查等待状态、挂起与重新竞争等过程适合复用,而一次尝试能否取得资源则由子类钩子决定。这样自定义同步器不必重新实现完整排队协议;此处引出设计模式,定义和具体AQS流程分别在后文展开。

6.3.1 模板模式

模板模式区分算法骨架与可变步骤:模板方法安排流程,钩子让子类实现或替换局部行为。书中beforeAction、action、afterAction的次序是具体示例的骨架,并不能推断所有模板方法都由父类永久固定同一顺序。理解这个分工后,就能看出AQS为什么把入队等待留在基类,把资源判定交给同步器。

对上述概念、机制与边界的进一步解释见模板方法固定算法骨架。

原书依据 · 1 处

6.3.2 一个模板模式的参考实现

参考实现通过tempMethod依次调用beforeAction、action、afterAction,使调用者一次调用就走完整体流程;子类用自己的action等钩子替换某一步的行为。示例要说明的是公共流程与定制逻辑的分工,输出次序仅对应这段实现,不能推广为模板模式的唯一结构。本项具象化上一项定义,不再拆一张示例卡。

6.3.3 AQS的模板流程

AQS有独占与共享两类模板。它们都先通过相应钩子尝试获取,失败者进入等待协议,资源释放后再安排重试或传播;子类不用接管通用排队流程,而负责state怎样获取与释放。共享模式可能允许多名等待者继续,不能把所有模板压成“每次释放只唤醒一个”。书中CyclicBarrier是间接复用锁与Condition,不是直接AQS子类。

对上述概念、机制与边界的进一步解释见模板方法管流程。

原书依据 · 1 处

6.3.4 AQS中的钩子方法

AQS的钩子负责回答资源操作结果:tryAcquire和tryRelease处理独占模式,tryAcquireShared和tryReleaseShared处理共享模式。共享获取的返回值有三种含义:负数失败,零成功但不支持后续共享继续,正数成功且可能继续传播。Condition还依赖独占持有检查。实现时须按目标JDK签名与合同填写,不能把书中的long参数笔误照抄成接口。

对上述概念、机制与边界的进一步解释见AQS钩子定义资源语义。

原书依据 · 1 处

6.4 通过AQS实现一把简单的独占锁

SimpleMockLock以一个简单、不可重入的独占锁帮助读者分开观察state、owner、模板与钩子,再回到功能更完整的ReentrantLock。简化对象减少了重入、公平与条件协作的干扰,却也不能把教学实现当成完整生产锁。本项说明学习顺序,未增加同步机制,不独立成卡。

6.4.1 简单的独占锁的UML类图

简单锁的类图表达组合与继承两层关系:对外锁对象持有内部同步器,同步器继承AQS以复用排队框架。调用Lock方法时,锁对象再委托内部同步器执行。这张图只能帮助定位职责,具体获取、释放与异常行为仍要看后续方法实现;架构思想已由可重入锁组合卡承接,不重复制图卡。

6.4.2 简单的独占锁的实现

简单锁用state=0表示空闲,CAS把0改为1成功后登记owner,释放时验证持有者并恢复空闲。原文注释把0和1的含义写反,应以状态转换与代码一致的解释为准。acquire/release提供排队模板,tryAcquire/tryRelease才定义这把锁的资源规则;没有队列前驱检查的直接CAS也不能因为存在同步队列就称为公平。本项具体化已有状态与钩子卡。

6.4.3 SimpleMockLock测试用例

测试用多个线程累加同一计数,观察锁能否避免丢失更新,是SimpleMockLock的使用演示。一次得到10000不能证明所有交错、异常路径或公平性正确;可靠检查还需等待全部任务结束、传播线程内异常并断言结果。原例只打印异常与结果,本次没有执行它,因此不据其输出生成测试保证卡。

6.5 AQS锁抢占的原理

获取原理从lock入口向内跟踪:先尝试子类钩子,失败才建立等待节点,随后在队列协议内竞争与挂起。这个顺序能把“资源是否可得”与“失败后怎样等待”分开理解。此项只给展开路线,不新增概念;SimpleMockLock是否公平仍由其tryAcquire是否检查排队者判断。

6.5.1 显式锁抢占的总体流程

SimpleMockLock的lock调用内部同步器acquire(1),参数交给子类按资源规则解释。AQS先试一次获取,成功就直接返回,失败后才准备节点并进入等待循环。调用者看到的是一个lock入口,内部实际上分成资源钩子与排队模板两层;后文逐步拆解这条路径,本项不另成卡。

6.5.2 AQS模板方法:acquire(arg)

acquire先调用tryAcquire,失败才通过addWaiter排队并进入acquireQueued。不可中断获取并非忽略中断:等待过程中会记录曾经发生的中断,最终成功获取资源后再用selfInterrupt恢复标志,让上层继续处理。park返回只意味着等待暂时结束,并不代表已经拿到锁,必须回到获取条件重新竞争。

对上述概念、机制与边界的进一步解释见不可中断获取会恢复中断标志。

原书依据 · 1 处

6.5.3 钩子实现:tryAcquire(arg)

SimpleMockLock的tryAcquire用CAS尝试将state从空闲0改为占用1,只有成功者才登记当前线程为owner并返回成功。失败者把等待交给AQS模板,钩子本身不实现完整排队。该例没有可重入计数,也不检查队列前驱,不能从名称或FIFO队列推断重入与公平;状态注释的反向笔误也不能改变实际迁移语义。本项由钩子与状态卡承接。

6.5.4 直接入队:addWaiter

addWaiter为当前线程构造节点并标记独占或共享模式,优先尝试把它用CAS接到现有队尾。若tail尚空,或者更新tail的CAS失败,就转入enq循环,因此进入enq不一定说明已经发生并发竞争,也可能是首次初始化。先发布反向链接、再补正向链接的过程,还解释了后续唤醒为何需要反向查找兜底。

对上述概念、机制与边界的进一步解释见AQS竞争入队用CAS循环。

原书依据 · 1 处

6.5.5 自旋入队:enq

enq在循环中完成初始化或追加:队列尚空时先CAS建立不绑定业务线程的哑元head,再让tail指向它;队列已有节点时,当前等待者设置prev并CAS更新tail,失败就重读队尾继续尝试。新等待节点不会直接充当初始哑元头。此项展开addWaiter的慢路径,与入队循环卡保留同一算法,不重复成卡。

6.5.6 自旋抢占:acquireQueued()

acquireQueued把等待者放在循环里:只有前驱是head时才尝试tryAcquire;成功后把自己设为新head并断开旧头,否则检查前驱状态,必要时park。唤醒后再回到循环,既可能再次失败,也可能记录中断。这里的“自旋”包含可阻塞等待,不能想成所有排队线程始终忙转;成功节点清空线程后成为新的队首标记。本项机制由挂起与队首卡承接。

6.5.7 挂起预判:shouldParkAfterFailedAcquire()

线程park之前必须先与有效前驱建立通知约定。shouldParkAfterFailedAcquire跳过已取消前驱;看到前驱已为SIGNAL才允许挂起。若前驱尚未准备好,本轮只CAS设置SIGNAL并返回false,让获取流程重试,之后再次确认才可能park。这个协议减少错过释放通知的风险,不能把首次设置状态等同立即挂起。

对上述概念、机制与边界的进一步解释见挂起前要确认前驱。

原书依据 · 1 处

6.5.8 线程挂起:parkAndCheckInterrupt()

parkAndCheckInterrupt调用LockSupport.park暂停当前线程,返回后用Thread.interrupted检查并清除中断标志。不可中断获取把这个结果累计起来,等拿到资源后再恢复标志;可中断获取则有不同退出合同。unpark只提供继续运行的机会,返回后仍要复查获取条件。本项补全等待循环,与前面的中断恢复及挂起卡合并,不再拆卡。

6.6 AQS的两个关键点:节点的入队和出队

理解队列变化可以沿两个时点:获取失败者怎样接到队尾,已经排队的线程怎样在成功获取后推进队首。入队、释放通知和成功获取不是同一个动作,分清它们才能理解指针为何在不同线程中变化。本项为后续复述建立观察点,没有新增定义,不单独成卡。

6.6.1 节点的自旋入队

入队循环先解决空队列初始化,再解决已有队尾的并发追加:通过CAS建立哑元head,随后等待节点以prev指向旧tail并尝试成为新tail,失败就重试。哑元头不绑定当前等待线程,后续获取成功的节点才会成为新头。本项重复enq机制,用于串联队列变化,已有入队循环卡完整承接。

6.6.2 节点的出队

等待者出队发生在成功获取路径:只有前驱已是head且自己的tryAcquire成功,当前节点才晋升新head并断开旧头。释放者负责发出唤醒,不能替被唤醒者完成资源获取。把“通知继续竞争”与“成功推进队首”分开,就能解释为什么唤醒不保证立即持锁,也不能用排队次序代替成功顺序。

对上述概念、机制与边界的进一步解释见AQS成功获取后推进队首。

原书依据 · 1 处

6.7 AQS锁释放的原理

释放路径从unlock进入release,再由子类tryRelease改变资源状态,必要时通知等待者。状态释放与队首推进属于不同路径:释放者让资源可用,后继随后竞争成功才更新head。本项只是释放机制的导引,具体所有权验证与唤醒选择在后续展开,不新增卡。

6.7.1 SimpleMockLock独占锁的释放流程

SimpleMockLock把unlock委托给release(1),release先调用具体tryRelease;资源真正释放后,模板检查队列是否需要通知并调用unparkSuccessor。流程串起了三个职责:公开锁API、子类资源状态变更、AQS等待通知。通知之后原线程可以继续执行,被通知者还要重新竞争;此处是既有模板与释放机制的总览,不重复成卡。

6.7.2 AQS模板方法:release()

release的返回结果来自资源释放钩子:只有tryRelease报告资源已经可释放,模板才继续检查头节点并在需要时通知后继。对子类而言,“减少一次重入计数”与“资源完全释放”可能不同,因此返回值必须表达本次释放的同步含义。模板统一组织后续等待通知,资源合同留在子类;该分工已由模板卡承接。

6.7.3 钩子实现:tryRelease()

独占释放必须先验证当前线程是持有者,否则应拒绝释放,避免其他线程擅自打开临界区。SimpleMockLock校验后清除owner,并把state恢复为0;只有持有者负责这一状态变更时,才可按该简单锁协议不使用竞争CAS。可重入锁还需先递减持有计数,最后一层才真正释放,不能把清零模板套给所有同步器。

对上述概念、机制与边界的进一步解释见独占释放验证持有线程。

原书依据 · 1 处

6.7.4 唤醒后继:unparkSuccessor()

unparkSuccessor优先看当前节点的next;若正向链接暂未补齐,或后继已取消,就从tail沿prev逆向扫描,保留最靠前的有效候选,再唤醒其线程。反向链接兜底与入队时指针发布顺序相呼应。书中这版实现以状态不大于零筛选候选,具体内部协议要按JDK版本阅读;被唤醒者仍需获取成功才推进head。

对上述概念、机制与边界的进一步解释见唤醒时逆向查有效后继。

原书依据 · 1 处

6.8 ReentrantLock的抢锁流程

ReentrantLock仍把获取操作交给内部Sync,差别在于使用FairSync还是NonfairSync。两者共享AQS排队与重入的基本框架,空闲时是否先检查排队前驱则决定是否允许后来者直接竞争。后续分别观察入口与钩子,能避免把公平性误当作Node队列的自然属性。本项重复组合与策略总览,不另成卡。

6.8.1 ReentrantLock非公平锁的抢占流程

非公平抢占流程先给当前线程一次直接CAS获取空闲状态的机会,失败后才进入AQS的acquire与排队等待。这样新线程可能在原等待者尚未恢复运行时抢到刚释放的锁。此项主要给流程图入口,下一项源码展开同一路径,因此不新增图示卡。

6.8.2 非公平锁的同步器子类

NonfairSync的lock先CAS尝试把state从0改为占用,成功便登记owner;失败再调用acquire进入通用模板。这个入口没有先询问队列中谁等得更久,因此存在后来者插队机会。排队仍然发生,只是不作为所有获取的先决条件;本项把非公平定义落到实现路径,与公平性边界卡合并。

6.8.3 非公平抢占的钩子方法:tryAcquire(arg)

非公平获取钩子在state=0时直接CAS,不先检查排队前驱;state非零时,若当前线程正是owner,便增加持有计数完成重入。空闲争抢和持有者重入是两个分支,队列位置不能代替所有权检查。钩子只决定资源获取策略,失败后的等待仍由AQS负责;这些职责已由公平性、重入与钩子卡承接。

6.8.4 ReentrantLock公平锁的抢占流程

公平抢占流程把排队资格检查放到实际资源竞争之前,使新线程在已有有效前驱时进入等待,而不是只看state空闲就抢。流程图在这里提供阅读路线,具体判断位于后续tryAcquire与hasQueuedPredecessors,因此不另制流程图卡,也不据图保证线程严格按时间运行。

6.8.5 公平锁的同步器子类

FairSync的lock直接进入acquire模板,没有非公平入口那次绕过前驱检查的快速CAS。不过acquire本身仍先尝试钩子,并非所有线程都必须实际入队;真正决定空闲时可否获取的是公平tryAcquire中的前驱检查。本项连接入口与策略实现,细节与后续公平获取卡合并。

6.8.6 公平抢占的钩子方法:tryAcquire(arg)

公平tryAcquire在state=0时先调用hasQueuedPredecessors,确认没有排在当前线程之前的等待者,才尝试CAS获取。若state非零且current就是owner,则进入独立的重入分支增加计数。排到首位只是空闲时有资格竞争,不等于已经持锁;公平队列位置与持有者身份必须分别判断。

对上述概念、机制与边界的进一步解释见公平获取先检查队列前驱。

原书依据 · 1 处

6.8.7 是否有后继节点的判断

hasQueuedPredecessors从head、tail及head.next判断当前线程前面是否还有等待者。队列非空而next尚未发布时,应保守视作有人等待,避免利用链接窗口插队;若首个等待节点就是当前线程,则可认为它没有排队前驱。首位只表示竞争资格,不是已持锁或可重入的证明。本项是公平钩子的细化,保留在同一张卡中。

6.9 AQS条件队列

Condition为显式锁提供按条件等待的接口:线程先因业务条件不满足而离开锁竞争,收到通知后再进入竞争。这里要分清“条件等待”和“争取同步资源”,前者等待谓词变化,后者等待拿到锁;后文通过两种队列展示迁移,本导言不另成卡。

6.9.1 Condition基本原理

每个ConditionObject维护自己的条件等待链,一个Lock可以创建多个Condition,例如分别等待“不空”和“不满”。AQS同步队列则组织重新获取同一同步器的线程。signal把合适的条件等待节点转入同步队列,之后该线程还要竞争锁;分队列能区分等待原因,但业务谓词与循环复查仍由应用负责。

对上述概念、机制与边界的进一步解释见条件队列分离等待。

原书依据 · 1 处

6.9.2 await()等待方法原理

await先把线程节点放入条件队列,保存并完整释放当前同步状态,让其他线程有机会修改业务条件。收到signal并转入同步队列后,线程用保存的状态重新获取锁,成功后await才返回,因此返回时仍持有相应锁。调用方必须在while里复查谓词,因为通知并不预留业务资源,等待还可能被其他原因打断。

对上述概念、机制与边界的进一步解释见await释放并重获锁。

原书依据 · 1 处

6.9.3 signal()唤醒方法原理

signal须在持有绑定锁时调用,它检查独占持有并把条件队列中的有效等待节点转到同步队列。调用者仍持锁,signal不会等待被通知线程取得锁,也不会把业务条件变成必然满足。被通知者只有之后重新竞争成功才能从await继续,并再次检查条件;此项与条件队列卡合并,不重复建立“立即唤醒执行”的错误模型。

6.10 AQS的实际应用

AQS把底层CAS、volatile等同步能力组织成状态与等待协议,ReentrantLock、Semaphore等上层同步器再赋予这些状态具体语义。锁与Condition还可被阻塞队列等组件复用,形成层层组合的并发基础设施。图中的依赖层次不意味着所有并发类都直接继承AQS,更不意味着共享获取都保护只读数据;本项收束本章,不另生成工具清单卡。

第7章 JUC容器类

列表、集合、队列和映射分别组织有序元素、去重成员、交接次序与键值关系。普通 ArrayList、LinkedList、HashMap 的结构更新不能直接交给多个线程同时操作;同步容器用互斥保护操作,并发容器则按访问模式进一步安排读写。本章从保护方式走向复制快照、满空等待和分散写入热点。这一项只是问题和路线的导言,没有额外的独立机制需要成卡。

7.1 线程安全的同步容器类

同步容器把访问基础容器的操作放进同一监视器的临界区;Collections 的包装器在获得锁后把实际操作委托给原容器。这样能保护经由包装器发起的方法调用,但也会让原本互不相关的访问争用同一把锁。争用成本取决于负载和 JDK 实现,不能按书中旧锁状态模型断言每次竞争都进入内核。同步容器锁太粗说明这种锁粒度的取舍。

原书依据 · 1 处

7.2 JUC高并发容器

并发容器需要按数据和操作模式选择。读多写少的列表可用写时复制;键值并发访问可用 ConcurrentHashMap;需要有序键集合时可考虑跳表家族;生产消费交接则需考虑普通队列还是阻塞队列。它们不是统一的“无锁”实现:复制列表仍会串行化写者,阻塞队列也可能依靠锁和条件等待。因此先判断读写比例、顺序、容量及失败策略,再比较性能,见并发容器选模型。

原书依据 · 1 处

7.3 CopyOnWriteArrayList

写时复制把读者正在使用的数据保留为稳定版本,修改者在副本上完成变化,再发布新版本。CopyOnWriteArrayList 将这种思路用于数组列表:没有写入时多个读者共享同一数组,写入时付出复制成本,换取读取无需等待写者。它适合读多写少、规模可控并可接受快照陈旧的场景;具体数组发布与迭代机制在后续展开,本项不重复拆卡。

7.3.1 CopyOnWriteArrayList的使用

同步包装与列表能否改变大小是两种能力。书中先用 Arrays.asList 建立固定大小列表,再包装为 synchronizedList;包装器增加同步,却不能使底层列表支持 add,因此此例的 UnsupportedOperationException 不能证明“同步列表不能边迭代边写”。使用可变列表还需整体同步遍历,而 CopyOnWriteArrayList 以快照支持遍历期间的外部写入。同步包装不改变可变性保留这一区分;原例循环没有推进迭代器,也不能直接作为完整可运行的遍历模板。

原书依据 · 1 处

7.3.2 CopyOnWriteArrayList的原理

CopyOnWriteArrayList 持有底层数组引用 array。修改先复制数组,在新数组上完成变化,最后把引用换到新数组;旧数组只要仍被读者持有就继续有效。书中实现的 ReentrantLock 让写者串行,防止两名写者从同一旧版复制后互相覆盖;volatile array 则负责让新引用安全发布给不取写锁的读者。这两个职责不能互相替代,详见写时复制偏向读与写者串行与引用发布。

原书依据 · 2 处

7.3.3 CopyOnWriteArrayList读取操作

读取一个位置时,get 先取得当前 array 引用,再从该数组取元素。因为写者另建数组而不原地修改这个数组,已经拿到旧引用的读取可以安全继续;新引用发布后,后来的读取则可能看到新版本。一次 get 的读取对象与一轮迭代的快照并不相同,连续多次 get 也不自动构成同一快照。该机制已由写时复制偏向读承接,不另建重复卡。

原书依据 · 1 处

7.3.4 CopyOnWriteArrayList写入操作

add 在独占写锁内取得旧数组、复制出多一个槽位的新数组、写入元素,再发布新引用并解锁。写锁避免写者覆盖彼此结果,读者仍可访问旧数组。代价是复制时间与临时内存随列表大小增长;因此“可以并发读取”不能推出适合高频写入。写者串行与引用发布与写时复制偏向读已覆盖这两种取舍,本项把它们落实到 add 的步骤。

原书依据 · 2 处

7.3.5 CopyOnWriteArrayList的迭代器实现

快照迭代器在创建时保存当时的数组引用,并通过自己的游标读取该数组。后续写入发布另一数组,不会改变已创建迭代器的内容,所以遍历能稳定完成,却看不到创建之后的新增或删除。若需要新状态,应重新取得迭代器;这种稳定性针对数组中的成员关系,不表示元素对象自身不可变。迭代器固定数组快照进一步解释稳定视图与实时视图的差别。

原书依据 · 1 处

7.4 BlockingQueue

BlockingQueue 是生产者和消费者交接元素的接口。生产者把待处理数据放入队列,消费者从中取出;队列将数据存储与等待协调放在一起,使业务方不必每次手写满空条件的通知协议。本项只引出这种协作用途,下一项再区分哪些操作会等待,相关知识复用后续的背压卡。

7.4.1 BlockingQueue的特点

阻塞添加让生产者在有界队列没有空位时等待,阻塞删除让消费者在队列没有数据时等待。这样,暂时的速度差可以转化为等待,而不是不断检查条件。这里的行为具体对应 put 和 take;add、offer 等方法有不同的失败处理,不能因为容器名有 Blocking 就假定所有调用都阻塞。阻塞队列管背压同时指出容量和所选方法才决定能否限制积压。

原书依据 · 1 处

7.4.2 阻塞队列的常用方法

队列不能立即完成操作时,调用方可选择抛异常、返回特殊值、一直等或限时等。插入的常见对应是 add、offer、put、offer(timeout),移除对应 remove、poll、take、poll(timeout)。选择策略时需要先决定满载是错误、可检查的失败,还是允许等待的状态。无参 poll 立即返回元素或 null,不声明 InterruptedException;限时 poll 才涉及可中断等待。阻塞队列四种操作策略把这些契约放在一起比较。

原书依据 · 1 处

7.4.3 常见的BlockingQueue

ArrayBlockingQueue 用定长数组和同一把锁保护两端,LinkedBlockingQueue 用链式节点与分离的两端锁,后者需显式指定合理容量,详见数组与链式队列的取舍。PriorityBlockingQueue 按优先级提供元素,DelayQueue 则让未到期元素继续等待,见延迟队列等待到期;两者的无界性质意味着不会因容量耗尽而阻塞生产者,无界队列不提供背压说明内存积压风险。SynchronousQueue 则没有存储缓冲,交接须有另一端配合。公平模式约束等待者的获取次序倾向,不是 CPU 调度或完成顺序保证。

原书依据 · 3 处

7.4.4 ArrayBlockingQueue的基本使用

生产消费示例用 ArrayBlockingQueue 代替手写的共享缓冲和条件等待,但业务包装方法仍决定最终语义。书中称生产者满载时会等待,代码 DataBuffer.add 实际调用 add(element),满载会抛异常;若要等待空位应选 put。消费者 take 则会等到有元素后移除。这个例子是阻塞队列管背压和阻塞队列四种操作策略的应用,不产生新的等待机制,也不能用样例日志证明满载行为正确。

原书依据 · 2 处

7.4.5 ArrayBlockingQueue构造器和成员

环形数组把固定空间反复利用:putIndex 指向下一次插入位置,takeIndex 指向下一次移除位置,count 区分空与满。索引到末尾后回绕到零,状态在同一把锁内更新,见读写索引分工。notFull 保存等待空位的生产者,notEmpty 保存等待数据的消费者;条件队列区分等待原因,仍共享同一把锁。构造器的 fair 选项改变等待访问次序的取舍,不代表不同的存储结构。

原书依据 · 1 处

7.4.6 非阻塞式添加元素:add()、offer()方法的原理

非阻塞添加是不等待队列空位,并非整个方法无锁。offer 取得锁后检查 count,满时返回 false;add 将插入失败转为异常。成功时把元素写入 putIndex、推进并回绕索引、增加 count,再调用 notEmpty.signal 通知等待消费者。书中正文的 notFull.notEmpty 是笔误。该步骤连接了阻塞队列四种操作策略的失败契约与读写索引分工的存储更新,不需重复生卡。

原书依据 · 2 处

7.4.7 阻塞式添加元素:put()方法的原理

put 使用可中断方式取得 ArrayBlockingQueue 的同一把 lock,满时在 while 循环中 await notFull,释放锁等待。出队者发出通知后,生产者还要重新竞争锁并复查是否已有空位,才能真正插入,随后通知 notEmpty。书中步骤误称 putLock,那属于另一种队列的双锁命名;此处不能混用。可等待的容量约束由阻塞队列管背压承接,这里解释其条件等待过程。

原书依据 · 1 处

7.4.8 非阻塞式删除元素:poll()方法的原理

poll 在锁内检查元素数,空队列立即返回 null;非空则取出 takeIndex 位置的元素,将槽置空,推进并回绕 takeIndex,减少 count,再通知 notFull 上等待空位的生产者。清槽让队列不再持有已经移除的元素;推进索引保持下次消费位置。这些步骤是读写索引分工与阻塞队列四种操作策略的具体实现,没有新增独立卡片。

原书依据 · 2 处

7.4.9 阻塞式删除元素:take()方法的原理

take 与 poll 的主要差别在空队列时:take 可中断地获取锁,在 count 为零时循环 await notEmpty,等获得锁并确认有数据后再移除。成功出队又释放一个容量名额,通知等待生产者。通知只是重试条件的机会,不能代替 while 复查;抢锁和条件等待都须考虑中断。该过程延续阻塞队列管背压,复用已有等待机制卡,不重复拆卡。

原书依据 · 1 处

7.4.10 peek()直接返回当前队列的头元素

peek 取得锁后读取 takeIndex 位置,但不清槽、不推进索引、不减少 count;队列为空时返回 null。它回答的是“调用这一刻队首是什么”,并没有替调用方保留消费权,另一线程随后仍可能取走该元素。因此后续业务不能用一次 peek 判断代替实际取出操作的结果,见peek只观察不占有队首。

原书依据 · 1 处

7.5 ConcurrentHashMap

ConcurrentHashMap 是为并发键值访问设计的映射。理解其性能不能只说“加了锁”:JDK 7 让写者按 Segment 分散竞争,JDK 8 把结构与更新协调进一步下移到桶,并保留不获取写锁的读取路径。它们是版本不同的内部实现,后续依次解释;本项只是版本对照,不额外成卡。

7.5.1 HashMap和HashTable的问题

HashMap 不为并发结构修改提供同步;当多个线程访问且至少一方结构性增删时,需要外部协调或使用合适的并发映射。书中死循环属于旧实现风险,不能泛化到所有 JDK。Hashtable 通过同步方法保护整体映射,虽然解决单方法互斥,也使不同键的访问可能争用同一锁。HashMap并发修改需要同步说明安全边界,这也引出了缩小锁粒度的动机。

原书依据 · 1 处

7.5.2 JDK 1.7版本ConcurrentHashMap的结构

JDK 7 的表分为两层:外层 Segment 数组划分竞争区域,每个 Segment 继承 ReentrantLock,并持有 HashEntry 桶数组;同一桶中的映射再由链表连接。写入只锁所在段,而非整张表,也并非每桶一锁。默认并发参数只是配置起点,实际并发还取决于键是否分散到不同段。JDK7并发哈希表两层分桶提供结构定位。

原书依据 · 1 处

7.5.3 JDK 1.7版本ConcurrentHashMap的核心原理

JDK 7 的 get 按哈希定位段和桶,通过带 volatile 语义的数组槽读取及链表遍历查找,不获取段锁,见JDK7并发映射读路径不取段锁。这要求节点和链路有正确的发布语义;原书把 next 写成 final 却又调用 setNext,是混版矛盾,实际可变链路的边界由可变链路须安全发布解释,不能复制其片段作为实现。

写入在目标 Segment 的锁下执行。put 覆盖已有值,putIfAbsent 仅在键缺失时建立映射,两者通过 onlyIfAbsent 区别,见两种写入语义不同。锁竞争时 scanAndLockForPut 可先扫描桶并准备候选节点,获得锁后继续完成插入;这把部分准备工作移出持锁区,见抢段锁时扫描可复用准备。书中全段初始化与后文懒建 Segment、next 声明与接链代码都不一致,因此这里只保留已核实的分段协调与预扫描意图。

原书依据 · 4 处

7.5.4 JDK 1.8版本ConcurrentHashMap的结构

JDK 8 去掉 Segment 层,table 直接保存桶;空桶发布可用 CAS,非空桶修改在桶的范围内协调,将无关键的写入热点进一步分散。桶既可为普通 Node 链表,也可为树桶。树桶放在 table 槽中的对象是 TreeBin,它管理由 TreeNode 构成的树,不能把两者混作一种节点,见树桶容器与树节点不同。与 JDK 7 的锁粒度差异由CHM分段到桶锁统一说明,并非所有写入都无锁。

原书依据 · 2 处

7.5.5 JDK 1.8版本ConcurrentHashMap的核心原理

JDK 8 的 table 按需初始化,sizeCtl 协调初始化和扩容状态,而不是普通元素计数;扩容线程分工迁移,已迁移桶以 ForwardingNode 标记,遇到迁移的更新线程可协助,见sizeCtl协调扩容。桶过长时还要判断表容量:向已有至少八个节点的桶再插入时考虑树化,容量不足 64 则优先扩容,详见树化阈值与数组容量分开判断。普通 Node 的 hash/key 固定,val/next 可见地更新,Node固定键并可见值链说明这与读取路径的关系。

原书依据 · 3 处

7.5.6 JDK 1.8版本ConcurrentHashMap的核心源码

putVal 按桶状态分流:表未建立先初始化;空桶用 CAS 发布;遇迁移标记则协助扩容;非空桶先锁桶首,再在锁内复查该槽仍指向它,之后才更新链表或树。这次复查防止等待锁时桶已变化,见非空桶写入先锁定再复核。get 不取桶锁,而以 volatile 语义读取槽位,按键和节点类型查找,见JDK8并发映射读取不加锁;不加写锁仍依赖可见性约束,并不意味着普通数组读取就足够安全。

原书依据 · 2 处

第8章 高并发设计模式

并发设计模式分别处理共享对象创建、任务拆分、工作分配、速率缓冲和结果获取。传统单例需要补上创建与发布的线程安全;大任务可递归拆小以利用多核;生产消费与 Master-Worker 则组织任务交接。本项仅指出本章的这些问题,不给出新实现,因此作为后续各模式的导言而不另成卡。

8.1 线程安全的单例模式

单例用于管理共享的全局对象,例如配置、调度器或连接池。要判断一个实现是否合格,既要检查实例是否只创建一次,也要检查初始化和引用发布是否安全;如果对象本身还会变化,其后续并发访问也需要单独设计。单例唯一性与线程安全分开看提醒读者,模式名称不是线程安全的证明。

原书依据 · 1 处

8.1.1 从饿汉式单例到懒汉式单例

饿汉式把对象放在静态初始化过程中创建,写法直接;懒汉式则推迟到首次使用。延迟的代价是多个调用者可能同时看到 instance 为 null,分别创建对象,再覆盖共享引用。单独的判空不能把“检查再创建”变成不可分割的动作,所以懒加载不等于安全单例,见懒加载判空不能保证单例。

原书依据 · 1 处

8.1.2 使用内置锁保护懒汉式单例

把 getInstance 声明为静态 synchronized 方法,会在同一监视器内完成判空与创建,阻止线程同时进入初始化路径。实例已经存在后的访问也仍经过同步方法,这是保护范围较大带来的热路径成本。成本大小应结合运行时与争用判断,不能把 synchronized 一概等同于重量级锁;同步单例也会锁热路径保留这种正确性与访问成本的取舍。

原书依据 · 1 处

8.1.3 双重检查锁单例模式

双重检查希望让已初始化实例走锁外快速返回路径:先判空,未初始化才获取锁,进入锁后再判一次空,避免等待锁期间另一线程已经创建对象。第二次判断负责防止重复构造,却不能独自解决锁外读取的安全发布。书中方法仍声明 synchronized,与其快路径文字不符;双检需锁内复查说明设计意图,完整条件由下一项补齐。

原书依据 · 1 处

8.1.4 使用双重检查锁+volatile

DCL 的另一问题是对象尚未初始化完整时,引用就可能对无锁读者可见。正确声明的 volatile instance 将引用发布与后续读取联系起来,使读者能观察到发布前的初始化写入;锁内复查则继续负责唯一创建,两者解决不同问题。原书虽然在文字要求 volatile,完整示例却漏掉字段修饰且保留同步方法,不能照抄为 DCL 模板,见DCL必须配volatile。

原书依据 · 1 处

8.1.5 使用静态内部类实现懒汉式单例模式

静态内部类方案把实例放在 LazyHolder 的静态字段中,首次访问该字段才触发持有类初始化。虚拟机协调类初始化的执行和完成后的可见性,因此既能延迟构造,又不用手写 DCL 的检查与发布协议。安全性来自类初始化语义,不能仅归因于 final。静态内部类延迟说明它与前两种懒汉实现的关系。

原书依据 · 1 处

8.2 Master-Worker模式

Master-Worker 把接收分配任务与实际执行分开:Master 管理任务入口、分派和结果归并,Worker 处理所分得的工作。它适用于任务能够独立执行、结果能够按业务规则合并的场景。架构图规定的是角色,不规定必须多少线程、如何处理失败或缓冲多少任务;这些选择要到具体实现中补足,本项不另建重复模式卡。

8.2.1 Master-Worker模式的参考实现

参考实现用 Master 队列接收任务,由调度线程轮流分给各 Worker 的局部队列;Worker 执行完通过回调将结果交回,Master 保存结果并累加,见Master拆分调度。两层无参 LinkedBlockingQueue 都缺少实际容量约束,持续过载仍会耗尽内存,详见Master双层队列须限容量。周期打印只读到当前结果快照,异常任务还可能不回调;归并结果需要完成信号指出必须定义批次的成功、失败和终结条件,不能把一次打印当全批完成。

原书依据 · 3 处

8.2.2 Netty中Master-Worker模式的实现

Netty 服务端将接入连接与已有连接的 I/O 分工。Boss EventLoopGroup 监听并接受新连接,Worker 组中的 EventLoop 轮询子通道事件,再交给 Handler 处理输入输出。EventLoop 内部线程执行事件轮询与分发,组负责组织多个 EventLoop;这是对调度与执行职责的映射,并不是与通用 Master/Worker 类的继承关系。工作线程处理IO保留该框架案例。

原书依据 · 1 处

8.2.3 Nginx中Master-Worker模式的实现

书中 Nginx 案例把管理职责放在 Master 进程:加载配置、启动和监管 Worker、处理外部信号并向 Worker 传递信号,创建监听套接字供 Worker 使用。Worker 负责接入连接并读取、解析、处理请求和返回响应。这个进程分工说明管理与请求执行可以分离,不能把本节未注明版本的每项细节推广为所有部署,见Nginx管理监听与工作进程。

原书依据 · 1 处

8.3 ForkJoin模式

分治先把问题拆成较小部分,分别求解,再把局部答案组合成整体答案。ForkJoin 将拆分职责放进工作任务:Worker 可以继续把大任务递归拆小,直到直接求解,而不是由单一 Master 逐项分派。这样产生了任务之间的父子依赖,也产生了各工作队列负载不均的问题;后续用 join 和窃取分别处理。分治池没有中心调度说明它与 Master-Worker 的角色差异。

原书依据 · 1 处

8.3.1 ForkJoin模式的原理

拆出子任务只完成了工作分配,父任务还需要取得它们的结果并按业务规则归并。书中以双端任务队列和结果队列画出概念流程;实际 ForkJoinPool API 不要求统一的结果队列,而通过 fork 提交、join 取得任务结果。子任务结果仍需归并区分这层示意与 API 契约,避免把并行执行误当作整体答案已经形成。

原书依据 · 1 处

8.3.2 ForkJoin框架

ForkJoinPool 提供执行资源,ForkJoinTask 表达可执行且可取得结果的任务。通常按任务结果契约选择基类:有结果继承 RecursiveTask,无业务结果继承 RecursiveAction。compute 判断规模,足够小直接执行,否则拆分、fork 子任务并通过 join 协调完成;结果型任务再组合子结果。递归任务按结果选基类把类型选择与递归骨架连接起来。

原书依据 · 1 处

8.3.3 ForkJoin框架使用实战

求和示例把区间分成左右两段,分别 fork 后 join,再把两个局部和相加;叶任务直接循环累加。由于循环包含 start 与 end 两端,实际元素数是 end-start+1,而代码用 end-start 与 THRESHOLD 比较,叶任务可能比文字阈值多处理一项。这影响粒度口径,不使求和结果错误,见闭区间阈值差一个元素。

原书依据 · 1 处

8.3.4 ForkJoin框架的核心API

ForkJoinPool 的 parallelism 是目标并行水平,不能当最大线程数,见并行度不是线程硬上限。asyncMode 决定本地队列的 FIFO/LIFO 策略,不等于调用是否同步,也不能据其名称断言任务能否 join,见asyncMode控制队列顺序。外部 invoke 等待并返回结果,execute 只安排执行,submit 返回可继续取结果的句柄;内部子任务用 fork,这些调用契约由分治提交契约不同区分。

原书依据 · 3 处

8.3.5 工作窃取算法

每个工作线程拥有本地任务队列,忙闲不均时,空闲线程可扫描其他队列尝试领取尚未执行的任务。常见本地后进先出、他队先进先出的两端策略减少双方对同一位置的竞争,详见工作窃取补负载。减少争用不代表不会失败:目标任务可能已被队主取走,窃取任务是一场竞争说明一次领取失败不是任务执行失败,更不授权重复执行。

原书依据 · 2 处

8.3.6 ForkJoin框架的原理

join 等待子任务时,ForkJoin 工作线程可能帮助推进计算:尚未被其他线程接手的子任务可由自己执行;已被窃取时,则处理其他可运行任务。这把部分被动等待转为有效工作,见等待子任务时继续干活。它是协作调度策略,不能像原书的绝对表述那样保证永不阻塞;慢 I/O 仍可能占住工作线程,因此不能仅凭有工作窃取就把它当任意阻塞任务池。

原书依据 · 1 处

8.4 生产者-消费者模式

生产者把生成的数据交给缓冲区,消费者按自己的节奏取出并处理,双方不必直接调用对方的具体实现。缓冲还可吸收短暂的速率差,见缓冲区隔离生产消费依赖。但缓冲只延迟失衡的影响,不能消除长期生产过快的问题;有界缓冲满时需要等待或拒绝,空时消费者需要等待数据,这与前章阻塞队列的容量和方法选择相接。

原书依据 · 1 处

8.5 Future模式

Future 模式先返回表示未来结果的对象,使发起方能继续其他工作,到真正依赖结果时再 get。任务已经完成则可直接取值,尚未完成则等待;JDK Future 本身不承诺完成回调。三次各耗时 500 毫秒的 RPC 理想并行可重叠为约 500 毫秒,这忽略网络、发起与调度成本,不能当测量保证。Future先给契约连接了任务发起、结果句柄和下一章完成通知的问题。

原书依据 · 1 处

第9章 高并发核心模式之异步回调模式

多个上游系统的请求往往可以同时发出,但下游业务仍须知道哪些结果已经就绪。Future 将任务发起与取值分离;回调进一步让完成事件主动触发后续处理。本章以泡茶依赖说明这种通知差异,再比较 JDK 主动等待、Guava 与 Netty 的完成监听。本项只提出问题与路线,不另造调度或汇合机制卡。

9.1 从泡茶的案例讲起

泡茶依赖两项准备:清洗茶具和烧水。它们互不依赖,可以并行;泡茶却必须等待两者都具备条件。并发能够缩短可重叠路径,不能删除真正的业务依赖,因此必须为汇合点选择等待或通知机制。独立任务并行后再汇合用两条前置边展示这个结构,后文只是替换它的实现方式。

原书依据 · 1 处

9.2 join:异步阻塞之闷葫芦

对目标线程调用 Thread.join,会让调用线程等待目标线程终止;被等待的线程继续运行。所谓“合并”表达的是继续执行的依赖关系,不是把两条线程的数据自动合成结果。本项是后续例子的简短定义,已由主动调用会阻塞承接,不另成卡。

原书依据 · 1 处

9.2.1 线程的合并流程

先启动烧水和清洗线程,再分别 join,两项准备可以在主线程等待时并行推进。主线程依次执行两次 join 并不意味着子任务因此串行:只要它们已启动,就可能同时运行。第二次 join 返回后才能继续泡茶,但这还只证明线程终止,结果成功与否需要另有信号。双前置关系复用独立任务并行后再汇合,不新增结构卡。

原书依据 · 1 处

9.2.2 调用join()实现异步泡茶喝

join 版代码让主线程启动两项准备,再等待它们结束。示例子线程在 sleep 被中断后只记录中断并退出,主线程的 join 仍可能正常返回,因此“已结束”不能直接作为“准备成功”。这暴露了线程生命周期与业务结果的区别,join只等待不返回结果承接这一限制;模拟延迟和日志也不能当真实执行耗时或成功证明。

原书依据 · 1 处

9.2.3 join()方法详解

无参 join 等待目标线程终止;限时重载只限制调用方等多久,到时目标线程仍可能运行。join 返回 void,不交付计算结果,更不保证目标的业务工作成功。若后续步骤需要根据结果作决定,应使用 FutureTask 等结果契约,见join只等待不返回结果。书中把等待循环称为低效不能证明忙轮询,条件等待与反复占 CPU 检查需要区分。

原书依据 · 1 处

9.3 FutureTask:异步调用之重武器

Runnable 描述动作而不返回业务值,Callable 的 call 可以产生结果。FutureTask 将这样的计算包装为既可由线程执行、又可通过 Future 接口读取结果的对象,补足 join 只能等结束的限制。本项回顾第一章已经展开的任务与结果桥接,没有新增机制;下面将这种结果契约用于泡茶条件判断。

9.3.1 通过FutureTask获取异步执行结果的步骤

取得 FutureTask 结果的操作链是:编写返回结果的 Callable,把它包装成 FutureTask,将该对象交给 Thread 执行,发起方继续独立工作,依赖结果时调用 get。包装不会自动启动线程;get 在未完成时也仍会等待。该步骤是既有任务句柄的使用回顾,结果发起与获取的关系由Future先给契约承接,不再拆出操作清单卡。

原书依据 · 1 处

9.3.2 使用FutureTask实现异步泡茶喝

FutureTask 版让烧水和清洗分别返回 Boolean,主线程读取两个结果,仅在二者成功时才执行泡茶。这样业务条件来自任务结果,不再从线程退出推断成功。两个任务可以先并行启动,即使主线程之后依次 get,也不改变已经发生的并行执行;取值本身仍可能等待或抛出异常。用任务结果门控后续操作说明这种结果门控与 join 的区别。

原书依据 · 1 处

9.4 异步回调与主动调用

主动等待由发起方调用 join 或 get:前者等待线程终止,后者按 Future 契约取得结果,未就绪时可能占住调用线程,见主动调用会阻塞。回调则先登记后续处理,任务完成后触发已登记钩子,将通知方向反转,见回调反转方向。通知方向并不规定执行线程;API、执行器与注册时机共同决定回调在哪运行,不能把书中图示当通用线程合同。

原书依据 · 2 处

9.5 Guava的异步回调模式

Guava 的 ListenableFuture 在 Future 结果句柄上增加完成监听能力。调用方不必用一条线程专门等待 get,而可先登记完成后的处理。这个导言只提出接口扩展的目的,后续分别解释任务体、成功失败回调、监听入口与线程池适配,完整流程复用已有 Guava 卡,不重复成卡。

9.5.1 详解FutureCallback

Guava 中 Callable 是要运行的工作,FutureCallback 则是工作完成后如何处理结果。onSuccess 接收成功结果,onFailure 接收失败原因;取消也进入失败回调语义。把两者分开,才能避免把回调当成任务体,也能为异常路径安排独立处理。成功失败走不同回调说明这组职责,绑定时仍需按 Guava 版本选择执行器。

原书依据 · 1 处

9.5.2 详解ListenableFuture

ListenableFuture 继承 Future,并公开 addListener(Runnable, Executor),把完成后要执行的动作与执行资源一起登记。应用可以直接调用该公开入口;Futures.addCallback 是把成功失败分支包装为监听逻辑的便利方法,并不是唯一合法入口。监听接口承接回调纠正了原书“仅供内部使用”的说法,并连接了结果契约与完成通知。

原书依据 · 1 处

9.5.3 ListenableFuture异步任务

Guava 使用流程先编写 Callable/Runnable,通过 listeningDecorator 适配线程池,提交后得到 ListenableFuture,再把 FutureCallback 绑定到该句柄;工作完成时转入对应完成分支,见Guava增强Future。书中两参数 addCallback 属旧版用法,需按实际版本显式指定执行器。回调若在完成线程内联执行,耗时工作会占住该线程;回调线程要识别把 API、完成时机与执行器放在一起判断。

原书依据 · 2 处

9.5.4 使用Guava实现泡茶喝的实例

Guava 泡茶示例用两条完成回调更新同一 DrinkJob 的准备标志,再尝试泡茶。两条回调可能并发执行,“检查都已完成”与“执行一次泡茶”若没有统一协调,就可能重复触发,原日志也出现两次泡茶输出。回调汇合要防重复说明汇合处必须保护条件检查、状态推进和副作用;采用回调并不会自动使共享状态安全。

原书依据 · 1 处

9.5.5 Guava异步回调和Java异步调用的区别

FutureTask 通过 get 让发起方主动取得结果,Guava 回调则在完成后触发预先登记的处理,区别在依赖如何恢复执行,而不在任务是否曾并行运行。结果已就绪的 get 不必等待,回调也未必切换线程;回调线程要识别说明实际调度边界。此项是既有主动等待与回调模型的比较,小节对代码繁简的评价不构成新的普遍机制。

原书依据 · 1 处

9.6 Netty的异步回调模式

Netty 同样把异步结果句柄与完成监听分开:Future/ChannelFuture 承载操作状态,GenericFutureListener 承载完成后的处理。它与 Guava 的结果句柄加回调结构相近,但方法参数不同,不能将两个接口直接混用。此处建立角色对照,后面再展开 Listener 参数及 I/O 完成时机,不另建重复接口卡。

9.6.1 GenericFutureListener接口详解

GenericFutureListener 的 operationComplete(F) 接收已经完成的 Future,监听者再从句柄判断成功、失败原因或取消状态。Guava FutureCallback 则直接把值和失败原因分到 onSuccess/onFailure。两者承担完成处理的相近角色,却交付不同的参数契约,见框架回调接口的角色映射;理解角色对应不意味着异常处理代码可以原样互换。

原书依据 · 1 处

9.6.2 Netty的Future接口详解

Netty Future 继承 JDK Future,再增加 isSuccess、cause、监听器增删等能力,使结果句柄能主动通知完成。isCancellable 表示此刻是否可取消,isCancelled 表示是否已经取消,不能把能力状态与完成状态混同。Netty结果补监听说明如何用这些状态区分成功、失败和取消,而不是仅凭操作已完成就取作成功。

原书依据 · 1 处

9.6.3 ChannelFuture的使用

connect 等网络操作先提交并返回 ChannelFuture,连接尚未真正建立时调用方也能继续执行;addListener 登记的 operationComplete 在操作完成后触发,再按 isSuccess 与 cause 处理成功或失败。提交完成与 I/O 完成是两个时刻,见Netty监听IO完成。监听运行在哪个线程还要看 Netty 的实际合同,不能在 I/O 回调里无条件安排耗时阻塞处理。

原书依据 · 1 处

9.6.4 Netty的出站和入站异步回调

出站 write 返回 ChannelFuture,可为写操作完成注册监听;入站数据则交给对应 Handler 处理。书中 Echo 现象是多次发送未逐次对应回写,发送次数不等于回写条数只保留这种消息边界观察,不从本节补造分帧实现。异步写完成也不能证明对端应用已逐条处理完成;传输事件、消息边界和业务确认是不同层次。

原书依据 · 1 处

9.7 异步回调模式小结

主动等待和回调都能安排依赖关系:join 等线程结束,Future.get 按结果契约取值,而 Guava、Netty 让完成事件触发后续处理。回调避免专门等结果的调用线程,并不使任务体、回调中的慢操作或共享状态自动安全。此项收束前面已经解释的通知方式,不再新增卡片;下一章用 JDK 的阶段接口组织更复杂的依赖。

第10章 CompletableFuture异步回调

CompletableFuture 在 JDK 中把 Future 结果契约与函数式回调组合起来。一个异步工作完成后,可以触发后续转换、消费或多路汇合,不必为每一步手写监听共享标志。本项只是第十章导言;具体阶段含义、异常路径和执行资源将分别展开,不因 API 名称就推断所有回调都有独立线程。

10.1 CompletableFuture详解

CompletableFuture 既是未来结果的句柄,也能表示完成后继续推进的计算阶段。前一种视角回答“怎样取得结果”,后一种回答“结果就绪后还有什么依赖工作”。它们结合后可以把多个异步任务组织成一条或多条阶段链。该总述由后续双接口与阶段卡展开,这一短导引不另成卡。

10.1.1 CompletableFuture的UML类关系

类关系中,CompletableFuture 同时实现 Future 与 CompletionStage。Future 负责结果访问、等待和取消等契约;CompletionStage 负责描述完成后如何连接其他阶段。两条实现关系表达同一对象具有两组能力,并不表达两条运行线程,也不规定回调何时切换执行器。双接口异步契约用结构图保存这个区别。

原书依据 · 1 处

10.1.2 CompletionStage接口

CompletionStage 是一次同步或异步计算的阶段,阶段完成可以触发后续阶段。thenApply 用函数把输入映射成新值,thenAccept 消费输入,thenRun 只执行无参动作;这些是常见回调形态,并未穷尽接口中的函数类型。链式依赖约束前后关系,但同一阶段触发多个分支时,不保证它们按注册次序运行。阶段表达流水线说明阶段图与线程调度并不是一回事。

原书依据 · 1 处

10.1.3 使用runAsync和supplyAsync创建子任务

runAsync 包装 Runnable,得到表示动作完成的 CompletableFuture;supplyAsync 包装 Supplier,得到携带任务结果的 CompletableFuture。应按业务是否需要交付结果选择工厂,而不是为了控制后续分支任意丢弃结果。两种工厂都能显式传 Executor,结果契约和执行资源可以分别决定,见用返回契约选异步工厂。

原书依据 · 1 处

10.1.4 设置子任务回调钩子

whenComplete 接收结果和异常,适合观察完成、记录日志;它不返回替代业务值。exceptionally 只处理异常路径,可以返回恢复值供后续阶段使用,见观察与恢复分开。取消属于异常完成,但读取已取消原阶段抛 CancellationException,不能套用一般异常的 ExecutionException/CompletionException 包装;completeExceptionally 是主动异常完成的方法,也不是注册钩子,详见取消进入异常完成。

原书依据 · 2 处

10.1.5 调用handle()方法统一处理异常和结果

handle 无论成功或异常都会获得相应的结果、异常信息,并把回调返回值放进一个新的阶段。因此可以在同一处做结果转换或恢复,再把返回阶段接到后续流程。只调用 handle 却丢掉返回值,不会改写原 future 的异常状态;原书示例随后对原 future 调 get,仍可能抛异常。异步链必须处理异常强调恢复发生在哪个阶段,而不是只看回调有没有被执行。

原书依据 · 1 处

10.1.6 线程池的使用

runAsync、supplyAsync 未指定执行器时通常使用公共 ForkJoinPool;慢 I/O 长时间占住共享工作线程,会拖慢无关异步任务。应按负载选择合适执行器并隔离资源,见默认公共池不放阻塞任务。公共池并行度可以配置,Java 8 在公共池并行度不足二时还会为每个异步任务新建线程,不能简单认定线程数恒等于 CPU 核数。

原书依据 · 1 处

10.2 异步任务的串行执行

串行依赖表示下一步要在前一步正常完成后开始,而不要求发起线程亲自等待每一步。选择续链方法时先问三个问题:要不要前一结果、是否生成新业务值、下一步是否已经返回另一个阶段。thenApply、thenAccept、thenRun 与 thenCompose 分别表达这些契约,后面逐个解释,本项不重复生成方法卡。

10.2.1 thenApply()方法

thenApply 接收前一阶段的值 T,用 Function 转换成 U,并返回携带 U 的新 CompletableFuture,可继续链式调用。映射函数如果返回另一个阶段,thenApply 会把它当普通值,从而形成嵌套,后续的 compose 才负责展平。串行依赖选方法统一比较这些结果契约;非 Async 版本不保证永远同线程执行,仍须按完成时机与执行器理解调度。

原书依据 · 1 处

10.2.2 thenRun()方法

thenRun 在前一阶段正常完成后执行 Runnable,不取得前一结果,也不产生业务值。其返回类型虽然是 Void,返回对象仍表示这个动作何时完成,后面仍可继续链接。适合只依赖完成时机的动作,而不是要消费前序结果的计算。这个区别已由串行依赖选方法承接,不再拆出重复方法卡。

原书依据 · 1 处

10.2.3 thenAccept()方法

thenAccept 把前一阶段的结果交给 Consumer,例如用于输出或其他副作用,但不产生新业务值。它与 thenRun 的差别是能够取得输入,与 thenApply 的差别是不映射出业务结果;返回的 Void 阶段仍能表达动作完成并继续组合。三种输入输出契约由串行依赖选方法统一承接,本项落实结果消费的用途。

原书依据 · 1 处

10.2.4 thenCompose()方法

thenCompose 适用于“前一步结果决定下一段异步流程”:回调接收前序值,返回 CompletionStage,外层把这个阶段展平接入结果链。相比 thenApply 得到嵌套的阶段对象,调用方最终直接等待 U 对应的完成。supplyAsync 是创建内部阶段的一种办法,并非唯一办法;关键是回调返回阶段的契约,见Compose避免嵌套。

原书依据 · 1 处

10.2.5 4个任务串行方法的区别

四种串行方法都返回阶段,均可以继续链式编排。thenApply 转换值,thenAccept 消费值,thenRun 不接收值,thenCompose 将返回的阶段展平。书中把 thenApply 说成返回普通结果且不能续链,与其前文签名和示例矛盾,不能沿用;真实区别是回调返回普通值还是另一个阶段。比较复用串行依赖选方法与Compose避免嵌套,不为勘误另建卡。

原书依据 · 2 处

10.3 异步任务的合并执行

合并依赖要求后继工作同时等两项前置工作具备结果,如泡茶同时依赖烧水与清洗。两个前置阶段可以各自并行,合并方法只规定汇合后的动作:要生成新值、消费两份值,还是仅在两边就绪后运行。这个引导承接前章的双前置依赖,后续方法再按回调契约区别,不另造新模式卡。

10.3.1 thenCombine()方法

thenCombine 等两个上游阶段正常完成,再把两路结果 T、U 交给 BiFunction,产生 V 并形成新的结果阶段。它既是完成汇合,也是值的合成;某路异常时不能把不存在的正常结果送进合并函数,异常需沿后续阶段处理。两路结果在此合并说明它与只等完成的屏障不同。

原书依据 · 1 处

10.3.2 runAfterBoth()方法

runAfterBoth 只要求两路上游正常完成后运行一个 Runnable。动作不接收两路结果,也不生成业务值,返回的 Void 阶段表达动作本身是否完成;如果还要用两路值作计算,就应换结果合并方法。两路就绪后做副作用保留这组边界,避免把“都完成”与“拿到并合成两份结果”混为一谈。

原书依据 · 1 处

10.3.3 thenAcceptBoth()方法

thenAcceptBoth 在两个上游正常完成后,把两路结果交给 BiConsumer 消费,但不生成新的业务值。它介于 thenCombine 与 runAfterBoth 之间:保留两路输入,返回阶段只承载动作完成。消费双路结果不产值说明这种结果消费契约;原文末尾误称 thenAccept,不改变本方法的双输入含义。

原书依据 · 1 处

10.3.4 allOf()等待所有的任务结束

CompletableFuture.allOf 是静态的多任务完成屏障,等所有传入任务结束后形成整体完成阶段。它不自动收集每个任务的结果,业务值仍须从原任务读取;任何输入异常完成时,整体也异常完成。它属于 CompletableFuture 而非 CompletionStage,也没有“必须两个以上”的限制,详见合并等待全部。

原书依据 · 1 处

10.4 异步任务的选择执行

选择执行让两个候选任务竞争完成速度,再接到后继动作;这和等两路结果的合并执行不同。它解决“哪个结果先可用”,并不负责判断哪个结果业务质量最高。后继可以映射该值、消费该值或完全忽略值,异常、超时和剩余任务的资源处理仍须另有安排。本项是下一组三种回调契约的引导,不另建卡。

10.4.1 applyToEither()方法

applyToEither 在候选上游正常完成时,使用较快就绪的一路结果执行 Function,得到后继值。它适合可替代结果的竞速,却不等于择优:先到的值不一定更完整,也不自动清理慢任务。尤其不能把正常示例推导为必然屏蔽先到异常,异常和超时仍需显式编排。择快不是择优说明这类性能选择的业务边界。

原书依据 · 1 处

10.4.2 runAfterEither()方法

runAfterEither 在任一上游正常完成后执行无参 Runnable,不把该路值传入动作,也不产生业务结果,返回 Void 阶段。它表达任一路就绪后的动作依赖;需要读取结果时则应选另两种 Either 方法。任一路正常后触发动作将正常完成条件写清,不能沿用书中“任何完成”就推断异常情况下也保证运行动作。

原书依据 · 1 处

10.4.3 acceptEither()方法

acceptEither 使用较快正常完成的一路结果调用 Consumer,动作能消费该值,却不生成新业务值。它与 applyToEither 的区别是无业务输出,与 runAfterEither 的区别是有输入;三者都不是自动的异常兜底或超时策略。消费择快结果不产值保留这组输入输出契约。

原书依据 · 1 处

10.5 CompletableFuture的综合案例

后面的泡茶与 RPC 案例把已学过的任务创建、串行依赖和双路合并放进同一流程。此项只有案例预告,没有额外的接口规则或完整实现,因此不另建卡片;阅读具体案例时仍要同时检查业务条件、异常路径和执行器选择。

10.5.1 使用CompletableFuture实现泡茶喝实例

CompletableFuture 版泡茶把烧水与清洗分别交给 supplyAsync,并用 thenCombine 汇合布尔结果,再决定能否泡茶。这将两路完成关系直接写进阶段图,不再让两个回调手工竞争共享标志,双前置结构复用独立任务并行后再汇合与两路结果在此合并。代码省略了文字中的洗茶壶、拿茶叶步骤,只能证明依赖结构;模拟 sleep 与默认公共池也不是生产 I/O 配置方案,因此不为示例再造新卡。

原书依据 · 2 处

10.5.2 使用CompletableFuture进行多个RPC调用

RPC 示例先独立提交两个 supplyAsync,最后 thenCombine 把两个返回值组合;业务原本必须等两路,现在仍等两路,只是可重叠请求耗时。两路结果在此合并承接值合并机制,默认公共池不放阻塞任务说明真实阻塞调用为何需要资源选择。代码 sleep 600 毫秒而注释写 400 毫秒,不能从注释推算性能;此例没有新的独立机制,不重复生卡。

原书依据 · 2 处

10.5.3 使用RxJava模拟RPC异步回调

RxJava 示例把每个 RPC 包成 fromCallable 源,分别用 subscribeOn 安排源端执行;merge 合并通知,observeOn 改变其后下游通知的调度,再由 toList 汇成列表。源运行位置与下游观察位置应沿操作符判断,不能简单说整条链只有一个“异步线程”,见上下游调度各有边界。原例没有显式 onError,长时间 sleep 只为保持演示进程存活;实际用法须按所用 RxJava 版本处理错误与生命周期。

原书依据 · 1 处

跨章综合

正确性约束先于工具选择。锁、CAS、volatile和并发容器承担不同责任:锁可以保护一段临界区,CAS比较并更新一个位置,volatile参与可见性和顺序协议,容器方法则有各自的原子边界。它们不能互相替换,更不能仅凭某个组件“线程安全”就推出跨多步业务流程也安全。

等待与唤醒是一套状态协议。等待线程必须在正确锁或同步器约束下复查条件;通知意味着可能值得重试,不保证条件仍成立。AQS把排队、获取与唤醒组织起来,但具体同步器仍须定义状态含义和获取释放规则。

异步表达也不会自动消除阻塞。Future.get或join可能让调用者等待,回调可能运行在完成线程或指定执行器,阶段组合还要传递异常与取消。把耗时任务与无关任务放进同一有限池,会让本来独立的工作共享排队压力。设计时应同时画任务依赖与执行资源,避免只看API链条。

版本与证据边界贯穿全书:对象布局、偏向锁、AQS节点结构和ConcurrentHashMap内部算法要绑定具体实现;书中的样例勘误保留在覆盖与历史审查记录中。一次演示展示某种交错可能发生,不能推出稳定概率或所有负载的性能结论。

发散与实践

以下是读者延伸。保留四项计划:CHM固定版本实现深读(ideas/idea-001-CHM桶锁在JDK17是否成立.md)、等待条件复查演示(ideas/idea-002-if判断wait条件真的会出错吗.md)、公共池合成阻塞对照(ideas/idea-003-公共池线程饥饿的真实代价.md)、懒汉单例受控交错(ideas/idea-004-复现懒汉单例竞态.md)。前三项包含历史记录,原临时代码和当时环境本轮没有复验;第4项仍是计划。本轮核验了CHM官方固定版本入口并补齐两层阅读计划,没有重新运行实验。

生成进度与管理记录

Java高并发核心编程.卷2,多线程、锁、JMM、JUC、高并发设计模式

执行模式:light 本次执行规则:book-notes v23 / book-workflow v4(原历史规则记录保留) 建档进度:done

整书笔记:325项逐段讲解、191卡主要位置及真实出处。

类别:编程语言类

本次实际使用规则:book-notes v8(2026-09-24 补做主题索引维护,卡片正文未改动),详见 _workflow.md v8 升级记录。

整体评级

四象限结论:经典原理(高信息浓度 + 高稳定性)

支撑理由: 本书虽然以 Java 线程、JUC 和若干具体 API 为载体,但主线不是简单罗列调用方法,而是解释高并发编程中的根本约束和底层机制:线程池为何不能无界排队、线程数为何要区分 IO 密集型和 CPU 密集型任务、synchronized 如何依赖对象头与锁升级、CAS 的性能边界为何会引出 LongAdder、volatile 与 JMM 如何解决可见性和有序性、AQS 如何用模板方法和同步队列支撑显式锁。后半部分还把 Master-Worker、ForkJoin、生产者-消费者、Future、异步回调和 CompletableFuture 放到并发协作模型中理解。书中存在部分 JDK 版本和类库 API 细节,但这些细节服务于可迁移的并发原理,因此整体归为“经典原理”。

章节筛选

章节号 章节标题 精读/略读 状态(pending/done) 卡片数
1 多线程原理与实战 精读:线程生命周期、线程池、线程数估算和 ThreadLocal 都是 Java 并发的底座;S4 补中断标志、拒绝策略。V10 已逐项回读本章,新增进程、线程、任务执行、线程池与 ThreadLocal 基础等三十五卡;准确性问题留 S3 复核。 done 42
2 Java内置锁的核心原理 精读:V10 已逐项回读本章,新增对象锁作用域、拆锁前提、类锁区别、对象布局、旧版锁记录、监视器等待和丢失通知等九卡;书中多个锁示例及版本断言留 S3 审查。 done 15
3 CAS原理与JUC原子类 精读:V10 已逐项回读本章,新增 CAS 重试、原子类选型、数组与引用的原子边界、布尔标记历史信息及 LongAdder 结构协调等六卡;书中 ABA、API 和性能叙述的问题留 S3 复核。 done 11
4 可见性与有序性的原理 精读:CPU 缓存、MESI、内存屏障、JMM 和 Happens-Before 是并发正确性的核心;V10 已逐项回读全章,补可见性、顺序和发布协议边界卡,书中 JMM 规则与硬件实现叙述待 S3 复核。 done 10
5 JUC显式锁的原理与实战 精读:LockSupport、CLH、自旋锁、读写锁和 StampedLock 展示显式锁的取舍;V10 已逐项回读本章全部 spine #157–#185,新增锁竞争成本、公平策略边界、AB-BA 循环等待、ThreadMXBean 检测范围及读写锁转换卡;Condition 顺序、伪唤醒、中断状态、实现边界及硬件性能概括留 S3 复核。 done 15
6 AQS抽象同步器的核心原理 精读:AQS 是 JUC 同步器的共同骨架,源码流程值得形成长期卡片;V10 已逐项回读 spine #186–#232,卡片覆盖状态、节点、模板、入队、出队、释放、公平获取与 Condition 等待恢复。 done 18
7 JUC容器类 精读:CopyOnWrite、BlockingQueue、ConcurrentHashMap 体现并发容器的不同设计策略。 done 26
8 高并发设计模式 精读:单例、Master-Worker、ForkJoin、生产者-消费者、Future 是可迁移的并发结构;V10 已逐项回读至 #279,Future 契约由既有卡承接,示例耗时前提留 S3 核验。 done 23
9 高并发核心模式之异步回调模式 精读:主动获取结果与回调反转控制流,是异步系统设计的重要分界;V10 已逐项回读至 #301,#288 记录结果门控、#291 记录 FutureCallback 成功/失败分支、#292 记录 ListenableFuture 监听接口分层;#289 总结、#290 Guava 导言及 #293 执行器适配由既有卡承接;#294 新增并行回调汇合的一次性风险卡;#295 的主动 FutureTask 与回调对比由既有卡承接;#296–#297 的 Netty/Guava 接口角色和参数形态由《框架回调接口的角色映射》承接;#298 新增 Netty Future 状态与可取消性区分卡;#299 的 ChannelFuture 完成通知、状态与失败原因由既有《Netty监听IO完成》《Netty结果补监听》承接;#300 的出站 write() 完成监听由既有《Netty监听IO完成》承接;EchoServer 粘包/半包症状新增《发送次数不等于回写条数》,不扩写本节未给出的解决方案。#301 总结段由现有主动调用与回调卡承接;get() 异常边界及 Future/Listener 精确契约与执行器语义留 S3 核查。 done 14
10 CompletableFuture异步回调 精读:CompletionStage 链式编排是 Java 8 后表达异步流程的核心工具;V10 #302–#303 导言由《Future先给契约》《回调反转方向》《阶段表达流水线》承接;#304 补 CompletableFuture 同时实现 Future 与 CompletionStage 的类关系卡;#305 核对同步/异步阶段定义、三类任务输入输出与链式执行边界,并据原文修订《阶段表达流水线》;#306 新增《用返回契约选异步工厂》,区分 runAsync 与 supplyAsync 的任务/结果契约,公共池风险由既有卡承接;#307 新增《观察与恢复分开》《取消进入异常完成》,补完成观察/异常恢复契约及异常包装差异;#317–#327的编排方法及CompletableFuture案例由新旧卡承接;#328新增《上下游调度各有边界》,RxJava模型与版本契约留S3核验。 done 17

章节进度追踪表

本轮复用已核验的325项历史阅读覆盖,逐项讲解统一见整书笔记;以下保留真实计划与计数。

章节号 章节标题 状态(pending/done) 卡片数
4 前言(OEBPS/Text/chapter.xhtml) done 0
5 自序(OEBPS/Text/chapter1.xhtml) done 0
6 第1章 多线程原理与实战(OEBPS/Text/chapter2.xhtml) done 0
7 1.1 两个技术面试故事(OEBPS/Text/chapter3.xhtml) done 0
8 1.2 无处不在的进程和线程(OEBPS/Text/chapter4.xhtml) done 1
9 1.2.1 进程的基本原理(OEBPS/Text/chapter5.xhtml) done 1
10 1.2.2 线程的基本原理(OEBPS/Text/chapter6.xhtml) done 2
11 1.2.3 进程与线程的区别(OEBPS/Text/chapter7.xhtml) done 0
12 1.3 创建线程的4种方法(OEBPS/Text/chapter8.xhtml) done 0
13 1.3.1 Thread类详解(OEBPS/Text/chapter9.xhtml) done 2
14 1.3.2 创建一个空线程(OEBPS/Text/chapter10.xhtml) done 0
15 1.3.3 线程创建方法一:继承Thread类创建线程类(OEBPS/Text/chapter11.xhtml) done 0
16 1.3.4 线程创建方法二:实现Runnable接口创建线程目标类(OEBPS/Text/chapter12.xhtml) done 1
17 1.3.5 优雅创建Runnable线程目标类的两种方式(OEBPS/Text/chapter13.xhtml) done 1
18 1.3.6 通过实现Runnable接口的方式创建线程目标类的优缺点(OEBPS/Text/chapter14.xhtml) done 2
19 1.3.7 线程创建方法三:使用Callable和FutureTask创建线程(OEBPS/Text/chapter15.xhtml) done 2
20 1.3.8 线程创建方法四:通过线程池创建线程(OEBPS/Text/chapter16.xhtml) done 2
21 1.4 线程的核心原理(OEBPS/Text/chapter17.xhtml) done 0
22 1.4.1 线程的调度与时间片(OEBPS/Text/chapter18.xhtml) done 1
23 1.4.2 线程的优先级(OEBPS/Text/chapter19.xhtml) done 2
24 1.4.3 线程的生命周期(OEBPS/Text/chapter20.xhtml) done 1
25 1.4.4 一个线程状态的简单演示案例(OEBPS/Text/chapter21.xhtml) done 0
26 1.4.5 使用Jstack工具查看线程状态(OEBPS/Text/chapter22.xhtml) done 1
27 1.5 线程的基本操作(OEBPS/Text/chapter23.xhtml) done 0
28 1.5.1 线程名称的设置和获取(OEBPS/Text/chapter24.xhtml) done 1
29 1.5.2 线程的sleep操作(OEBPS/Text/chapter25.xhtml) done 1
30 1.5.3 线程的interrupt操作(OEBPS/Text/chapter26.xhtml) done 2(含历史1)
31 1.5.4 线程的join操作(OEBPS/Text/chapter27.xhtml) done 1
32 1.5.5 线程的yield操作(OEBPS/Text/chapter28.xhtml) done 1
33 1.5.6 线程的daemon操作(OEBPS/Text/chapter29.xhtml) done 2(含历史1)
34 1.5.7 线程状态总结(OEBPS/Text/chapter30.xhtml) done 0
35 1.6 线程池原理与实战(OEBPS/Text/chapter31.xhtml) done 0
36 1.6.1 JUC的线程池架构(OEBPS/Text/chapter32.xhtml) done 1
37 1.6.2 Executors的4种快捷创建线程池的方法(OEBPS/Text/chapter33.xhtml) done 1
38 1.6.3 线程池的标准创建方式(OEBPS/Text/chapter34.xhtml) done 1
39 1.6.4 向线程池提交任务的两种方式(OEBPS/Text/chapter35.xhtml) done 2(含历史1)
40 1.6.5 线程池的任务调度流程(OEBPS/Text/chapter36.xhtml) done 0
41 1.6.6 ThreadFactory(线程工厂)(OEBPS/Text/chapter37.xhtml) done 1
42 1.6.7 任务阻塞队列(OEBPS/Text/chapter38.xhtml) done 1
43 1.6.8 调度器的钩子方法(OEBPS/Text/chapter39.xhtml) done 1
44 1.6.9 线程池的拒绝策略(OEBPS/Text/chapter40.xhtml) done 1(历史)
45 1.6.10 线程池的优雅关闭(OEBPS/Text/chapter41.xhtml) done 1
46 1.6.11 Executors快捷创建线程池的潜在问题(OEBPS/Text/chapter42.xhtml) done 1(历史)
47 1.7 确定线程池的线程数(OEBPS/Text/chapter43.xhtml) done 0
48 1.7.1 按照任务类型对线程池进行分类(OEBPS/Text/chapter44.xhtml) done 0
49 1.7.2 为IO密集型任务确定线程数(OEBPS/Text/chapter45.xhtml) done 1(历史)
50 1.7.3 为CPU密集型任务确定线程数(OEBPS/Text/chapter46.xhtml) done 1(历史)
51 1.7.4 为混合型任务确定线程数(OEBPS/Text/chapter47.xhtml) done 0
52 1.8 ThreadLocal原理与实战(OEBPS/Text/chapter48.xhtml) done 0
53 1.8.1 ThreadLocal的基本使用(OEBPS/Text/chapter49.xhtml) done 1
54 1.8.2 ThreadLocal的使用场景(OEBPS/Text/chapter50.xhtml) done 2(含历史1)
55 1.8.3 使用ThreadLocal进行线程隔离(OEBPS/Text/chapter51.xhtml) done 0
56 1.8.4 使用ThreadLocal进行跨函数数据传递(OEBPS/Text/chapter52.xhtml) done 0
57 1.8.5 ThreadLocal内部结构演进(OEBPS/Text/chapter53.xhtml) done 1
58 1.8.6 ThreadLocal源码分析(OEBPS/Text/chapter54.xhtml) done 0
59 1.8.7 ThreadLocalMap源码分析(OEBPS/Text/chapter55.xhtml) done 1(历史)
60 1.8.8 ThreadLocal综合使用案例(OEBPS/Text/chapter56.xhtml) done 0
61 第2章 Java内置锁的核心原理(OEBPS/Text/chapter57.xhtml) done 1
62 2.1 线程安全问题(OEBPS/Text/chapter58.xhtml) done 0
63 2.1.1 自增运算不是线程安全的(OEBPS/Text/chapter59.xhtml) done 1(历史)
64 2.1.2 临界区资源与临界区代码段(OEBPS/Text/chapter60.xhtml) done 1(历史)
65 2.2 synchronized关键字(OEBPS/Text/chapter61.xhtml) done 0
66 2.2.1 synchronized同步方法(OEBPS/Text/chapter62.xhtml) done 0
67 2.2.2 synchronized同步块(OEBPS/Text/chapter63.xhtml) done 1
68 2.2.3 静态的同步方法(OEBPS/Text/chapter64.xhtml) done 1
69 2.3 生产者-消费者问题(OEBPS/Text/chapter65.xhtml) done 0
70 2.3.1 生产者-消费者模式(OEBPS/Text/chapter66.xhtml) done 1(历史)
71 2.3.2 一个线程不安全的实现版本(OEBPS/Text/chapter67.xhtml) done 0(复用历史卡)
72 2.3.3 一个线程安全的实现版本(OEBPS/Text/chapter68.xhtml) done 0(复用历史卡)
73 2.4 Java对象结构与内置锁(OEBPS/Text/chapter69.xhtml) done 0(过渡)
74 2.4.1 Java对象结构(OEBPS/Text/chapter70.xhtml) done 1
75 2.4.2 Mark Word的结构信息(OEBPS/Text/chapter71.xhtml) done 0(历史承接)
76 2.4.3 使用JOL工具查看对象的布局(OEBPS/Text/chapter72.xhtml) done 0(已并入)
77 2.4.4 大小端问题(OEBPS/Text/chapter73.xhtml) done 1
78 2.4.5 无锁、偏向锁、轻量级锁和重量级锁(OEBPS/Text/chapter74.xhtml) done 0(历史承接)
79 2.5 偏向锁的原理与实战(OEBPS/Text/chapter75.xhtml) done 0(历史承接)
80 2.5.1 偏向锁的核心原理(OEBPS/Text/chapter76.xhtml) done 0(历史承接)
81 2.5.2 偏向锁的演示案例(OEBPS/Text/chapter77.xhtml) done 0(历史承接)
82 2.5.3 偏向锁的膨胀和撤销(OEBPS/Text/chapter78.xhtml) done 0(历史承接)
83 2.6 轻量级锁的原理与实战(OEBPS/Text/chapter79.xhtml) done 0(过渡)
84 2.6.1 轻量级锁的核心原理(OEBPS/Text/chapter80.xhtml) done 1
85 2.6.2 轻量级锁的演示案例(OEBPS/Text/chapter81.xhtml) done 0(已并入)
86 2.6.3 轻量级锁的分类(OEBPS/Text/chapter82.xhtml) done 0(历史承接)
87 2.6.4 轻量级锁的膨胀(OEBPS/Text/chapter83.xhtml) done 0(历史承接)
88 2.7 重量级锁的原理与实战(OEBPS/Text/chapter84.xhtml) done 0(下项展开)
89 2.7.1 重量级锁的核心原理(OEBPS/Text/chapter85.xhtml) done 1
90 2.7.2 重量级锁的开销(OEBPS/Text/chapter86.xhtml) done 0(历史承接)
91 2.7.3 重量级锁的演示案例(OEBPS/Text/chapter87.xhtml) done 0(已并入)
92 2.8 偏向锁、轻量级锁与重量级锁的对比(OEBPS/Text/chapter88.xhtml) done 0(历史承接)
93 2.9 线程间通信(OEBPS/Text/chapter89.xhtml) done 0(已并入)
94 2.9.1 线程间通信的定义(OEBPS/Text/chapter90.xhtml) done 1
95 2.9.2 低效的线程轮询(OEBPS/Text/chapter91.xhtml) done 0(历史承接)
96 2.9.3 wait方法和notify方法的原理(OEBPS/Text/chapter92.xhtml) done 0(已并入)
97 2.9.4 “等待-通知”通信模式演示案例(OEBPS/Text/chapter93.xhtml) done 0(已并入)
98 2.9.5 生产者-消费者之间的线程间通信(OEBPS/Text/chapter94.xhtml) done 1
99 2.9.6 需要在synchronized同步块的内部使用wait和notify(OEBPS/Text/chapter95.xhtml) done 0(历史承接)
100 第3章 CAS原理与JUC原子类(OEBPS/Text/chapter96.xhtml) done 0(引言)
101 3.1 什么是CAS(OEBPS/Text/chapter97.xhtml) done 0(节引言)
102 3.1.1 Unsafe类中的CAS方法(OEBPS/Text/chapter98.xhtml) done 0(历史承接)
103 3.1.2 使用CAS进行无锁编程(OEBPS/Text/chapter99.xhtml) done 1
104 3.1.3 使用无锁编程实现轻量级安全自增(OEBPS/Text/chapter100.xhtml) done 0(已并入)
105 3.1.4 字段偏移量的计算(OEBPS/Text/chapter101.xhtml) done 0(历史承接)
106 3.2 JUC原子类(OEBPS/Text/chapter102.xhtml) done 0(节引言)
107 3.2.1 JUC中的Atomic原子操作包(OEBPS/Text/chapter103.xhtml) done 1
108 3.2.2 基础原子类AtomicInteger(OEBPS/Text/chapter104.xhtml) done 0(已并入)
109 3.2.3 数组原子类AtomicIntegerArray(OEBPS/Text/chapter105.xhtml) done 1
110 3.2.4 AtomicInteger线程安全原理(OEBPS/Text/chapter106.xhtml) done 0(已并入)
111 3.3 对象操作的原子性(OEBPS/Text/chapter107.xhtml) done 0(已并入)
112 3.3.1 引用类型原子类(OEBPS/Text/chapter108.xhtml) done 1
113 3.3.2 属性更新原子类(OEBPS/Text/chapter109.xhtml) done 0(已并入)
114 3.4 ABA问题(OEBPS/Text/chapter110.xhtml) done 0
115 3.4.1 了解ABA问题(OEBPS/Text/chapter111.xhtml) done 0
116 3.4.2 ABA问题解决方案(OEBPS/Text/chapter112.xhtml) done 0
117 3.4.3 使用AtomicStampedReference解决ABA问题(OEBPS/Text/chapter113.xhtml) done 0
118 3.4.4 使用AtomicMarkableReference解决ABA问题(OEBPS/Text/chapter114.xhtml) done 1
119 3.5 提升高并发场景下CAS操作的性能(OEBPS/Text/chapter115.xhtml) done 0
120 3.5.1 以空间换时间:LongAdder(OEBPS/Text/chapter116.xhtml) done 0
121 3.5.2 LongAdder的原理(OEBPS/Text/chapter117.xhtml) done 1
122 3.6 CAS在JDK中的广泛应用(OEBPS/Text/chapter118.xhtml) done 0
123 3.6.1 CAS操作的弊端和规避措施(OEBPS/Text/chapter119.xhtml) done 0
124 3.6.2 CAS操作在JDK中的应用(OEBPS/Text/chapter120.xhtml) done 0
125 第4章 可见性与有序性的原理(OEBPS/Text/chapter121.xhtml) done 0
126 4.1 CPU物理缓存结构(OEBPS/Text/chapter122.xhtml) done 0
127 4.2 并发编程的三大问题(OEBPS/Text/chapter123.xhtml) done 0
128 4.2.1 原子性问题(OEBPS/Text/chapter124.xhtml) done 0
129 4.2.2 可见性问题(OEBPS/Text/chapter125.xhtml) done 1
130 4.2.3 有序性问题(OEBPS/Text/chapter126.xhtml) done 1
131 4.3 硬件层的MESI协议原理(OEBPS/Text/chapter127.xhtml) done 0
132 4.3.1 总线锁和缓存锁(OEBPS/Text/chapter128.xhtml) done 0
133 4.3.2 MSI协议(OEBPS/Text/chapter129.xhtml) done 0
134 4.3.3 MESI协议及RFO请求(OEBPS/Text/chapter130.xhtml) done 1
135 4.3.4 volatile的原理(OEBPS/Text/chapter131.xhtml) done 0
136 4.4 有序性与内存屏障(OEBPS/Text/chapter132.xhtml) done 0
137 4.4.1 重排序(OEBPS/Text/chapter133.xhtml) done 0
138 4.4.2 As-if-Serial规则(OEBPS/Text/chapter134.xhtml) done 0
139 4.4.3 硬件层面的内存屏障(OEBPS/Text/chapter135.xhtml) done 1
140 4.5 JMM详解(OEBPS/Text/chapter136.xhtml) done 0
141 4.5.1 什么是Java内存模型(OEBPS/Text/chapter137.xhtml) done 1
142 4.5.2 JMM与JVM物理内存的区别(OEBPS/Text/chapter138.xhtml) done 0
143 4.5.3 JMM的8个操作(OEBPS/Text/chapter139.xhtml) done 0
144 4.5.4 JMM如何解决有序性问题(OEBPS/Text/chapter140.xhtml) done 0
145 4.5.5 volatile语义中的内存屏障(OEBPS/Text/chapter141.xhtml) done 0
146 4.6 Happens-Before规则(OEBPS/Text/chapter142.xhtml) done 0
147 4.6.1 Happens-Before规则介绍(OEBPS/Text/chapter143.xhtml) done 0
148 4.6.2 规则1:顺序性规则(OEBPS/Text/chapter144.xhtml) done 0
149 4.6.3 规则2:volatile规则(OEBPS/Text/chapter145.xhtml) done 0
150 4.6.4 规则3:传递性规则(OEBPS/Text/chapter146.xhtml) done 0
151 4.6.5 规则4:监视锁规则(OEBPS/Text/chapter147.xhtml) done 0
152 4.6.6 规则5:start()规则(OEBPS/Text/chapter148.xhtml) done 0
153 4.6.7 规则6:join()规则(OEBPS/Text/chapter149.xhtml) done 0
154 4.7 volatile不具备原子性(OEBPS/Text/chapter150.xhtml) done 0
155 4.7.1 volatile变量的自增实例(OEBPS/Text/chapter151.xhtml) done 0
156 4.7.2 volatile变量的复合操作不具备原子性的原理(OEBPS/Text/chapter152.xhtml) done 0
157 第5章 JUC显式锁的原理与实战(OEBPS/Text/chapter153.xhtml) done 0
158 5.1 显式锁(OEBPS/Text/chapter154.xhtml) done 0
159 5.1.1 显式锁Lock接口(OEBPS/Text/chapter155.xhtml) done 0
160 5.1.2 可重入锁ReentrantLock(OEBPS/Text/chapter156.xhtml) done 0
161 5.1.3 使用显式锁的模板代码(OEBPS/Text/chapter157.xhtml) done 0
162 5.1.4 基于显式锁进行“等待-通知”方式的线程间通信(OEBPS/Text/chapter158.xhtml) done 0(旧卡承接)
163 5.1.5 LockSupport(OEBPS/Text/chapter159.xhtml) done 0(旧卡承接)
164 5.1.6 显式锁的分类(OEBPS/Text/chapter160.xhtml) done 0(旧卡承接)
165 5.2 悲观锁和乐观锁(OEBPS/Text/chapter161.xhtml) done 0(术语边界留 S3)
166 5.2.1 悲观锁存在的问题(OEBPS/Text/chapter162.xhtml) done 1
167 5.2.2 通过CAS实现乐观锁(OEBPS/Text/chapter163.xhtml) done 0(旧卡承接)
168 5.2.3 不可重入的自旋锁(OEBPS/Text/chapter164.xhtml) done 0(旧卡承接)
169 5.2.4 可重入的自旋锁(OEBPS/Text/chapter165.xhtml) done 0(旧卡承接)
170 5.2.5 CAS可能导致“总线风暴”(OEBPS/Text/chapter166.xhtml) done 0(旧卡承接)
171 5.2.6 CLH自旋锁(OEBPS/Text/chapter167.xhtml) done 0(旧卡承接)
172 5.3 公平锁与非公平锁(OEBPS/Text/chapter168.xhtml) done 0
173 5.3.1 非公平锁实战(OEBPS/Text/chapter169.xhtml) done 0(公平策略边界由下一项承接)
174 5.3.2 公平锁实战(OEBPS/Text/chapter170.xhtml) done 1
175 5.4 可中断锁与不可中断锁(OEBPS/Text/chapter171.xhtml) done 0(旧卡承接)
176 5.4.1 锁的可中断抢占(OEBPS/Text/chapter172.xhtml) done 0(旧卡承接)
177 5.4.2 死锁的监测与中断(OEBPS/Text/chapter173.xhtml) done 2
178 5.5 共享锁与独占锁(OEBPS/Text/chapter174.xhtml) done 0(旧卡承接)
179 5.5.1 独占锁(OEBPS/Text/chapter175.xhtml) done 0(旧卡承接)
180 5.5.2 共享锁Semaphore(OEBPS/Text/chapter176.xhtml) done 0(旧卡承接)
181 5.5.3 共享锁CountDownLatch(OEBPS/Text/chapter177.xhtml) done 0(旧卡承接)
182 5.6 读写锁(OEBPS/Text/chapter178.xhtml) done 0(旧卡承接)
183 5.6.1 读写锁ReentrantReadWriteLock(OEBPS/Text/chapter179.xhtml) done 0(旧卡承接)
184 5.6.2 锁的升级与降级(OEBPS/Text/chapter180.xhtml) done 1
185 5.6.3 StampedLock(OEBPS/Text/chapter181.xhtml) done 0(旧卡承接)
186 第6章 AQS抽象同步器的核心原理(OEBPS/Text/chapter182.xhtml) done 0(旧卡承接)
187 6.1 锁与队列的关系(OEBPS/Text/chapter183.xhtml) done 0(旧卡承接)
188 6.2 AQS的核心成员(OEBPS/Text/chapter184.xhtml) done 0(旧卡承接)
189 6.2.1 状态标志位(OEBPS/Text/chapter185.xhtml) done 1
190 6.2.2 队列节点类(OEBPS/Text/chapter186.xhtml) done 1
191 6.2.3 FIFO双向同步队列(OEBPS/Text/chapter187.xhtml) done 1
192 6.2.4 JUC显式锁与AQS的关系(OEBPS/Text/chapter188.xhtml) done 0(旧卡承接)
193 6.2.5 ReentrantLock与AQS的组合关系(OEBPS/Text/chapter189.xhtml) done 1
194 6.3 AQS中的模板模式(OEBPS/Text/chapter190.xhtml) done 0(旧卡承接)
195 6.3.1 模板模式(OEBPS/Text/chapter191.xhtml) done 1
196 6.3.2 一个模板模式的参考实现(OEBPS/Text/chapter192.xhtml) done 0(旧卡承接)
197 6.3.3 AQS的模板流程(OEBPS/Text/chapter193.xhtml) done 0(旧卡承接)
198 6.3.4 AQS中的钩子方法(OEBPS/Text/chapter194.xhtml) done 1
199 6.4 通过AQS实现一把简单的独占锁(OEBPS/Text/chapter195.xhtml) done 0(旧卡承接)
200 6.4.1 简单的独占锁的UML类图(OEBPS/Text/chapter196.xhtml) done 0(旧卡承接)
201 6.4.2 简单的独占锁的实现(OEBPS/Text/chapter197.xhtml) done 0(旧卡承接)
202 6.4.3 SimpleMockLock测试用例(OEBPS/Text/chapter198.xhtml) done 0(旧卡承接)
203 6.5 AQS锁抢占的原理(OEBPS/Text/chapter199.xhtml) done 0(旧卡承接)
204 6.5.1 显式锁抢占的总体流程(OEBPS/Text/chapter200.xhtml) done 0(旧卡承接)
205 6.5.2 AQS模板方法:acquire(arg)(OEBPS/Text/chapter201.xhtml) done 1
206 6.5.3 钩子实现:tryAcquire(arg)(OEBPS/Text/chapter202.xhtml) done 0(旧卡承接)
207 6.5.4 直接入队:addWaiter(OEBPS/Text/chapter203.xhtml) done 1
208 6.5.5 自旋入队:enq(OEBPS/Text/chapter204.xhtml) done 0(并入 #207 卡)
209 6.5.6 自旋抢占:acquireQueued()(OEBPS/Text/chapter205.xhtml) done 0(旧卡承接)
210 6.5.7 挂起预判:shouldParkAfterFailedAcquire()(OEBPS/Text/chapter206.xhtml) done 0(旧卡承接)
211 6.5.8 线程挂起:parkAndCheckInterrupt()(OEBPS/Text/chapter207.xhtml) done 0(旧卡承接)
212 6.6 AQS的两个关键点:节点的入队和出队(OEBPS/Text/chapter208.xhtml) done 0(章节导语)
213 6.6.1 节点的自旋入队(OEBPS/Text/chapter209.xhtml) done 0(重复讲解)
214 6.6.2 节点的出队(OEBPS/Text/chapter210.xhtml) done 1
215 6.7 AQS锁释放的原理(OEBPS/Text/chapter211.xhtml) done 0(章节导语)
216 6.7.1 SimpleMockLock独占锁的释放流程(OEBPS/Text/chapter212.xhtml) done 0(图由后续卡承接)
217 6.7.2 AQS模板方法:release()(OEBPS/Text/chapter213.xhtml) done 0(旧卡承接)
218 6.7.3 钩子实现:tryRelease()(OEBPS/Text/chapter214.xhtml) done 1
219 6.7.4 唤醒后继:unparkSuccessor()(OEBPS/Text/chapter215.xhtml) done 1
220 6.8 ReentrantLock的抢锁流程(OEBPS/Text/chapter216.xhtml) done 0(旧卡承接)
221 6.8.1 ReentrantLock非公平锁的抢占流程(OEBPS/Text/chapter217.xhtml) done 0(由后续代码说明)
222 6.8.2 非公平锁的同步器子类(OEBPS/Text/chapter218.xhtml) done 0(旧卡承接)
223 6.8.3 非公平抢占的钩子方法:tryAcquire(arg)(OEBPS/Text/chapter219.xhtml) done 0(旧卡承接)
224 6.8.4 ReentrantLock公平锁的抢占流程(OEBPS/Text/chapter220.xhtml) done 0(由后续代码说明)
225 6.8.5 公平锁的同步器子类(OEBPS/Text/chapter221.xhtml) done 0(并入新卡)
226 6.8.6 公平抢占的钩子方法:tryAcquire(arg)(OEBPS/Text/chapter222.xhtml) done 1
227 6.8.7 是否有后继节点的判断(OEBPS/Text/chapter223.xhtml) done 0(并入 #226 卡)
228 6.9 AQS条件队列(OEBPS/Text/chapter224.xhtml) done 0(旧卡承接)
229 6.9.1 Condition基本原理(OEBPS/Text/chapter225.xhtml) done 0(旧卡承接)
230 6.9.2 await()等待方法原理(OEBPS/Text/chapter226.xhtml) done 1
231 6.9.3 signal()唤醒方法原理(OEBPS/Text/chapter227.xhtml) done 0(旧卡承接)
232 6.10 AQS的实际应用(OEBPS/Text/chapter228.xhtml) done 0(旧卡承接)
233 第7章 JUC容器类(OEBPS/Text/chapter229.xhtml) done 0(章节导言)
234 7.1 线程安全的同步容器类(OEBPS/Text/chapter230.xhtml) done 0(旧卡承接)
235 7.2 JUC高并发容器(OEBPS/Text/chapter231.xhtml) done 0(旧卡承接)
236 7.3 CopyOnWriteArrayList(OEBPS/Text/chapter232.xhtml) done 0(旧卡承接)
237 7.3.1 CopyOnWriteArrayList的使用(OEBPS/Text/chapter233.xhtml) done 1
238 7.3.2 CopyOnWriteArrayList的原理(OEBPS/Text/chapter234.xhtml) done 1
239 7.3.3 CopyOnWriteArrayList读取操作(OEBPS/Text/chapter235.xhtml) done 0(旧卡承接)
240 7.3.4 CopyOnWriteArrayList写入操作(OEBPS/Text/chapter236.xhtml) done 0(旧卡承接)
241 7.3.5 CopyOnWriteArrayList的迭代器实现(OEBPS/Text/chapter237.xhtml) done 1
242 7.4 BlockingQueue(OEBPS/Text/chapter238.xhtml) done 0(旧卡承接)
243 7.4.1 BlockingQueue的特点(OEBPS/Text/chapter239.xhtml) done 0(旧卡承接)
244 7.4.2 阻塞队列的常用方法(OEBPS/Text/chapter240.xhtml) done 1
245 7.4.3 常见的BlockingQueue(OEBPS/Text/chapter241.xhtml) done 3
246 7.4.4 ArrayBlockingQueue的基本使用(OEBPS/Text/chapter242.xhtml) done 0(旧卡承接)
247 7.4.5 ArrayBlockingQueue构造器和成员(OEBPS/Text/chapter243.xhtml) done 1
248 7.4.6 非阻塞式添加元素:add()、offer()方法的原理(OEBPS/Text/chapter244.xhtml) done 0(旧卡承接)
249 7.4.7 阻塞式添加元素:put()方法的原理(OEBPS/Text/chapter245.xhtml) done 0(旧卡承接)
250 7.4.8 非阻塞式删除元素:poll()方法的原理(OEBPS/Text/chapter246.xhtml) done 0(旧卡承接)
251 7.4.9 阻塞式删除元素:take()方法的原理(OEBPS/Text/chapter247.xhtml) done 0(旧卡承接)
252 7.4.10 peek()直接返回当前队列的头元素(OEBPS/Text/chapter248.xhtml) done 1
253 7.5 ConcurrentHashMap(OEBPS/Text/chapter249.xhtml) done 0(旧卡承接)
254 7.5.1 HashMap和HashTable的问题(OEBPS/Text/chapter250.xhtml) done 1
255 7.5.2 JDK 1.7版本ConcurrentHashMap的结构(OEBPS/Text/chapter251.xhtml) done 1
256 7.5.3 JDK 1.7版本ConcurrentHashMap的核心原理(OEBPS/Text/chapter252.xhtml) done 4
257 7.5.4 JDK 1.8版本ConcurrentHashMap的结构(OEBPS/Text/chapter253.xhtml) done 1
258 7.5.5 JDK 1.8版本ConcurrentHashMap的核心原理(OEBPS/Text/chapter254.xhtml) done 3
259 7.5.6 JDK 1.8版本ConcurrentHashMap的核心源码(OEBPS/Text/chapter255.xhtml) done 2
260 第8章 高并发设计模式(OEBPS/Text/chapter256.xhtml) done 0(章节导言)
261 8.1 线程安全的单例模式(OEBPS/Text/chapter257.xhtml) done 1
262 8.1.1 从饿汉式单例到懒汉式单例(OEBPS/Text/chapter258.xhtml) done 1
263 8.1.2 使用内置锁保护懒汉式单例(OEBPS/Text/chapter259.xhtml) done 1
264 8.1.3 双重检查锁单例模式(OEBPS/Text/chapter260.xhtml) done 1
265 8.1.4 使用双重检查锁+volatile(OEBPS/Text/chapter261.xhtml) done 1
266 8.1.5 使用静态内部类实现懒汉式单例模式(OEBPS/Text/chapter262.xhtml) done 0(旧卡承接:《静态内部类延迟》)
267 8.2 Master-Worker模式(OEBPS/Text/chapter263.xhtml) done 0(旧卡承接:《Master拆分调度》)
268 8.2.1 Master-Worker模式的参考实现(OEBPS/Text/chapter264.xhtml) done 2
269 8.2.2 Netty中Master-Worker模式的实现(OEBPS/Text/chapter265.xhtml) done 1
270 8.2.3 Nginx中Master-Worker模式的实现(OEBPS/Text/chapter266.xhtml) done 1
271 8.3 ForkJoin模式(OEBPS/Text/chapter267.xhtml) done 1
272 8.3.1 ForkJoin模式的原理(OEBPS/Text/chapter268.xhtml) done 1
273 8.3.2 ForkJoin框架(OEBPS/Text/chapter269.xhtml) done 1
274 8.3.3 ForkJoin框架使用实战(OEBPS/Text/chapter270.xhtml) done 1
275 8.3.4 ForkJoin框架的核心API(OEBPS/Text/chapter271.xhtml) done 3
276 8.3.5 工作窃取算法(OEBPS/Text/chapter272.xhtml) done 1
277 8.3.6 ForkJoin框架的原理(OEBPS/Text/chapter273.xhtml) done 1
278 8.4 生产者-消费者模式(OEBPS/Text/chapter274.xhtml) done 1
279 8.5 Future模式(OEBPS/Text/chapter275.xhtml) done 0(旧卡承接:《Future先给契约》;示例耗时前提留 S3 核验)
280 第9章 高并发核心模式之异步回调模式(OEBPS/Text/chapter276.xhtml) done 0(旧卡承接:Future、回调、Master-Worker)
281 9.1 从泡茶的案例讲起(OEBPS/Text/chapter277.xhtml) done 1
282 9.2 join:异步阻塞之闷葫芦(OEBPS/Text/chapter278.xhtml) done 0(旧卡承接:《主动调用会阻塞》)
283 9.2.1 线程的合并流程(OEBPS/Text/chapter279.xhtml) done 0(旧卡承接:《主动调用会阻塞》《独立任务并行后再汇合》)
284 9.2.2 调用join()实现异步泡茶喝(OEBPS/Text/chapter280.xhtml) done 0(旧卡承接:Future、join、依赖汇合;中断处理留 S3 核查)
285 9.2.3 join()方法详解(OEBPS/Text/chapter281.xhtml) done 1
286 9.3 FutureTask:异步调用之重武器(OEBPS/Text/chapter282.xhtml) done 0(旧卡承接:Callable、FutureTask、Future 契约)
287 9.3.1 通过FutureTask获取异步执行结果的步骤(OEBPS/Text/chapter283.xhtml) done 0(旧卡承接:Callable、FutureTask、Future 契约)
288 9.3.2 使用FutureTask实现异步泡茶喝(OEBPS/Text/chapter284.xhtml) done 1
289 9.4 异步回调与主动调用(OEBPS/Text/chapter285.xhtml) done 0
290 9.5 Guava的异步回调模式(OEBPS/Text/chapter286.xhtml) done 0
291 9.5.1 详解FutureCallback(OEBPS/Text/chapter287.xhtml) done 1
292 9.5.2 详解ListenableFuture(OEBPS/Text/chapter288.xhtml) done 1
293 9.5.3 ListenableFuture异步任务(OEBPS/Text/chapter289.xhtml) done 1
294 9.5.4 使用Guava实现泡茶喝的实例(OEBPS/Text/chapter290.xhtml) done 1
295 9.5.5 Guava异步回调和Java异步调用的区别(OEBPS/Text/chapter291.xhtml) done 3
296 9.6 Netty的异步回调模式(OEBPS/Text/chapter292.xhtml) done 1
297 9.6.1 GenericFutureListener接口详解(OEBPS/Text/chapter293.xhtml) done 0
298 9.6.2 Netty的Future接口详解(OEBPS/Text/chapter294.xhtml) done 1
299 9.6.3 ChannelFuture的使用(OEBPS/Text/chapter295.xhtml) done 0(既有卡承接)
300 9.6.4 Netty的出站和入站异步回调(OEBPS/Text/chapter296.xhtml) done 1
301 9.7 异步回调模式小结(OEBPS/Text/chapter297.xhtml) done 0(既有卡承接)
302 第10章 CompletableFuture异步回调(OEBPS/Text/chapter298.xhtml) done 0(既有卡承接)
303 10.1 CompletableFuture详解(OEBPS/Text/chapter299.xhtml) done 0(既有卡承接)
304 10.1.1 CompletableFuture的UML类关系(OEBPS/Text/chapter300.xhtml) done 1
305 10.1.2 CompletionStage接口(OEBPS/Text/chapter301.xhtml) done 0(既有卡修订后承接)
306 10.1.3 使用runAsync和supplyAsync创建子任务(OEBPS/Text/chapter302.xhtml) done 1
307 10.1.4 设置子任务回调钩子(OEBPS/Text/chapter303.xhtml) done 2
308 10.1.5 调用handle()方法统一处理异常和结果(OEBPS/Text/chapter304.xhtml) done 0(修订既有卡承接,无新增卡)
309 10.1.6 线程池的使用(OEBPS/Text/chapter305.xhtml) done 0(既有卡承接,无新增卡)
310 10.2 异步任务的串行执行(OEBPS/Text/chapter306.xhtml) done 0(既有卡承接,无新增卡)
311 10.2.1 thenApply()方法(OEBPS/Text/chapter307.xhtml) done 0(修订既有卡承接,无新增卡)
312 10.2.2 thenRun()方法(OEBPS/Text/chapter308.xhtml) done 0(修订既有卡承接,无新增卡)
313 10.2.3 thenAccept()方法(OEBPS/Text/chapter309.xhtml) done 0(既有卡承接,无新增卡)
314 10.2.4 thenCompose()方法(OEBPS/Text/chapter310.xhtml) done 0(既有卡承接,无新增卡)
315 10.2.5 4个任务串行方法的区别(OEBPS/Text/chapter311.xhtml) done 0(修订既有卡承接,无新增卡)
316 10.3 异步任务的合并执行(OEBPS/Text/chapter312.xhtml) done 0(既有卡承接,无新增卡)
317 10.3.1 thenCombine()方法(OEBPS/Text/chapter313.xhtml) done 1
318 10.3.2 runAfterBoth()方法(OEBPS/Text/chapter314.xhtml) done 1
319 10.3.3 thenAcceptBoth()方法(OEBPS/Text/chapter315.xhtml) done 1
320 10.3.4 allOf()等待所有的任务结束(OEBPS/Text/chapter316.xhtml) done 0(既有卡承接,无新增卡)
321 10.4 异步任务的选择执行(OEBPS/Text/chapter317.xhtml) done 0(既有卡承接,无新增卡)
322 10.4.1 applyToEither()方法(OEBPS/Text/chapter318.xhtml) done 0(既有卡承接,无新增卡)
323 10.4.2 runAfterEither()方法(OEBPS/Text/chapter319.xhtml) done 1
324 10.4.3 acceptEither()方法(OEBPS/Text/chapter320.xhtml) done 1
325 10.5 CompletableFuture的综合案例(OEBPS/Text/chapter321.xhtml) done 0(章节导语,无独立候选)
326 10.5.1 使用CompletableFuture实现泡茶喝实例(OEBPS/Text/chapter322.xhtml) done 0(既有卡承接,无新增卡)
327 10.5.2 使用CompletableFuture进行多个RPC调用(OEBPS/Text/chapter323.xhtml) done 0(既有卡承接;400/600毫秒不一致留S3)
328 10.5.3 使用RxJava模拟RPC异步回调(OEBPS/Text/chapter324.xhtml) done 1
上下游调度各有边界 已复用 notes/_topics/async-composition.md

待关联术语

术语名 出现章节 一句话语境
RxJava 第9章 9.4、10.5.3 第9章仅提名;#328用Observable与调度/汇合API演示RPC回调,但未展开响应式模型、背压等概念,保留待关联。

引用文献

标题 类型(书/论文/框架/源码项目) 出现章节 一句话语境
《Spring Cloud、Nginx高并发核心编程》 书 第9章 9.4 作为 RxJava 延伸阅读建议,未在本段展开介绍。

S4 修订说明(两轮:S2初次生成 + S3审查后修订)

S2轮:全部 56 张卡片的 分类 字段已从历史旧枚举”专业/工作”迁移为当前模板六选一枚举(全部判定为”普通读书笔记卡”,本书未出现问题卡/延伸参考卡/操作参考卡/支付系统案例卡/结构图卡取材场景),并补齐 **参考来源** 的”位置/结论依据/原始内容”三项证据字段,逐一回读 _epub-src 对应 XHTML 原文核实。新增 P1 卡片 6 张(ch02-006、ch05-006、ch05-007、ch10-006、ch10-007,以及 P2 追加的 ch05-008),单卡修订 7 张(ch02-003、ch03-002、ch04-003、ch07-004、ch09-003、ch10-004、ch10-005)。

S3独立审查后的S4轮:审查发现系统性问题——54/56张卡片的 **内容** 字段超过 card-template.md 规定的 200 字硬上限(最严重 504 字),已全部逐张精简至 ≤200 字,删减内容中的版本号、多重限定移入”结论依据”字段或直接精简;同时补齐3张P1新增卡(ch01-006中断标志、ch01-007拒绝策略、ch05-009 CountDownLatch)+ 1张P2新增卡(ch05-010可重入),当前共 60 张卡片,全部通过 ≤200 字、三项证据字段齐全、无重复标题、无wikilink断链的机械复核。详见 _card_review.md 问题清单与对应卡片文件。

实践卡进度

序号 实践标题 实践方式 状态(pending/done) 关联章节 产出
1 CHM桶锁在JDK17是否成立 实现深读 done 7 原历史核验保留;本轮补固定标签官方入口、首轮映射及两层计划,未重跑
2 if判断wait条件真的会出错吗 其他(最小实验) done 2 原历史一次交错记录:3消费者中2个取空;不代表错误概率、未测虚假唤醒;本轮未运行
3 公共池线程饥饿的真实代价 其他(最小实验) done 10 原历史合成阻塞样例记录2004ms/0ms;不代表当前机器或实际IO测量,本轮未运行
4 复现懒汉单例竞态 其他(最小实验) done 8 计划固定并发判空交错并对比对象身份;尚未执行

实践候选筛选:done

筛选结论:保留四项具体计划,区分历史观察和新执行;暂不另造完整并发库或部署实验。更高成本实现并不能更直接回答这些机制与交错问题。原临时代码未在本轮恢复,历史记录不作为本轮实测证据。

V10 类别清单核对

沿用历史“编程语言类”标签,对照当前类别清单逐项复核。本书重点是 Java 线程、JMM、同步器和 JUC 组件;清单中属于 Java 语言全貌、但原书没有实质展开的维度如实记为未覆盖。零散的 API 示例或术语提及不等于解释该维度的设计机制。

维度 覆盖状态 关联卡片标题或未覆盖理由
类型系统 未覆盖 Callable<V> 的返回类型只用于异步任务示例;原书未解释 Java 类型系统、推断或泛型实现。
内存管理模型 未覆盖 GC 线程只作为守护线程和运行时背景出现;原书未比较内存管理策略及取舍。
并发/并行模型 已覆盖 《线程是调度粒度》《JMM规则不等于物理内存布局》《同步队列排失败者》《工作窃取补负载》等分别覆盖线程、可见性、同步与并行任务。
错误处理机制 未覆盖 《异步链必须处理异常》等覆盖并发任务的异常传播,但原书未讨论语言级错误处理机制及与其他模型的取舍。
编译/执行模型 未覆盖 第 4 章在指令重排论证中涉及字节码、解释执行和 JIT,但没有系统讲解编译/执行模型及其设计。
模块/包与命名空间设计 未覆盖 代码示例中的 package 与导入语句只用于组织示例,未讲解模块或命名空间设计。
语言设计哲学与取舍 未覆盖 对 Java 并发 API 的用法和机制有比较,但没有以语言设计哲学或跨语言取舍为主题展开。
元编程/反射/宏能力 未覆盖 第 3 章通过反射获取 Unsafe 只是示例入口,未解释反射或元编程能力的机制与边界。
性能特性与其代价 已覆盖 《线程池要有边界》《CAS是乐观提交》《LongAdder分散热点》《读写锁看比例》等说明吞吐、竞争与资源代价。

主题索引维护

本轮复核 58 张此前待定卡:53 张复用已有主题,5 张无需加入;历史主题维护结论保留,以本表逐卡记录为准。

卡片标题 结论 主题文件或原因
线程是调度粒度 已复用 notes/_topics/concurrency-tasks-sync.md
进程是程序的运行实例 无需加入 概念区分用于线程章入门;现有并发任务主题聚焦线程/任务/同步语义,进程定义没有独立跨卡路径
进程控制块保存上下文 无需加入 进程管理结构细节;现有并发任务与单机I/O主题均不以PCB结构为阅读路径
线程私有栈保存调用帧 已复用 notes/_topics/concurrency-tasks-sync.md
start才启动新线程 已复用 notes/_topics/concurrency-tasks-sync.md
就绪不等于运行 已复用 notes/_topics/concurrency-tasks-sync.md
Runnable只定义执行目标 已复用 notes/_topics/concurrency-tasks-sync.md
函数式接口可用Lambda实现 无需加入 Java语言语法桥接说明;现有并发主题不涵盖函数式接口设计
库存检查与扣减分离会超卖 已复用 notes/_topics/concurrency-tasks-sync.md
库存校验与扣减同锁保护 已复用 notes/_topics/concurrency-tasks-sync.md
Callable能返回计算结果 已复用 notes/_topics/concurrency-tasks-sync.md
懒加载判空不能保证单例 已复用 notes/_topics/memory-model-visibility.md
同步单例也会锁热路径 已复用 notes/_topics/lock-implementation.md
双检需锁内复查 已复用 notes/_topics/memory-model-visibility.md
FutureTask承接结果 已复用 notes/_topics/concurrency-tasks-sync.md
线程池复用工作线程 已复用 notes/_topics/thread-pool-capacity-overload.md
submit返回结果句柄 已复用 notes/_topics/async-composition.md
时间片轮换形成并发 已复用 notes/_topics/concurrency-tasks-sync.md
优先级不保证执行机会 已复用 notes/_topics/concurrency-tasks-sync.md
stop可能破坏资源状态 已复用 notes/_topics/concurrency-tasks-sync.md
Java线程状态转换 已复用 notes/_topics/concurrency-tasks-sync.md
线程转储是瞬时快照 已复用 notes/_topics/debugging-root-cause.md
有意义线程名便于追踪 已复用 notes/_topics/logging-observability.md
sleep不保证到点即运行 已复用 notes/_topics/concurrency-tasks-sync.md
阻塞中断会清除标志 已复用 notes/_topics/concurrency-tasks-sync.md
join等待目标线程结束 已复用 notes/_topics/concurrency-tasks-sync.md
yield只是调度提示 已复用 notes/_topics/concurrency-tasks-sync.md
守护状态须在启动前设置 已复用 notes/_topics/concurrency-tasks-sync.md
Executor分离提交与执行 已复用 notes/_topics/thread-pool-capacity-overload.md
固定频率与固定延迟起点不同 无需加入 周期任务调度口径;现有异步结果编排与线程池容量主题均不以定时调度为阅读路径
线程池参数共同决定容量 已复用 notes/_topics/thread-pool-capacity-overload.md
任务异常由Future承载 已复用 notes/_topics/async-composition.md
线程工厂统一配置工作线程 已复用 notes/_topics/thread-pool-capacity-overload.md
零容量队列直接交接 已复用 notes/_topics/thread-pool-capacity-overload.md
线程池后置钩子清理线程上下文 已复用 notes/_topics/thread-pool-capacity-overload.md
线程池关闭先停接收再等任务 已复用 notes/_topics/thread-pool-capacity-overload.md
按线程初始化 已复用 notes/_topics/concurrency-tasks-sync.md
线程局部值仅本线程 已复用 notes/_topics/concurrency-tasks-sync.md
线程各有本地变量表 已复用 notes/_topics/concurrency-tasks-sync.md
同一对象锁保护临界区 已复用 notes/_topics/concurrency-tasks-sync.md
拆锁前确认状态不变量独立 已复用 notes/_topics/lock-implementation.md
静态同步锁住Class对象 已复用 notes/_topics/lock-implementation.md
对象布局依配置而变 已复用 notes/_topics/lock-implementation.md
字节序决定多字节布局 无需加入 通用数据表示基础;现有锁实现主题聚焦锁状态与竞争,不把字节序作为其成员
锁记录保存旧对象头 已复用 notes/_topics/lock-implementation.md
监视器区分入锁与条件等待 已复用 notes/_topics/lock-implementation.md
线程通信协调共享状态 已复用 notes/_topics/concurrency-tasks-sync.md
检查条件与等待须共锁 已复用 notes/_topics/concurrency-tasks-sync.md
CAS失败后重读并重算 已复用 notes/_topics/lock-free-atomics.md
按更新目标选择原子类 已复用 notes/_topics/lock-free-atomics.md
原子数组逐元素更新 已复用 notes/_topics/lock-free-atomics.md
原子引用只原子替换引用 已复用 notes/_topics/lock-free-atomics.md
布尔标记不能计数变更 已复用 notes/_topics/lock-free-atomics.md
cellsBusy协调槽修改 已复用 notes/_topics/lock-free-atomics.md
可见性不能消除丢失更新 已复用 notes/_topics/memory-model-visibility.md
观测到零零不证明发生重排 已复用 notes/_topics/memory-model-visibility.md
MESI按缓存行协调副本 已复用 notes/_topics/memory-model-visibility.md
发布标志应建立先行关系 已复用 notes/_topics/memory-model-visibility.md
JMM规则不等于物理内存布局 已复用 notes/_topics/memory-model-visibility.md
线程池要有边界 已创建 notes/_topics/thread-pool-capacity-overload.md
按任务类型配线程 已创建 notes/_topics/thread-pool-capacity-overload.md
ThreadLocal隔离 已复用 notes/_topics/concurrency-tasks-sync.md
Daemon不担保收尾 已复用 notes/_topics/concurrency-tasks-sync.md
中断只是设置一个标志 已复用 notes/_topics/concurrency-tasks-sync.md
拒绝策略决定过载去向 已创建 notes/_topics/thread-pool-capacity-overload.md
竞态来自复合操作 已复用 notes/_topics/concurrency-tasks-sync.md
对象头承载锁态 已创建 notes/_topics/lock-implementation.md
锁会逐级膨胀 已创建 notes/_topics/lock-implementation.md
等待通知须持锁 已复用 notes/_topics/concurrency-tasks-sync.md
生产消费靠条件 已复用 notes/_topics/concurrency-tasks-sync.md
等待条件必须循环复查 已复用 notes/_topics/concurrency-tasks-sync.md
CAS是乐观提交 已创建 notes/_topics/lock-free-atomics.md
Unsafe连接硬件 已创建 notes/_topics/lock-free-atomics.md
ABA要看历史 已创建 notes/_topics/lock-free-atomics.md
LongAdder分散热点 已创建 notes/_topics/lock-free-atomics.md
无锁也有边界 已创建 notes/_topics/lock-free-atomics.md
并发三难题 已创建 notes/_topics/memory-model-visibility.md
缓存带来可见性 已创建 notes/_topics/memory-model-visibility.md
volatile传递信号 已创建 notes/_topics/memory-model-visibility.md
屏障约束重排 已创建 notes/_topics/memory-model-visibility.md
HB是推理工具 已创建 notes/_topics/memory-model-visibility.md
显式锁需模板 已创建 notes/_topics/lock-implementation.md
LockSupport是地基 已创建 notes/_topics/lock-implementation.md
自旋怕总线风暴 已创建 notes/_topics/lock-implementation.md
CLH排队降竞争 已创建 notes/_topics/lock-implementation.md
读写锁看比例 已创建 notes/_topics/lock-implementation.md
Semaphore限制共享名额 已复用 notes/_topics/concurrency-tasks-sync.md
乐观读必须验证快照 已创建 notes/_topics/lock-implementation.md
可中断抢锁用于可取消等待 已创建 notes/_topics/lock-implementation.md
CountDownLatch一次性计数 已复用 notes/_topics/concurrency-tasks-sync.md
可重入锁允许自己再进 已创建 notes/_topics/lock-implementation.md
AQS是同步骨架 已创建 notes/_topics/lock-implementation.md
模板方法管流程 已创建 notes/_topics/lock-implementation.md
同步队列排失败者 已创建 notes/_topics/lock-implementation.md
挂起前要确认前驱 已创建 notes/_topics/lock-implementation.md
条件队列分离等待 已创建 notes/_topics/lock-implementation.md
同步容器锁太粗 已创建 notes/_topics/concurrent-containers.md
写时复制偏向读 已创建 notes/_topics/concurrent-containers.md
阻塞队列管背压 已复用 notes/_topics/overload-protection-degradation.md
CHM分段到桶锁 已创建 notes/_topics/concurrent-containers.md
并发容器选模型 已创建 notes/_topics/concurrent-containers.md
DCL必须配volatile 已创建 notes/_topics/memory-model-visibility.md
静态内部类延迟 已创建 notes/_topics/memory-model-visibility.md
Master拆分调度 已复用 notes/_topics/concurrency-tasks-sync.md
工作窃取补负载 已复用 notes/_topics/goroutine-scheduling.md
Future先给契约 已复用 notes/_topics/concurrency-tasks-sync.md
主动调用会阻塞 已创建 notes/_topics/async-composition.md
回调反转方向 已创建 notes/_topics/async-composition.md
回调线程要识别 已创建 notes/_topics/async-composition.md
Guava增强Future 已创建 notes/_topics/async-composition.md
Netty监听IO完成 已创建 notes/_topics/async-composition.md
阶段表达流水线 已创建 notes/_topics/async-composition.md
用返回契约选异步工厂 已复用 notes/_topics/async-composition.md
观察与恢复分开 已复用 notes/_topics/async-composition.md
取消进入异常完成 已复用 notes/_topics/async-composition.md
双接口异步契约 已复用 notes/_topics/async-composition.md(S6 同步成员)
串行依赖选方法 已创建 notes/_topics/async-composition.md
Compose避免嵌套 已创建 notes/_topics/async-composition.md
两路结果在此合并 已复用 notes/_topics/async-composition.md
两路就绪后做副作用 已复用 notes/_topics/async-composition.md
消费双路结果不产值 已复用 notes/_topics/async-composition.md
任一路正常后触发动作 已复用 notes/_topics/async-composition.md
消费择快结果不产值 已复用 notes/_topics/async-composition.md
合并等待全部 已创建 notes/_topics/async-composition.md
择快不是择优 已创建 notes/_topics/async-composition.md
默认公共池不放阻塞任务 已创建 notes/_topics/thread-pool-capacity-overload.md
异步链必须处理异常 已创建 notes/_topics/async-composition.md
AQS竞争入队用CAS循环 已复用 notes/_topics/lock-implementation.md
递归任务按结果选基类 已复用 notes/_topics/concurrency-tasks-sync.md
缓冲区隔离生产消费依赖 已复用 notes/_topics/concurrency-tasks-sync.md
sizeCtl协调扩容 已复用 notes/_topics/concurrent-containers.md
回调汇合要防重复 已复用 notes/_topics/async-composition.md
发送次数不等于回写条数 无需加入 Netty演示的计数口径勘误;现有异步编排主题聚焦结果契约,不收录该特定案例计量
读写锁可降级但不支持升级 已复用 notes/_topics/lock-implementation.md
模板方法固定算法骨架 已复用 notes/_topics/lock-implementation.md
公平锁不约束线程调度 已复用 notes/_topics/lock-implementation.md
独占释放验证持有线程 已复用 notes/_topics/lock-implementation.md
迭代器固定数组快照 已复用 notes/_topics/concurrent-containers.md
两种写入语义不同 已复用 notes/_topics/concurrent-containers.md
分治提交契约不同 已复用 notes/_topics/concurrency-tasks-sync.md
用任务结果门控后续操作 已复用 notes/_topics/async-composition.md
数组与链式队列的取舍 已复用 notes/_topics/concurrent-containers.md
锁竞争会带来阻塞与调度成本 已复用 notes/_topics/lock-implementation.md
可重入锁组合AQS 已复用 notes/_topics/lock-implementation.md
反向获取锁会形成循环等待 已复用 notes/_topics/concurrency-tasks-sync.md
子任务结果仍需归并 已复用 notes/_topics/concurrency-tasks-sync.md
成功失败走不同回调 已复用 notes/_topics/async-composition.md
归并结果需要完成信号 已复用 notes/_topics/async-composition.md
树化阈值与数组容量分开判断 已复用 notes/_topics/concurrent-containers.md
读写索引分工 已复用 notes/_topics/concurrent-containers.md
死锁检测范围有边界 已复用 notes/_topics/debugging-root-cause.md
AQS钩子定义资源语义 已复用 notes/_topics/lock-implementation.md
join只等待不返回结果 已复用 notes/_topics/async-composition.md
并行度不是线程硬上限 已复用 notes/_topics/concurrency-tasks-sync.md
await释放并重获锁 已复用 notes/_topics/lock-implementation.md
JDK7并发映射读路径不取段锁 已复用 notes/_topics/concurrent-containers.md
asyncMode控制队列顺序 已复用 notes/_topics/concurrency-tasks-sync.md
AQS节点状态协调等待 已复用 notes/_topics/lock-implementation.md
HashMap并发修改需要同步 已复用 notes/_topics/concurrent-containers.md
Netty结果补监听 已复用 notes/_topics/async-composition.md
框架回调接口的角色映射 已复用 notes/_topics/async-composition.md
写者串行与引用发布 已复用 notes/_topics/concurrent-containers.md
等待子任务时继续干活 已复用 notes/_topics/concurrency-tasks-sync.md
唤醒时逆向查有效后继 已复用 notes/_topics/lock-implementation.md
无界队列不提供背压 已复用 notes/_topics/overload-protection-degradation.md
可变链路须安全发布 已复用 notes/_topics/concurrent-containers.md
闭区间阈值差一个元素 无需加入 书中分治求和示例的闭区间边界勘误;现有跨书主题没有以这一局部算式为阅读路径
Nginx管理监听与工作进程 已复用 notes/_topics/server-io-concurrency-models.md
阻塞队列四种操作策略 已复用 notes/_topics/concurrent-containers.md
peek只观察不占有队首 已复用 notes/_topics/concurrent-containers.md
AQS队列按竞争懒初始化 已复用 notes/_topics/lock-implementation.md
Master双层队列须限容量 已复用 notes/_topics/overload-protection-degradation.md
监听接口承接回调 已复用 notes/_topics/async-composition.md
延迟队列等待到期 已复用 notes/_topics/concurrent-containers.md
工作线程处理IO 已复用 notes/_topics/server-io-concurrency-models.md
AQS状态迁移需要CAS 已复用 notes/_topics/lock-implementation.md
不可中断获取会恢复中断标志 已复用 notes/_topics/lock-implementation.md
公平获取先检查队列前驱 已复用 notes/_topics/lock-implementation.md
分治池没有中心调度 已复用 notes/_topics/concurrency-tasks-sync.md
树桶容器与树节点不同 已复用 notes/_topics/concurrent-containers.md
同步包装不改变可变性 已复用 notes/_topics/concurrent-containers.md
Node固定键并可见值链 已复用 notes/_topics/concurrent-containers.md
独立任务并行后再汇合 已复用 notes/_topics/async-composition.md
JDK8并发映射读取不加锁 已复用 notes/_topics/concurrent-containers.md
JDK7并发哈希表两层分桶 已复用 notes/_topics/concurrent-containers.md
单例唯一性与线程安全分开看 无需加入 单例模式的概念边界;现有内存模型主题聚焦可见性和安全发布,不把一般设计辨析作为成员
AQS成功获取后推进队首 已复用 notes/_topics/lock-implementation.md
抢段锁时扫描可复用准备 已复用 notes/_topics/concurrent-containers.md
非空桶写入先锁定再复核 已复用 notes/_topics/concurrent-containers.md
窃取任务是一场竞争 已复用 notes/_topics/concurrency-tasks-sync.md

本轮整书笔记交接

  • 191张原卡路径和字节hash与本轮基线一致,未新建或删改卡。
  • 笔记schema 1;EPUB及原始XHTML哈希、325位置与191卡出处以笔记及evidence为准。
  • 轻量模式:未执行本轮笔记复核、独立审查及审查结果优化;历史报告保留,不把旧审查说成本次执行。

相关主题

从本书的主题进入跨书阅读,对照其他书籍的讲解。下方数量包含主题关联的全部卡片与书籍。

主题索引

过载保护与优雅降级

比较限流、减载、退避重试、分级依赖与防御成本的过载应对手段。

386 张卡片 · 68 本书

主题索引

单机高性能与I/O模型

比较进程/线程并发模型、I/O 多路复用、Reactor 与 Proactor 等单机高性能设计。

226 张卡片 · 46 本书

主题索引

并发任务与同步原语

比较线程/任务抽象、异步结果传递、原子与同步手段的语义差异和生命周期约束。

215 张卡片 · 41 本书

主题索引

追踪与上下文

Trace/Span 模型、标识与上下文传播、采样取舍、OpenTelemetry 与采集器管道。

199 张卡片 · 44 本书

主题索引

异步编程与结果编排

比较 Future、回调、监听器与阶段式编排在阻塞、线程归属、组合与异常传播上的差异。

140 张卡片 · 30 本书

主题索引

线程与任务抽象

线程的创建、状态、join/sleep/中断与收束,任务抽象为什么高于线程,线程池与 ForkJoin 的并行度与工作窃取,守护线程、ThreadLocal 与线程私有栈在什么条件下成立,以及并发结构怎样划分执行与状态;Actor/角色把状态隔离到单一线程、用 Inbox 串行收消息,是这条线的另一种解法。

112 张卡片 · 27 本书

主题索引

创建型模式

把对象创建从使用中隔离出来:单例、工厂方法、抽象工厂、建造者、原型,以及各自的代价与语言差异。

104 张卡片 · 9 本书

主题索引

异步结果的组合

Future 先给契约、回调反转调用方向,Promise 三态与 then 链、async/await 与 generator 把异步写成线性,阶段式组合(Compose/AllOf/择快)在异常传播与线程归属上的差异,以及回调地狱与 Zalgo 这类时序陷阱。

82 张卡片 · 10 本书

主题索引

互斥、条件与死锁

互斥锁与读写锁的适用比例、信号量与 CountDownLatch 的语义差别、条件等待为什么必须持锁并循环复查、锁顺序与可重入导致的死锁,以及粗粒度锁换简单性与细粒度锁换并发的代价。

81 张卡片 · 21 本书

主题索引

编程范式与设计

比较函数式与面向对象、一切皆对象、鸭子类型与泛型等语言范式对模块化、复用与扩展的影响。

77 张卡片 · 11 本书

主题索引

线程池容量边界与过载策略

比较线程池/工作队列如何设定容量边界、按任务类型配置线程以及越界后的拒绝、丢弃与背压策略。

75 张卡片 · 34 本书

主题索引

故障排查与根因分析

比较排查系统问题时的假设管理、基线对比与复现方法。

74 张卡片 · 21 本书

主题索引

事件循环与 NIO 线程模型

Reactor 与事件循环的基本结构,Netty 的 IO 线程与业务线程分工,Nginx 的事件模块、posted 请求、子请求调度与缓冲输出,响应式流的建模方式,以及阻塞调用如何破坏异步链路。

68 张卡片 · 11 本书

主题索引

数值表示与精度

比较浮点、定点等数值表示的精度误差与特殊值陷阱。

62 张卡片 · 9 本书

主题索引

内存模型与原子语义

原子不等于易变、volatile 不等于互斥,读改写为什么必须整体原子,竞态与数据争用的判定,内存屏障与顺序一致,双重检查锁与懒加载的发布问题,以及 Race 检测只覆盖运行路径的局限。

54 张卡片 · 19 本书

主题索引

锁的实现与竞争优化

比较锁状态存储、锁膨胀、自旋与排队队列、同步器骨架等锁实现机制及其竞争开销。

45 张卡片 · 7 本书

主题索引

Netty框架内部机制

Netty 的反应器、通道、流水线与处理器、ByteBuf 内存管理和编解码器的设计与使用边界。

44 张卡片 · 6 本书

主题索引

协程与线程调度模型

比较用户态协程、M:N 调度、工作窃取与抢占等调度器设计。

30 张卡片 · 9 本书

主题索引

并发容器选型

比较同步容器、写时复制、分段/桶锁等并发容器的一致性模型与读写取舍。

28 张卡片 · 3 本书

主题索引

缓冲、队列与限流

环形缓冲与乒乓缓冲怎样吸收速率差,有界队列的空满约束与 FIFO 余量,生产消费模型如何做限流与并发上限,以及缓冲只能吸收有限速差、不能替代背压。

19 张卡片 · 9 本书

主题索引

内存模型与可见性

比较缓存可见性、指令重排、内存屏障与 happens-before 等内存模型规则及安全发布手段。

18 张卡片 · 5 本书

主题索引

无锁与原子操作

比较 CAS、原子类、热点分散与 ABA 等无锁编程机制及其适用边界。

17 张卡片 · 6 本书

主题索引

定时任务与时钟轮调度

比较扫描、时间槽与分层时钟轮的调度成本,及截止时间校验和周期任务重排的边界。

16 张卡片 · 12 本书