来源书籍

消息队列高手课

Skill 版本:v23 工程实践(高信息浓度 + 较低稳定性) 194 张卡片

课程持续解释可靠性、幂等、异步、锁、缓存与复制的原因和权衡,信息浓度高;但主要论证依托具体时期Kafka/RocketMQ/Flink/Java/Go实现、产品选型与API,部分市场、协议与内核描述已有时点或简化边界。因此原理可长期迁移,整门课程作为工程实现教材仍需按版本核对,定为工程实践。 **内容形态**:问题思考型。多数讲围绕具体问题、分析、方案与取舍组织;概念解释、代码结构和局部操作按实际内容分别保留。 **书籍身份**:目录“消息队列高手课”沿用既有身份;OPF标题“消息队列高手课[更新完毕]”是同一本课程汇编。作者由讲师介绍及开篇自述交叉确认为李玥;OPF网站creator与0101年日期不作为真实作者/出版时间,其他未知出版字段为null。 **整书笔记**:[_book_note.md](_book_note.md);阅读与取舍见[_coverage.md](_coverage.md)。原书35讲、开篇/预习/JMQ加餐/测试图题/结束语等按实际225spine计划处理,分片不是新造的讲号。

李玥

全书导读

消息队列在不同进程之间搬运并暂存数据,让生产者与消费者在不同时间、不同速度工作。但异步交接也引入不确定性:确认可能丢失,消息会重投,故障时进度和副作用可能脱节。本课程先教如何使用消息、主题、消费组和事务,再深入实现所需的网络、序列化、内存、缓存、锁、复制与路由,最后通过流计算和RPC把这些知识组合起来。

课程是具体时期的工程教材,产品现状、配置与源码以其本地版本为准;本次必要边界核对明确区分了原文说明、读者推导与当前固定版本观察。没有答案的练习仍是问题,作者测时不是本轮实测。分片HTML按原书顺序逐项讲解,讲号保持原课程编号。

全书主线

第一层是业务行为:为什么异步、如何判断顺序和可靠性、重复消息怎样保护业务状态。第二层是实现资源:线程不应无谓等待,字节需要边界,数据布局和批量改变IO成本,内存和缓存需要明确生命周期与一致性。第三层是分布式协作:路由、复制、事务和故障恢复决定一个节点以外的行为。最后的Flink与RPC案例检验这些机制能否在不同系统中组合,而不是只记住某个产品名字。

flowchart TD
 A[业务需求与故障边界] --> B[消息模型和确认]
 B --> C[幂等 顺序与事务]
 D[异步 网络与序列化] --> E[内存 缓存与IO]
 E --> F[锁 CAS与复制]
 C --> G[具体源码与案例]
 F --> G
 G --> H[流计算与RPC组合]

简介 · 课程介绍

课程把消息队列当作理解分布式软件的入口。收发API很简单,生产中却要面对选型、重复、丢失和扩展;网络、存储与并发机制能帮助解释这些问题,而不是只记住某个产品的配置。

简介 · 模块介绍

课程按基础、进阶、案例三层组织。基础篇解决使用中的常见问题;进阶篇先讲异步、通信与内存等技术,再走进具体源码;案例篇把这些技术用于流计算与RPC两个不同领域,检验能否迁移理解。

开篇词-优秀的程序员,你的技术栈中不能只有“增删改查”

开篇说明讲师从基础中间件研发经验出发设计课程,案例背景涉及2018–2019年JMQ重构和业务活动。这里保留课程动机与历史语境,不把节点规模、性能或开源预期当作当前产品事实。

开篇词-优秀的程序员,你的技术栈中不能只有“增删改查” · 底层技术知识,给你深入解决业务问题的能力

理解实现原理的用途是遇到新故障时仍能推理。只会搜索报错可能碰运气;知道消息在哪些阶段传输、存储和确认,才能根据现象定位风险,再检查相应配置。消息队列功能相对集中,却包含多种通用底层问题。

原理支撑故障定位保留这一小节的独立机制与边界。

原书依据 · 1 处

开篇词-优秀的程序员,你的技术栈中不能只有“增删改查” · 课程设置

三个模块之间有依赖而非互相替代:先理解使用模型和可靠性,再把核心机制对应到源码,最后用不同项目检验。流计算案例偏向消息与计算任务的衔接,RPC案例则检验网络、协议、序列化和并发这些基础技术。

开篇词-优秀的程序员,你的技术栈中不能只有“增删改查” · 写在最后

开篇以制定计划、持续练习和回看目标结束。它要求把理解落实到代码和反思,而不是仅以读完文章衡量掌握;这里没有提供独立算法或实践结果,因此不凭鼓励性语句增卡。

预习-怎样更好地学习这门课?

预习把学习问题定位为缺乏清晰知识路径。消息队列既承担进程通信,也连接高并发、存储和分布式协作,适合从使用走向实现。后续内容将分层建立这张知识地图。

预习-怎样更好地学习这门课? · 哪些人适合学消息队列?

课程适合后端开发者以及希望深入实现的人。前者需要解决消息交互与业务可靠性,后者可借消息队列研究网络、存储和并发;这里是目标读者说明,并不要求所有学习者都去开发一个新中间件。

预习-怎样更好地学习这门课? · 学习消息队列,有哪些门槛?

学习前需要熟悉一门语言、基本集合、文件和网络IO、多线程、UML及常见设计概念。英文文档和Java生态有助于阅读课程案例,但不意味着必须先掌握所有产品。积极提问与练习是学习建议,不能由几个自评问题推断人的技术热爱程度。

预习-怎样更好地学习这门课? · 由浅入深学习消息队列

学习顺序是先认识主题、订阅和分区,再处理使用问题,之后阅读源码并补网络、内存和锁等基础,最后通过实际任务验证。理解不只停留在“能说出名词”,也应能解释为什么以及在何种条件下有效。

从使用逐步进入实现保留这一小节的独立机制与边界。

原书依据 · 1 处

预习-怎样更好地学习这门课? · 一份知识图谱

生态图把产品、协议标准、语言、应用和实现技术分成不同维度。无需把所有产品先学一遍,先认识通用问题和各自术语,再选择需要深入的对象。图中JMS、AMQP、MQTT与OpenMessaging等在此只是地图入口,后文会展开部分协议。

预习-怎样更好地学习这门课? · 学习资源推荐

资料选择优先考虑项目官方文档,并与实际使用版本相符。遇到问题可以用搜索补充线索,但仍需回到原始资料检验,避免把滞后翻译或其他版本经验当作当前配置答案。

资料跟随项目版本保留这一小节的独立机制与边界。

原书依据 · 1 处

01-为什么需要消息队列?

巧克力工厂的传送带和仓库分别对应通信与缓冲。仓库使上游不必等待下游空闲,从而吸收短期速度差;消息队列也是在生产和消费之间放置一个可暂存的交接点。它不能消除无限增长的负载。

队列缓冲上下游速差保留这一小节的独立机制与边界。

原书依据 · 1 处

01-为什么需要消息队列? · 哪些问题适合使用消息队列来解决?

本节比较三类用途。异步处理把不决定即时结果的步骤移出关键路径;削峰把瞬时压力转成队列中的等待;令牌桶则先发有限令牌,控制哪些请求可进入。令牌积累允许短时突发,不能只用当期新增量估算上限。发布订阅让多个下游从订单主题获得数据,减少生产者随下游数量反复改动。可靠落地、超时含义和数据契约仍需另行处理。

异步缩短关键路径保留这一小节的独立机制与边界。

队列削峰的代价保留这一小节的独立机制与边界。

令牌桶允许有限突发保留这一小节的独立机制与边界。

发布订阅隔离下游变化保留这一小节的独立机制与边界。

原书依据 · 4 处

01-为什么需要消息队列? · 小结

队列并非无成本的解耦按钮。它增加链路时延、部署和异步交互复杂度,还可能使不同数据副本短暂不一致。只有能说明它缓冲、分发或重叠等待的具体作用,才能评价是否值得采用。

引入队列也增加成本保留这一小节的独立机制与边界。

原书依据 · 1 处

01-为什么需要消息队列? · 思考题

思考题要求从实际系统中找出队列解决的问题,并比较新增成本。这里提出观察任务,没有给出具体系统或答案;它作为前述用途分析的应用入口,不凭空补造业务案例。

02-该如何选择消息队列?

选型先承认每个系统约束不同。产品的优点只有在对应业务场景下才有意义,所以应比较可靠性、吞吐、时延、维护与生态,而不是寻找一个通用冠军。

选型没有万能优胜者保留这一小节的独立机制与边界。

原书依据 · 1 处

02-该如何选择消息队列? · 选择消息队列产品的基本标准

候选产品先满足可靠传递、集群与性能基本要求,再考虑源码可访问性、社区支持和生态集成。课程把开源和活跃社区作为风险控制取向;当下的维护、许可和版本能力需要重新核验。

候选产品先过基本门槛保留这一小节的独立机制与边界。

原书依据 · 1 处

02-该如何选择消息队列? · 可供选择的消息队列产品

RabbitMQ的Exchange提供可配置路由;RocketMQ在课程中被用于说明低延迟在线业务取向;Kafka以异步批量和数据生态为主要比较维度。课中性能数字和产品优劣是成稿时经验,不能直接当作当前测评。应把这些差异转成自己的负载与维护问题。

RabbitMQ以交换机路由保留这一小节的独立机制与边界。

RocketMQ的在线业务取向保留这一小节的独立机制与边界。

Kafka用批量换吞吐保留这一小节的独立机制与边界。

原书依据 · 3 处

02-该如何选择消息队列? · 第二梯队的消息队列

本节补充三类历史比较对象:ActiveMQ被作者作为兼容旧系统的背景,ZeroMQ被区分为进程内可集成通信库,Pulsar引出存储计算分离。前者的市场评价按当时语境保留,后两者有结构性区别值得分别理解。

ZeroMQ是进程内通信库保留这一小节的独立机制与边界。

Pulsar分离存储与计算保留这一小节的独立机制与边界。

原书依据 · 2 处

02-该如何选择消息队列? · 总结

选型总结把轻量维护、在线业务、日志与流计算映射到不同关注点。真正可迁移的是根据需求比较,而不是固定产品名单;已有技术熟悉度也影响学习与运维成本。

02-该如何选择消息队列? · 思考题

本节思考题要求给出现有系统需求和选择理由,没有提供新案例的分析结果。可以用基本门槛和场景维度审视已有决定,但不把课程产品推荐自动移植到自己的环境。

03-消息模型:主题和队列有什么区别?

不同消息产品对Queue、Topic、Partition的用词并不完全一致,需要先建立共同业务模型。课程对标准状态的判断属于当时意见,不能由此声称JMS或AMQP已不再使用。

03-消息模型:主题和队列有什么区别? · 主题和队列有什么区别?

队列模型中消费者竞争一份消息;发布订阅模型中,各订阅分别取得完整数据。主题是发布的逻辑入口,订阅是独立消费视图;同一订阅内部仍可把工作分给多个消费者。它们是行为模型,不直接限定物理存储方式。

队列消费者竞争一份消息保留这一小节的独立机制与边界。

订阅是一份独立消费视图保留这一小节的独立机制与边界。

原书依据 · 2 处

03-消息模型:主题和队列有什么区别? · RabbitMQ的消息模型

RabbitMQ用Exchange和多个队列实现广播式订阅。生产者发送给Exchange,由路由规则扇出;不同业务要全量数据,应落到不同队列。同队列增加消费者,只增加竞争处理者,不会自动让每个人都拿到全量消息。

交换机扇出实现发布订阅保留这一小节的独立机制与边界。

原书依据 · 1 处

03-消息模型:主题和队列有什么区别? · RocketMQ的消息模型

确认机制在生产和消费两侧建立重试依据,但也意味着可能重复。主题下拆出多个队列可提高并行度,同时把顺序范围限定在队列内;消费组表示完整订阅,组内消费者分工,Offset按组和队列保存完成位置。

确认与重发支撑可靠传输保留这一小节的独立机制与边界。

分区把有序范围切小保留这一小节的独立机制与边界。

消费组与消费位置保留这一小节的独立机制与边界。

原书依据 · 3 处

03-消息模型:主题和队列有什么区别? · Kafka的消息模型

Kafka把相似的逻辑切分称为Partition。课程强调其业务模型与RocketMQ队列/消费组模型相近,不能把这一对应扩大成内部存储、重试和所有API行为完全相同。

03-消息模型:主题和队列有什么区别? · 小结

业务模型帮助应用理解订阅和进度,内部实现则决定存储、索引、复制和调度。即使都使用主题与分区,Kafka和RocketMQ的源码仍可能差异很大,后面的实现篇正是用来拆开这两层。

业务模型不等于存储实现保留这一小节的独立机制与边界。

原书依据 · 1 处

03-消息模型:主题和队列有什么区别? · 思考题

问题设想在不要求严格顺序时并行消费一个队列,提醒有序与吞吐之间的取舍。此处只问不答,具体空洞和重试队列机制在第08讲保留。

04-如何利用事务消息实现分布式事务?

订单数据库插入与发布清理购物车消息是两个可分别失败的动作,任一先成功都可能留下失配。消费者完成清理后再确认能让失败重试,但生产端双写仍需专门协调。

订单与消息双写会失配保留这一小节的独立机制与边界。

原书依据 · 1 处

04-如何利用事务消息实现分布式事务? · 什么是分布式事务?

跨服务事务方案要说明协调哪些资源、允许多长不一致及可承受什么成本。事务消息适合下游可以稍后更新的场景。本节对ACID采用通俗甚至混淆的描述,不能把读可见性当作一致性的完整定义,也不能笼统断言分布式严格事务不可能;笔记保留的是方案边界。

分布式事务需要说明边界保留这一小节的独立机制与边界。

原书依据 · 1 处

04-如何利用事务消息实现分布式事务? · 消息队列是如何实现分布式事务的?

半消息先保存完整内容但不让消费者看到,等本地事务结果确定后再提交或回滚。提交请求或响应也可能丢失,因此“发半消息—本地提交—消息提交”不是无故障窗口的单次原子操作。

半消息把可见性延后保留这一小节的独立机制与边界。

原书依据 · 1 处

04-如何利用事务消息实现分布式事务? · RocketMQ中的分布式事务实现

RocketMQ回查让Broker在提交结果不确定时再次询问本地事务状态,查询可靠业务存储可避免依赖原进程存活。若本地事务仍执行中,只能按暂未知处理,不能因暂时查不到订单就草率回滚;状态判定必须与业务提交边界对应,Unknown和下游责任已与固定官方材料核对。

事务回查依赖可靠业务状态保留这一小节的独立机制与边界。

原书依据 · 1 处

04-如何利用事务消息实现分布式事务? · 小结

课程总结强调事务消息并非解决所有一致性的万能方案,RocketMQ与Kafka的事务定义、范围不同。对订单事件而言回查有用,不意味着两产品可以无条件按功能名字互换。

04-如何利用事务消息实现分布式事务? · 思考题

练习要求实现订单与购物车场景,并检查ACID覆盖范围。它未提供完整答案,本轮不补造运行结果;实践计划将以固定版本机制和故障窗口作为观察问题。

05-如何确保消息不会丢失?

消息可靠性必须结合正确使用和配置。产品具备机制不代表应用自然不丢,接下来要把生产、存储和消费三个阶段拆开检查,而非只观察最后一个错误日志。

05-如何确保消息不会丢失? · 检测消息丢失的方法

序号连续性可作为检测线索,但应在同一个生产者与分区构成的有序序列内检查。给消息携带生产者ID和局部递增号,可避免不同实例交错造成误报;拦截器可隔离检测与业务逻辑。

按生产者分区检查序号保留这一小节的独立机制与边界。

原书依据 · 1 处

05-如何确保消息不会丢失? · 确保消息可靠传递

生产端观察发送确认,Broker端按耐久与副本条件确认,消费端完成业务后再确认。同步代码需处理异常,异步代码需观察回调。处理成功但确认失败可能重投,所以可靠性与去重不是互斥目标。

发送成功必须检查确认保留这一小节的独立机制与边界。

存储确认受刷盘复制约束保留这一小节的独立机制与边界。

消费业务完成后再确认保留这一小节的独立机制与边界。

原书依据 · 3 处

05-如何确保消息不会丢失? · 小结

三阶段检查把丢失问题定位到生产失败、存储耐久或消费确认时机。只有代码与配置共同满足相应故障模型,才有可解释的可靠性保证,不是勾选一个配置就覆盖所有故障。

05-如何确保消息不会丢失? · 思考题

确认响应也可能在网络中丢失,发送方会重试,于是原消息虽已成功仍再次到达。这是下一讲幂等问题的明确起点;这里保留重试导致重复的机制,去重方法在后文展开。

06-如何处理消费过程中的重复消息?

重复消费会使订单统计等非幂等业务多执行一次。不能因为重试是为了防丢失,就忽略其副作用;应用需要知道保证的范围及消息是否可能再次到达。

06-如何处理消费过程中的重复消息? · 消息重复的情况必然存在

至多一次、至少一次与恰好一次描述不同投递或处理边界。课程提醒Kafka事务和流处理语义有条件,不能把“Exactly Once”推广到任意外部副作用。对产品的营销评价不作为机制结论。

投递语义先确认作用范围保留这一小节的独立机制与边界。

原书依据 · 1 处

06-如何处理消费过程中的重复消息? · 用幂等性解决重复消息问题

幂等要求相同业务操作重复执行仍产生同样效果。流水唯一约束保护登记、版本前置条件拒绝重复或过期更新、消息ID记录执行情况各有适用边界。尤其先查未处理、再加款、最后标记若未原子保护,两个消费者会同时通过并重复加款。多步余额更新仍需可靠推进。

幂等关注重复后的效果保留这一小节的独立机制与边界。

重复加款使余额多增保留这一小节的独立机制与边界。

唯一流水限定一次变更保留这一小节的独立机制与边界。

前置条件构成一次性更新保留这一小节的独立机制与边界。

分离检查导致双重加款保留这一小节的独立机制与边界。

检查变更登记需要原子性保留这一小节的独立机制与边界。

原书依据 · 6 处

06-如何处理消费过程中的重复消息? · 小结

幂等方法也适用于重复HTTP提交和RPC自动重试。可优先让业务天然幂等,或使用唯一登记/一次性前置条件;通用检查记录方案较复杂,必须把业务副作用与记录边界一同设计。

06-如何处理消费过程中的重复消息? · 思考题

思考题询问为何常见系统选择至少一次,没有给出进一步论证。前文已经说明可靠性与重复的关系,这里不凭空补造一个普遍性能定理或产品保证。

07-消息积压了该如何处理?

积压表示有效处理速度跟不上到达速度。先区分暂时峰值与长期能力不足,再观察生产、队列和消费各段瓶颈,避免把所有慢都归因于Broker。

07-消息积压了该如何处理? · 优化性能来避免消息积压

批量减少每条消息平均交互开销,并发重叠在途等待。消费扩容还受队列分配约束,一个消费者可负责多个队列,超过可分配队列的实例则可能闲置。回调提前返回、把消息转入不耐久内存队列并不能安全解决积压。

批量与并发摊薄发送等待保留这一小节的独立机制与边界。

消费能力必须覆盖生产速率保留这一小节的独立机制与边界。

内存转交不等于可靠消费保留这一小节的独立机制与边界。

原书依据 · 3 处

07-消息积压了该如何处理? · 消息积压了该如何处理?

积压突增先看发送是否增加、有效消费是否减少。可用扩容或降低非关键流量控制影响;消费变慢则看错误和线程堆栈。反复失败重投也可能让表面收发量正常、有效处理量却下降。

积压排查先分速率变化保留这一小节的独立机制与边界。

原书依据 · 1 处

07-消息积压了该如何处理? · 小结

解决积压应先恢复服务能力,再研究长期优化。扩容不是单纯加进程,要结合分区、业务资源和处理错误;批量与并发也须权衡延迟和可靠确认。

07-消息积压了该如何处理? · 思考题

本题要求评估批量消费的适用性,未提供实现方案。它延续吞吐与业务处理粒度的权衡,不能由题目存在就宣称批量总会提升性能。

08-答疑解惑(一)-网关如何接收服务端的秒杀结果?

答疑页收集基础篇的实际困惑,接下来分别解释网关结果关联、消费组映射、并行空洞和局部顺序。开头的互动与讲师外貌插曲无新增技术结论。

08-答疑解惑(一)-网关如何接收服务端的秒杀结果? · 1. 网关如何接收服务端的秒杀结果?

网关为任务带请求ID和网关ID,后端通过RPC把结果送回正确实例,网关再以请求ID唤醒对应等待者。示例需要超时和资源清理,但等待/通知代码是教学方案,仍有竞态与超时语义边界,不能直接当作完整秒杀系统。

异步请求靠ID关联返回保留这一小节的独立机制与边界。

原书依据 · 1 处

08-答疑解惑(一)-网关如何接收服务端的秒杀结果? · 2. 详解RocketMQ和Kafka的消息模型

五个队列可以分给两个消费者,一个消费者离线后重新分配。组和队列决定进度,而不是某消费者进程拥有进度;不同组独立读取相同数据。这个例子也澄清“实例数必须等于分区数”的过度简化。

消费进度归组和队列保留这一小节的独立机制与边界。

原书依据 · 1 处

08-答疑解惑(一)-网关如何接收服务端的秒杀结果? · 3. 如何实现单个队列的并行消费?

允许单队列并行后,未完成的较早消息成为空洞。课程的JMQ设计把它转入特殊重试队列,再推进主位置,后续优先重试。转移必须可靠,严格顺序也已放宽,所以它不是没有额外成本的通用扩容方法。

并行消费用重试队列接空洞保留这一小节的独立机制与边界。

原书依据 · 1 处

08-答疑解惑(一)-网关如何接收服务端的秒杀结果? · 4. 如何保证消息的严格顺序?

多数业务只要求同一个实体内有序,例如同账户流水,不必给所有账户排全局顺序。稳定按业务键路由可保持局部顺序范围;扩容迁移及并发发送/处理仍需配合,不能只凭一个哈希函数宣称端到端严格有序。

按业务键保持局部顺序保留这一小节的独立机制与边界。

原书依据 · 1 处

08-答疑解惑(一)-网关如何接收服务端的秒杀结果? · 写在最后

基础篇关注宏观模型和可靠性,具体API与配置在选定产品后查文档;实现篇则要深入到技术细节。学习粒度随目标变化,不是一直忽略配置,也不是一直从零散参数开始。

09-学习开源代码该如何入手?

源码阅读的难点是规模和网状关系。目标不是背完全部文件,而是能用实现知识解释使用方式与故障,因此需要先建立地图,再选一个可回答的小问题。

09-学习开源代码该如何入手? · 通过文档来了解开源项目

官方文档可按Quick Start、基本概念、场景与生态、设计/理论材料的顺序阅读。课程推荐The Log作为理解Kafka日志思想的背景文章,此处只介绍阅读价值,不代替实际阅读全文。

先用文档建立源码地图保留这一小节的独立机制与边界。

原书依据 · 1 处

09-学习开源代码该如何入手? · 用以点带面的方式来阅读源码

源码从具体问题切入。先在设计文档或KIP等提案中找到预期机制,再沿实际代码和测试追一两条主链。提案说明动机、影响和方案,不代表该版本一定按相同方式实现。

带着问题沿源码主链阅读保留这一小节的独立机制与边界。

改进提案解释设计取舍保留这一小节的独立机制与边界。

原书依据 · 2 处

09-学习开源代码该如何入手? · 小结

阅读以小问题积累覆盖面,比泛读全部源码更容易验证理解。理论与设计材料是地图,真实实现是证据,二者之间的差异也是需要记录的结果。

09-学习开源代码该如何入手? · 思考题

练习不仅要求看代码,还要求用流程/时序图记录主链,用文字解释算法和原理。这是把阅读转成可检查产物的方法,没有执行就不能写成已经掌握某项目。

10-如何使用异步设计提升系统性能?

异步把“完成后做什么”登记下来,让调用线程不用一直等资源。课程将用转账说明线程模型变化,先提醒异步设计解决的是等待资源,并非自动把业务步骤改成并行。

10-如何使用异步设计提升系统性能? · 异步设计如何提升系统性能?

两次有依赖的账户调用仍先扣再加,异步只把等待与回调组织起来,单次依赖链时延未必下降。同步线程池饱和时排队会延长响应,异步能在其他资源未饱和前提高在途处理能力。例子刻意省略失败和事务,不应据此运行真实转账。

异步重叠等待而非加快计算保留这一小节的独立机制与边界。

原书依据 · 1 处

10-如何使用异步设计提升系统性能? · 简单实用的异步框架: CompletableFuture

CompletableFuture把未完成结果变成对象。thenCompose连接下一个异步步骤,thenRun登记完成动作,get提供阻塞等待方式;账户服务与转账服务接口说明了代码怎样组合这种结果。失败传播和执行线程要另外核对。

Future表达尚未完成的结果保留这一小节的独立机制与边界。

原书依据 · 1 处

10-如何使用异步设计提升系统性能? · 小结

异步的收益来自减少等待,代价是状态、控制流与错误处理更复杂。当业务复杂而同步方案已足够时,保留可维护性可能更重要;框架简化表达,不会消除所有复杂度。

异步收益要抵过复杂度保留这一小节的独立机制与边界。

原书依据 · 1 处

10-如何使用异步设计提升系统性能? · 思考题

本题明确指出转账示例未处理失败,要求思考错误报告和账务恢复,并询问回调线程。这些尚未被解答,不能从示例中补造事务安全方案;实践只作模拟计划。

11-如何实现高性能的异步网络传输?

IO密集型程序主要等待外部读写,计算密集型主要消耗CPU。异步适合重叠等待,不能解决一切CPU瓶颈;网络、磁盘和服务端的实际资源限制应分别观察。

区分IO与计算瓶颈保留这一小节的独立机制与边界。

原书依据 · 1 处

11-如何实现高性能的异步网络传输? · 理想的异步网络框架应该是什么样的?

每连接一个阻塞线程在海量连接下会带来线程和调度负担。理想框架让少量线程管理许多连接,收到数据时调用事先登记的处理逻辑。发送缓冲区也会饱和,不能把一次快速内存写入推广为网络发送永远不阻塞。

多连接不应每条独占线程保留这一小节的独立机制与边界。

原书依据 · 1 处

11-如何实现高性能的异步网络传输? · 使用Netty来实现异步网络通信

Netty用ServerBootstrap配置线程组、端口与子连接初始化,再把MyHandler安装到Pipeline。框架管理连接与缓冲,事件线程调用业务处理器;业务仍需避免在IO线程里做长期阻塞操作。

Netty隔离网络通用管理保留这一小节的独立机制与边界。

原书依据 · 1 处

11-如何实现高性能的异步网络传输? · 使用NIO来实现异步网络通信

NIO Selector注册多个Channel的事件兴趣,让一个线程等待就绪集合并逐个处理。Java API的select返回就绪键数量,selectedKeys提供键集合;课程把返回值说成迭代器是简化错误,笔记按官方API纠正。

Selector连接复用保留这一小节的独立机制与边界。

原书依据 · 1 处

11-如何实现高性能的异步网络传输? · 小结

Netty封装较多线程、连接和缓冲管理,NIO暴露更底层的就绪选择。区别在控制范围和需要自行承担的通用工作,不能仅按代码行数决定框架优劣。

11-如何实现高性能的异步网络传输? · 思考题

问题要求追踪Netty接收链怎样利用NIO,只是后续源码阅读方向,当前没有展开内部实现。它可作为实现深读的子问题,不在本节臆造调用链。

12-序列化与反序列化:如何通过网络传输结构化的数据?

字节流不能直接表达应用结构。序列化约定类或结构体如何变成字节,反序列化再还原;同样的表示也可写入文件,让内存之外的存储承载数据。

序列化连接结构与字节保留这一小节的独立机制与边界。

原书依据 · 1 处

12-序列化与反序列化:如何通过网络传输结构化的数据? · 你该选择哪种序列化实现?

序列化的可读性、复杂度、速度和信息密度互相约束。JSON便于调试,通用二进制减少人工编码,专用布局更紧凑却维护更重。Kryo例子展示注册类型、创建输出流并写出对象的基本用法,未覆盖格式兼容。

序列化选型比较四个维度保留这一小节的独立机制与边界。

Kryo用类型注册写出对象保留这一小节的独立机制与边界。

原书依据 · 2 处

12-序列化与反序列化:如何通过网络传输结构化的数据? · 实现高性能的序列化和反序列化

专用布局事先约定类型编号和字段顺序,变长字段带长度,短字段按需要编码,从而减少字段名等冗余。User的12字节例子只在该约定和值范围内成立,不能把节省比例推广到所有数据。

固定字段布局减少冗余保留这一小节的独立机制与边界。

原书依据 · 1 处

12-序列化与反序列化:如何通过网络传输结构化的数据? · 小结

格式选择应先满足业务可读和维护需要,再用性能测量决定是否承担专用布局成本。序列化优化不只是“压缩更小”,也涉及实现与版本约定。

12-序列化与反序列化:如何通过网络传输结构化的数据? · 思考题

题目询问为什么不能直接发送对象的内存字节,没有提供完整解释。这里只保留问题,前文已有结构与字节转换的作用,不凭题目补造对象内存布局事实。

13-传输协议:应用程序之间对话的语言

协议是收发双方对字节意义的无歧义约定。序列化定义数据表示,协议进一步规定消息边界和交互规则,二者配合才形成可互操作的通信。

应用协议是无歧义约定保留这一小节的独立机制与边界。

原书依据 · 1 处

13-传输协议:应用程序之间对话的语言 · 如何“断句”?

TCP读取边界可能与发送调用不同,需要显式断句。分隔符要转义数据中的同名字符;前置长度则先读头、再收齐内容,双方必须约定长度字段的单位、范围和是否包括头部。

字节流需要显式消息边界保留这一小节的独立机制与边界。

原书依据 · 1 处

13-传输协议:应用程序之间对话的语言 · 用双工收发协议提升吞吐量

允许请求与响应在连接中交错,可提升在途并发,但自然顺序不再足以关联。请求带会话内唯一ID,响应回传同一ID,就能正确匹配;课程对HTTP1单工的说法仅是对一问一答模式的简化。

请求ID解除响应顺序依赖保留这一小节的独立机制与边界。

原书依据 · 1 处

13-传输协议:应用程序之间对话的语言 · 小结

网络交互的基础组合是可识别边界的帧、可还原的数据表示和可匹配的请求/响应。消息队列和RPC常使用这一组合;它不是某个专有产品独有的诀窍。

13-传输协议:应用程序之间对话的语言 · 思考题

练习要求把两个人的对话实现为高并发网络程序并测时,后续加餐给出参考代码。此处只有任务,不虚构运行结果,也不把作者的某次测时当成本次验证。

14-内存管理:如何避免内存溢出和频繁的垃圾回收?

高并发请求与大范围汇总都可能暴露平时看不到的内存问题。自动管理减少手动释放负担,却不保证不会因残留引用或过量存活数据造成压力,接下来需要理解分配与回收。

14-内存管理:如何避免内存溢出和频繁的垃圾回收? · 自动内存管理机制的实现原理

回收器按可达性识别对象,碎片则使空闲总量与连续分配能力不同。课程用标记清除和小字节例子建立直觉,但GC根、压缩和暂停依具体运行时而异,不能当成所有回收器的统一流程。

GC以可达性识别待回收对象保留这一小节的独立机制与边界。

空闲总量不等于连续空间保留这一小节的独立机制与边界。

原书依据 · 2 处

14-内存管理:如何避免内存溢出和频繁的垃圾回收? · 为什么在高并发下程序会卡死?

请求洪峰带来大量短命对象,内存不足和回收暂停又使请求排队,随后更多对象同时出现。这种反馈可能放大延迟,应观察分配率、存活和GC日志,而不只盯CPU。

对象洪峰放大GC和排队保留这一小节的独立机制与边界。

原书依据 · 1 处

14-内存管理:如何避免内存溢出和频繁的垃圾回收? · 高并发下的内存管理技巧

先减少重复中间对象和大对象分配,再评估池化复用。对象池、自管内存与更大容量各有代价,不能把课程的Flink历史评价当作当前通用结论;具体实现和负载应重新验证。

减少大对象分配压力保留这一小节的独立机制与边界。

原书依据 · 1 处

14-内存管理:如何避免内存溢出和频繁的垃圾回收? · 小结

减少一次性大对象能减轻回收压力,但目标不是完全消灭GC。选择优化前应知道对象在哪里创建、是否真正可回收,以及复用是否增加并发和生命周期风险。

14-内存管理:如何避免内存溢出和频繁的垃圾回收? · 思考题

本题将10KB文本处理作为内存优化练习,仅提出场景,没有给出实现或数据。本轮不因题目就补造零拷贝解析、池化收益或实测结果。

加餐-JMQ的Broker是如何异步处理消息的?

加餐把网络、异步、协议和内存这些知识重新放回消息队列设计。作者的性能自述属于历史经验,重点是既有基础技术怎样组合,而不是宣称某产品当前绝对优胜。

加餐-JMQ的Broker是如何异步处理消息的? · JMQ的Broker是如何异步处理消息的?

JMQ把接收、单线程顺序处理、刷盘、复制与回复分开。IO线程快速入队,写线程生成带Offset的连续字节流,刷盘和复制更新各自完成位置,响应线程按QOS检查待回复链表。快路径少做慢IO与锁等待,确认仍要等耐久条件。

JMQ把慢IO移出写主链保留这一小节的独立机制与边界。

用位置协调持久化确认保留这一小节的独立机制与边界。

原书依据 · 2 处

加餐-JMQ的Broker是如何异步处理消息的? · 俩大爷的思考题

Go参考程序用长度、序号与内容组成帧,以ReadFull收齐数据,两端各有收发协程,写锁保护同一连接的多段写入。它展示双工与边界处理,仍省略充分错误检查和防御性长度验证;作者测时只作历史示例,未在本轮运行。

双向收发与完整帧写入保留这一小节的独立机制与边界。

原书依据 · 1 处

加餐-JMQ的Broker是如何异步处理消息的? · 思考题

练习要求先理解参考实现,再提出修改并运行验证性能。优化设想与实际收益必须分开,不能只在脑中推演就填写“更快”。

15-Kafka如何实现高性能IO?

Kafka性能章节把此前的异步与协议知识连接到存储路径。开头吞吐数字是作者特定机器的历史测量,后续更值得保留的是批量、顺序IO、缓存和数据搬运的机制。

15-Kafka如何实现高性能IO? · 使用批量消息提升服务端处理能力

客户端把逐条API调用聚成批,Broker以批组织传输与存储,消费端再交给业务;固定Kafka4.1官方文档也说明Broker可解压校验后再压缩,不能理解成服务端绝不解批。这样把聚合与拆解分担到两端,减少服务端请求次数;等待攒批和吞吐之间仍需要权衡。

批消息把开销移到两端保留这一小节的独立机制与边界。

原书依据 · 1 处

15-Kafka如何实现高性能IO? · 使用顺序读写提升磁盘IO性能

每分区日志顺序追加,读者从Offset继续顺序读。顺序访问减少随机定位及碎片式IO工作,实际收益受硬件与缓存影响,不能套用一个固定倍数。

追加日志利用顺序IO保留这一小节的独立机制与边界。

原书依据 · 1 处

15-Kafka如何实现高性能IO? · 利用PageCache加速消息读写

页缓存保存文件热数据,近期写入的消息可在消费时再次命中,从而降低真实磁盘读取压力。消费滞后很久或缓存不足时效果会变化,普通缓冲IO的说明也不能推广到全部系统调用路径。

近期消息可复用页缓存保留这一小节的独立机制与边界。

原书依据 · 1 处

15-Kafka如何实现高性能IO? · ZeroCopy:零拷贝技术

文件数据若无需在应用中修改,sendfile类机制可减少用户态中转复制。零拷贝不是完全没有数据移动,而是在特定路径减少复制和CPU工作;协议变换、加密等条件可能改变适用路径。

零拷贝避免用户态中转保留这一小节的独立机制与边界。

原书依据 · 1 处

15-Kafka如何实现高性能IO? · 小结

高性能由多种互相配合的机制组成:批减少请求次数,顺序布局改善IO,页缓存复用近期数据,零拷贝减少搬运。每项都需要适用条件,不能简单把名词列表当成性能保证。

15-Kafka如何实现高性能IO? · 思考题

思考题建议从这些机制中选一两个追源码。后续实践将固定项目版本和入口,先画映射再读相关链路,当前不冒充已经完整核验Kafka实现。

16-缓存策略:如何使用缓存来减少磁盘IO?

缓存把低速层的副本放进高速层。设计问题随之变成是否命中、何时刷新、是否可接受旧值及容量如何淘汰;单个注解只提供接入方式,不替代这些决策。

缓存是高速层中的副本保留这一小节的独立机制与边界。

原书依据 · 1 处

16-缓存策略:如何使用缓存来减少磁盘IO? · 选择只读缓存还是读写缓存?

读写缓存先接收写入,再异步落到低速存储,使速度与耐久时点分离。只读缓存让业务写绕过它,再另行刷新或失效。对故障的保证要区分进程退出、整机断电与多副本,不能把内存返回当作已耐久。

写缓存速度与耐久性分离保留这一小节的独立机制与边界。

原书依据 · 1 处

16-缓存策略:如何使用缓存来减少磁盘IO? · 保持缓存数据新鲜

同步双写可能部分失败,异步双写又可能乱序把新值覆盖。周期全量/增量刷新和到期重载降低维护复杂度,却接受陈旧窗口;对余额等敏感场景必须先定义一致性契约,不能直接接受缓存最终会追上。

异步刷新可能把新值覆盖保留这一小节的独立机制与边界。

按可接受陈旧度更新缓存保留这一小节的独立机制与边界。

原书依据 · 2 处

16-缓存策略:如何使用缓存来减少磁盘IO? · 缓存置换策略

LRU利用近期访问可能再次发生的经验,把最久未访问条目淘汰。业务信息也可改进策略:消息流常读尾部,因此JMQ把页面位置纳入权重,防止一次历史扫描挤掉热数据。这里用“未命中”,不沿用原文把普通未命中都叫“缓存穿透”的混淆术语。

LRU依据最近访问淘汰保留这一小节的独立机制与边界。

历史扫描会污染热缓存保留这一小节的独立机制与边界。

原书依据 · 2 处

16-缓存策略:如何使用缓存来减少磁盘IO? · 小结

缓存策略同时受新鲜度和空间约束。更新时机与淘汰规则解决不同问题:前者决定副本是否及时,后者决定有限内存留给谁,不能用提高命中率替代一致性设计。

16-缓存策略:如何使用缓存来减少磁盘IO? · 思考题

练习给出Storage读取接口和持有低速存储的LruCache抽象类,要求读者补LRU实现。该骨架表达依赖抽象与包装低速读取的关系,尚没有给出完整置换算法或并发保证。

用存储接口包装LRU缓存保留这一小节的独立机制与边界。

原书依据 · 1 处

17-如何正确使用锁保护共享数据,协调异步线程? / 共享资源与锁

共享数据的并发更新会使线程相互覆盖结果,锁把资源访问限制为同一时刻一个持有者。微信群报名例子呈现了“先读旧值再写新值”为什么会丢掉另一人的更新。

锁保护共享更新

多个线程根据同一旧值各自计算再覆盖写入,会丢失部分更新。互斥锁限定任何时刻只有一个持有者进入被保护区域,将相关读取、计算和写回放进同一临界区,才能避免这种交错。保护的对象是会被并发访问破坏的共享资源。

锁保护共享更新保留这一想法的依据。

原书依据 · 1 处

17-如何正确使用锁保护共享数据,协调异步线程? / 避免滥用锁

加锁带来CPU开销、阻塞等待、死锁与调试成本。需要先确认共享资源确实不支持并发访问,而不是给所有共享数据保险式加锁。

先证明加锁必要性

锁会增加获取释放的CPU开销,争用时还会阻塞线程,并使死锁和并发故障更难调试。只有共享资源不支持并发访问,或并发访问会产生错误,才有必要加锁。看见共享对象就加锁,会用确定的复杂度换取未经证明的安全收益。

先证明加锁必要性保留这一想法的依据。

原书依据 · 1 处

17-如何正确使用锁保护共享数据,协调异步线程? / 锁的用法

访问共享资源前获取锁,结束后释放;异常会跳过普通后续语句,因此释放必须置于finally或语言提供的作用域管理机制中。

异常路径也要释放锁

获取锁后若业务逻辑抛异常,顺序写在后面的解锁语句可能不会执行,后续线程就会一直等待。应把解锁放进finally,或使用Python的with等作用域机制,覆盖正常与异常出口。加锁和解锁尽量放在同一方法中,便于核对一一对应。

异常路径也要释放锁保留这一想法的依据。

原书依据 · 1 处

17-如何正确使用锁保护共享数据,协调异步线程? / 如何避免死锁?

死锁来源包括未释放、不可重入锁的再次获取,以及多线程以相反顺序持有多把锁。两线程分别持A等B、持B等A形成循环等待;少用锁、减少嵌套并统一获取顺序能降低风险。

可重入锁支持嵌套调用

可重入锁允许同一线程已持锁时再次获取它,适合调用链很深、内层无法判断外层是否已经加锁的情况。不可重入锁在这种情形下可能使线程等待自己。重入不取消释放义务,每次成功获取仍须有对应释放。

可重入锁支持嵌套调用保留这一想法的依据。

原书依据 · 1 处

统一锁顺序防死锁

线程1持有A等B,线程2持有B等A,两者都无法继续。给多把锁规定统一顺序,并让所有调用点按该顺序获取,可避免这个例子的循环等待;释放按获取的逆序进行。优先减少锁数量与同时持锁,规则越简单越容易验证。

统一锁顺序防死锁保留这一想法的依据。

原书依据 · 1 处

17-如何正确使用锁保护共享数据,协调异步线程? / 使用读写锁要兼顾性能和安全性

读取也需要避免与更新交错,否则可能读到一半状态。读写锁让多个只读访问并行,同时使写访问与其他读写互斥,适合读多写少的共享数据。

读写锁区分访问类型

共享数据的读访问也可能撞上写入并看到不完整状态。读写锁允许多个读锁同时持有,但持有写锁时其他线程不能获取读锁或写锁。它在读多写少时保留并行读取能力,同时保护更新;所有访问仍要遵循同一保护规则。

读写锁区分访问类型保留这一想法的依据。

原书依据 · 1 处

17-如何正确使用锁保护共享数据,协调异步线程? / 小结

本节回顾锁的资源保护、释放义务、死锁风险和读写锁,未引入独立机制。

17-如何正确使用锁保护共享数据,协调异步线程? / 思考题

练习要求读者在Java中实现类似try-with-lock的封装,正文没有给出实现答案。

18-如何用硬件同步原语(CAS)替代锁? / 引入CAS

Confluo用硬件同步原语支持单日志上的并发有序写入,是本讲CAS取代锁的动机。其吞吐对比来自特定实验,文中明确质疑了对Kafka比较的公平性。

Confluo并发日志思路

Confluo是面向高速网络监控诊断的流数据存储设计,本节用它说明硬件同步原语可支持单日志的多线程有序写入。其“Kafka的4~10倍”是论文实验宣称,文中对比较条件提出异议,不能直接当作生产选型结论。

Confluo并发日志思路保留这一想法的依据。

原书依据 · 1 处

18-如何用硬件同步原语(CAS)替代锁? / 什么是硬件同步原语?

CAS比较变量是否仍等于预期旧值,匹配才替换并返回成功;FAA原子地读取并加上增量。原子性来自CPU实现,普通语言顺序语句无法仅凭同样伪代码取得相同保证。

CAS比较后交换

CAS接收变量地址、预期旧值和新值。只有当前值等于预期值时才写入新值并返回成功,否则保持原值并返回失败。比较与替换由硬件保证不可分割,所以它能检测读取后是否发生竞争,成为无锁更新的基础。

CAS比较后交换保留这一想法的依据。

原书依据 · 1 处

FAA原子累加

FAA将“读取当前值、增加指定增量、返回原值”合为一个硬件原子操作,避免普通读改写在并发时丢更新。它适合计数和简单加减;与CAS相比,计算形式受限,但不必在业务代码中维护比较失败后的重试循环。

FAA原子累加保留这一想法的依据。

原书依据 · 1 处

18-如何用硬件同步原语(CAS)替代锁? / CAS版本的账户服务

账户余额例子分别用互斥锁、CAS重试与FAA累加实现并发入账。CAS失败意味着本次没有修改余额,需要重新读取并计算;高冲突时忙重试会消耗CPU,Yield可缓解但不能消除边界。

过期余额覆盖并发入账

多个并发转入都先读同一余额,各自计算后若无条件写回,后写者可能覆盖另一线程已完成的增加。原文CAS例子明确区分“读取后其他线程已经改变余额”的情况,此时旧计算结果不能再安全赋值。对应方案见CAS重试保护入账及余额累加优先FAA。

过期余额覆盖并发入账保留这一想法的依据。

原书依据 · 1 处

CAS重试保护入账

对共享余额先原子读取old,再计算new,最后仅在余额仍为old时CAS写回。若别的线程已经更新,当前尝试不修改余额,而是重新读取计算,直到成功。这样避免以过期余额覆盖并发入账。方案适用于单个受原子操作保护的更新,不等于完整数据库转账事务。 风险背景见过期余额覆盖并发入账。

CAS重试保护入账保留这一想法的依据。

原书依据 · 1 处

余额累加优先FAA

当业务只是给一个共享余额加上固定金额时,原子加法可直接完成不可分割的更新,不需要手写CAS循环。若计算比简单加减更复杂,CAS的“读—计算—条件写回”更通用。这里演示的是内存账户余额模型,不能据此推断跨账户持久事务已经解决。 风险背景见过期余额覆盖并发入账。

余额累加优先FAA保留这一想法的依据。

原书依据 · 1 处

CAS忙重试的边界

CAS失败后立即循环会持续占用CPU。线程冲突频繁时,大量失败重试可能抵消无锁的收益。Yield主动让出CPU可减轻忙等,Sleep也可退让但增加延迟。这种重试方案更适合大多数更新一次成功、竞争较少的场景。

CAS忙重试的边界保留这一想法的依据。

原书依据 · 1 处

18-如何用硬件同步原语(CAS)替代锁? / 小结

回顾CAS与FAA由CPU保证原子性,CAS重试适用于竞争不频繁的先读、计算、再更新场景。

18-如何用硬件同步原语(CAS)替代锁? / 思考题

练习要求用锁、CAS和FAA实现可运行的10000次入账,反复核验余额10000。它强调并发错误的不稳定复现,不把重复运行无错当成一般正确性证明。

19-数据压缩:时间换空间的游戏 / 压缩与吞吐

压缩可减少同样逻辑消息量占用的网络流量和存储空间。书中高重复种子压测显著提高Kafka吞吐,但明确说明生产数据通常达不到同样压缩率。

压缩吞吐取决于样本

压缩后传输的物理字节减少,所以按未压缩消息量计算的吞吐可能高于网卡直接承载的未压缩带宽。压测使用固定种子消息,重复率和压缩率影响极大;示例的几十倍提升不能直接外推到生产,应使用实际业务样本评估。

压缩吞吐取决于样本保留这一想法的依据。

原书依据 · 1 处

19-数据压缩:时间换空间的游戏 / 什么情况适合使用数据压缩?

压缩本质是CPU换带宽或存储,性能判断要比较压缩、传输、解压总耗时与直接传输,并考虑读写比及当前资源瓶颈。

压缩先看资源瓶颈

直接传输只付传输耗时,压缩路径还要付压缩和解压耗时。CPU已紧张时压缩可能更慢;磁盘IO或网络是瓶颈且CPU空闲时,置换更可能划算。对读多写少的数据还需计算每次读取的解压成本,不能只比较压缩文件大小。

压缩先看资源瓶颈保留这一想法的依据。

原书依据 · 1 处

19-数据压缩:时间换空间的游戏 / 应该选择什么压缩算法?

无损压缩要求还原后数据完全相同。算法选择需要同时考察压缩率与耗时,且同一种算法在不同业务内容上的表现可能不同。

按样本选择压缩算法

业务数据通常需要无损压缩,即解压后与原数据完全一致。选择算法不能只看压缩比,还要看压缩解压速度和CPU预算:本节以LZ4说明速度取向,以GZIP/XZ说明压缩比取向。应以业务样例实测,不把算法名称当作通用优劣排序。

按样本选择压缩算法保留这一想法的依据。

原书依据 · 1 处

19-数据压缩:时间换空间的游戏 / 如何选择合适的压缩分段?

无限数据流需要切成有界帧压缩。大帧更容易复用编码、压缩率较好,但读取局部数据也可能解压整帧,分段需要在压缩收益和解压浪费间权衡。

压缩分段决定读放大

压缩单元需要有确定边界,流数据因而分帧处理。较大分段通常含更多重复内容,可提高压缩率,但增长到一定程度后收益减弱。即使只读几个字节,也可能必须解压整段;选择帧大小要同时考虑压缩率、压缩速度和局部读取的解压浪费。

压缩分段决定读放大保留这一想法的依据。

原书依据 · 1 处

19-数据压缩:时间换空间的游戏 / Kafka是如何处理消息压缩的?

Kafka以一批消息为压缩单元,生产者压缩后整批发送,Broker整批存储和转发,消费者最后解压,从而把计算成本留在客户端。

Kafka整批压缩

以本书分析版本的批消息主路径为范围,Kafka以批消息为压缩分段,生产者压缩,Broker保存和转发完整压缩批,消费者解压。服务端不拆批解压,既省CPU,又减少网络字节和磁盘占用。是否开启、算法和批大小仍需根据客户端CPU与业务数据选择。这是本书对批处理主路径的解释,不能推成所有版本、格式转换或校验路径都绝不解压。

Kafka整批压缩保留这一想法的依据。

原书依据 · 1 处

19-数据压缩:时间换空间的游戏 / 小结

回顾压缩的资源置换、算法与分段权衡以及Kafka客户端压缩解压路径。

19-数据压缩:时间换空间的游戏 / 思考题

练习要求自行查阅RocketMQ压缩实现并与Kafka比较;本页没有给出比较结论。

20-RocketMQProducer源码分析:消息生产的实现过程 / 正文片段133

本讲以RocketMQ release-4.5.1为明确分析版本,聚焦有状态Producer的初始化和发送流程;阅读目标是客户端故障定位与可迁移设计思想。

20-RocketMQProducer源码分析:消息生产的实现过程 / 从单元测试看Producer API的使用

从单元测试先了解Producer API的使用与边界,再沿调用链分析。MQProducer和DefaultMQProducer承担门面,DefaultMQProducerImpl集中发送业务实现。

从测试进入源码

先找到目标流程的测试用例,可同时看清API应怎样使用、初始化要求及成功失败场景,再沿调用链定位实现。RocketMQ生产者测试按同步、异步、压缩等场景命名,比从程序入口无目的展开更容易建立局部模型。

从测试进入源码保留这一想法的依据。

原书依据 · 1 处

生产者门面隐藏实现

MQProducer为调用方提供发送接口,DefaultMQProducer实现它并将调用转交内部实现,DefaultMQProducerImpl承担大部分发送业务。门面使用户无需理解复杂内部类,也让实现分散时仍可保留统一入口。以下关系对应本书分析的release-4.5.1。

生产者门面隐藏实现保留这一想法的依据和关系图。

原书依据 · 1 处

20-RocketMQProducer源码分析:消息生产的实现过程 / 启动过程

Producer先从CREATE_JUST进入启动流程,注册到共享MQClientInstance、启动通信与后台服务,再进入RUNNING并发心跳。状态必须包含中间与失败路径;客户端业务、RPC封装和底层网络分工明确。

服务状态覆盖失败路径

有状态服务不能只设计“运行”和“关闭”,还需表示尚未启动与启动失败,并限定合法转换。Producer只允许从CREATE_JUST启动,先置START_FAILED,再在初始化成功后置RUNNING,使异常不会冒充正常启动,也防止重复启动。

服务状态覆盖失败路径保留这一想法的依据。

原书依据 · 1 处

单例集中共享客户端

单例提供唯一实例及全局获取入口。RocketMQ以MQClientManager集中获取或创建MQClientInstance,使生产者可以注册到客户端顶层对象,由后者统一管理通用状态及后台服务。单例解决实例入口,不自动证明对象内所有操作并发安全。

单例集中共享客户端保留这一想法的依据。

原书依据 · 1 处

Producer启动准备

启动时先取得MQClientInstance并注册Producer,再启动请求响应通道、定时任务、拉消息和重平衡服务、默认Producer,最后发送心跳。发消息前初始化这些共享服务,使后续流程可以依赖路由、通信和状态维护。

Producer启动准备保留这一想法的依据。

原书依据 · 1 处

客户端通信分层

DefaultMQProducerImpl承载发送业务,MQClientInstance承载生产消费共用逻辑,MQClientAPIImpl封装客户端到服务端的RPC,NettyRemotingClient实现底层网络。分层让业务调用无需处理网络细节,也为定位失败所属层提供入口。

客户端通信分层保留这一想法的依据。

原书依据 · 1 处

20-RocketMQProducer源码分析:消息生产的实现过程 / 消息发送过程

三种发送方式共享选队列、构造上下文与RPC流程;单向不等待结果,同步等待响应,异步经回调取结果。队列选择用策略接口,可按随机、哈希或同机房算法替换。

发送模式决定结果时机

单向发送发出后不处理响应;同步发送阻塞到响应或超时;异步发送将工作交给异步执行并用回调报告结果。异步方法返回只表示提交了任务,业务必须在回调判断成败。书中此处分析的是release-4.5.1中一个已弃用的线程池异步实现。

发送模式决定结果时机保留这一想法的依据。

原书依据 · 1 处

队列选择封装策略

MessageQueueSelector把选队列算法与发送主流程分开:主流程取得候选队列,调用select,随后将消息发给所选队列。随机、哈希、同机房策略可替换;按相同key保持顺序时,要让该key持续映射到同一队列。

队列选择封装策略保留这一想法的依据。

原书依据 · 1 处

统一同步异步发送流程

RocketMQ将同步、异步最终归入相同的发送内核,以参数区分通信模式,复用消息头、上下文和RPC调用等逻辑。上层异步调度改变执行与结果返回时机,底层共享实现则减少分叉维护;无需为每种模式复制完整业务链。

统一同步异步发送流程保留这一想法的依据。

原书依据 · 1 处

20-RocketMQProducer源码分析:消息生产的实现过程 / 小结

总结初始化、三种发送方式及四个核心实现类,并建议课后将主干补成详细类与方法调用图。

20-RocketMQProducer源码分析:消息生产的实现过程 / 思考题

思考题要求改进已标Deprecated的线程池异步发送;本页没有给出替代方案。

21-KafkaConsumer源码分析:消息消费的实现过程 / 正文片段139

本讲按Kafka 2.2分析:消费组内分区由消费者独占,Coordinator分配并依赖心跳感知成员变化。公开消费接口分为订阅和poll拉取,分析前先由JavaDoc示例建立使用模型。

消费组协调分区独占

同一消费组内,一个分区在任一时刻至多分配给一个Consumer,一个Consumer则可负责多个分区。Coordinator在成员或分区变化时重新分配,消费者用心跳报告存活。这使组内并行消费有清楚的分区边界;不同消费组可独立消费同一主题。

消费组协调分区独占保留这一想法的依据。

原书依据 · 1 处

21-KafkaConsumer源码分析:消息消费的实现过程 / 订阅过程如何实现?

subscribe只更新本地订阅和元数据并置需刷新标志,不立即通信。Consumer主动检测并拒绝不支持的并发使用,避免仅靠文档约束留下不可预测行为。

主动拒绝不支持操作

Kafka Consumer不支持并发调用,因此在方法入口检测并发并明确抛错,而非任由错误用法产生随机结果。对不支持的用户操作,应在边界校验并给出清楚错误;文档告诫不能替代运行时约束。

主动拒绝不支持操作保留这一想法的依据。

原书依据 · 1 处

订阅延后刷新元数据

Kafka 2.2的subscribe更新订阅状态与本地Topic集合,并把needUpdate置为true,没有当场向集群发请求。首次poll在拉消息前确保元数据新鲜,才能知道分区分配和Broker地址。“申请刷新”与“真正网络刷新”属于两个时刻。

订阅延后刷新元数据保留这一想法的依据。

原书依据 · 1 处

21-KafkaConsumer源码分析:消息消费的实现过程 / 拉取消息的过程如何实现?

poll先补齐协调与分区元数据,再优先读取缓存,否则构造Fetch请求、在网络poll中发送并处理响应,最后反序列化返回。请求和完成响应队列使调用线程可批量推进网络工作,无需每请求另建线程。

poll推进消费全过程

KafkaConsumer.poll先通过Coordinator准备分配元数据,再由Fetcher拉取。若已有未取走消息就返回缓存;否则构造所需Broker请求,在ConsumerNetworkClient.poll中真正发送并处理响应,最后反序列化成记录。这区分了构造请求、发送请求和取出结果三个阶段。

poll推进消费全过程保留这一想法的依据。

原书依据 · 1 处

网络队列批量异步

ConsumerNetworkClient把待发送请求放unsent、待完成响应放pendingCompletion,由调用线程在poll时集中推进发送和完成处理。Fetcher缓存拉取结果供后续取出。这样可减少异步专用线程并利用批量,但回调、状态和择机执行使代码更复杂。

网络队列批量异步保留这一想法的依据。

原书依据 · 1 处

21-KafkaConsumer源码分析:消息消费的实现过程 / 小结

异步队列设计省线程并发挥批处理优势,但显著增加理解和维护成本。设计时允许为简单、清晰且易维护的结构付出可接受的性能代价。

性能要计入维护成本

彻底异步与择机批量处理可提高吞吐,却把控制流分散在请求队列、响应队列和回调中。若团队难以理解和维护,这种优化会形成长期成本。应在目标性能范围内保留简单清晰的结构,而不是把最大吞吐当作唯一设计目标。

性能要计入维护成本保留这一想法的依据。

原书依据 · 1 处

21-KafkaConsumer源码分析:消息消费的实现过程 / 思考题

练习要求沿代码分析消费位置维护与提交,正文只重述消费后提交的任务,没有给出完整实现。

22-Kafka和RocketMQ的消息复制实现的差异点在哪? / 正文片段144

复制把消息放在多个节点,配合持久化提供可靠性;副本还让某节点故障后有其他节点可服务。本讲比较复制确认、主从切换与配置的权衡。

22-Kafka和RocketMQ的消息复制实现的差异点在哪? / 消息复制面临什么问题?

副本确认数量影响写入延迟、可用节点要求与已确认数据风险。主从复制通过单一写入顺序组织数据,故障恢复还要指定或选出新主,管理服务与自选举各自承担额外复杂度。

副本确认数量的取舍

更多副本确认可减少主节点故障时已确认消息丢失的风险,却增加写入等待并要求更多节点在线。只确认主副本更快、可继续写入的条件更宽,但未复制的数据可能随主节点故障丢失。必须结合故障模型与接管规则评估,不能仅用副本总数衡量可靠性。

副本确认数量的取舍保留这一想法的依据。

原书依据 · 1 处

主节点故障需协调接管

主从复制让写入以一个主节点为准,故障时必须确定后继主节点。外部管理服务可指定新主,却引入管理服务自身可用性与一致性问题;节点自行投票减少外部依赖,但算法和恢复时间更复杂。选举过程中的停服也是可用性成本。

主节点故障需协调接管保留这一想法的依据。

原书依据 · 1 处

22-Kafka和RocketMQ的消息复制实现的差异点在哪? / RocketMQ如何实现复制?

传统RocketMQ固定Broker主从,异步确认与同步双写不同;固定主从不自动接管写入,所以主磁盘仍完好时可等恢复补复制,但严格队列顺序限制跨主切换。Dledger以多数派确认和选主提高故障接管能力。

固定主从的恢复边界

本书传统RocketMQ模式按配置固定主从,主故障后生产停止,消费者可读从。异步未复制消息若仍在完好主磁盘中,可等主恢复继续复制;这不等于磁盘损坏也不丢消息。跨多组主从分摊主题提高可用性,却不能随意迁移要求严格顺序的单队列。

固定主从的恢复边界保留这一想法的依据。

原书依据 · 1 处

Dledger多数派复制

Dledger在消息复制到半数以上节点后确认,并通过投票切换主节点。三副本允许失去一个节点仍有多数派,选举需选拥有已确认数据的节点以保留顺序与可靠性。代价是等待更多副本、选举期间停服,以及多数派不足时不能服务。

Dledger多数派复制保留这一想法的依据。

原书依据 · 1 处

22-Kafka和RocketMQ的消息复制实现的差异点在哪? / Kafka是如何实现复制的?

Kafka以分区而非整个Broker为复制单元,分区有主从,Broker可承载不同角色的副本。ISR集合与确认及选举策略共同决定可靠性;允许非ISR接管会牺牲数据一致性。

分区副本与ISR

Kafka的复制单位是分区,Broker只是副本容器。ISR表示与Leader保持同步的一组副本,包含Leader;写入确认条件和允许接管的候选集合共同约束故障时的数据风险。若ISR全部不可用,宁可停服或允许其他副本接管,是可用性与已确认数据风险的取舍。此处对应本书Kafka版本。

分区副本与ISR保留这一想法的依据。

原书依据 · 1 处

22-Kafka和RocketMQ的消息复制实现的差异点在哪? / 总结

总结传统主从、Dledger和ISR配置的性能、可用性与一致性权衡,没有普遍最优方案。

22-Kafka和RocketMQ的消息复制实现的差异点在哪? / 思考题

练习要求对齐五副本RocketMQ与Kafka的性能、可用性和一致性条件,本页未提供配置答案。

23-RocketMQ客户端如何在集群中找到正确的节点? / 正文片段150

弹性集群用NamingService把逻辑服务映射到具体节点,RocketMQ的NameServer、RPC注册中心都承担类似寻址职责;客户端不需要配置每个Broker物理地址。

命名服务映射逻辑地址

NamingService保存“特定服务位于哪个节点”的路由,使客户端可从逻辑主题或服务名找到物理地址。节点主动注册,客户端可直接查命名服务,也可经业务节点缓存中转。它把节点变化封装在寻址层,是弹性集群的通用协作方式。

命名服务映射逻辑地址保留这一想法的依据。

原书依据 · 1 处

23-RocketMQ客户端如何在集群中找到正确的节点? / NameServer是如何提供服务的?

每个NameServer独立保存完整路由,节点之间不互通。Broker向所有NameServer注册与定期上报,客户端选择一个查询;连接失效会移除路由,客户端失败后重新获取并切换。

独立NameServer节点

NameServer集群节点互不通信,每个节点独立提供完整寻址服务。Broker向所有NameServer注册并周期上报路由,兼作心跳;客户端选任一节点查询。失效Broker路由被移除,客户端通信失败后刷新路由。这里的自动寻址不能突破特定队列的副本与顺序边界。

独立NameServer节点保留这一想法的依据。

原书依据 · 1 处

23-RocketMQ客户端如何在集群中找到正确的节点? / NameServer的总体结构

路由存在内存中:topicQueueTable由主题找到队列及brokerName,brokerAddrTable再由brokerName找到主从物理地址。其余Map维护存活、集群归属与过滤服务地址。

两级路由定位Broker

NameServer的topicQueueTable由主题查队列,队列记录brokerName;brokerAddrTable再将brokerName映射为含主从地址的BrokerData。brokerName表示一组主从,不是某一个物理地址。逻辑分组与实际地址分开,使队列位置和副本地址能分别管理。

两级路由定位Broker保留这一想法的依据。

原书依据 · 1 处

23-RocketMQ客户端如何在集群中找到正确的节点? / NameServer如何处理Broker注册的路由信息?

Broker注册按请求类型和协议版本分发,最终更新路由Map。五份路由表构成一个一致资源,更新时共用写锁,避免读到表间不一致的中间状态。

整体路由表共用读写锁

NameServer注册请求会依次更新集群、地址、队列、存活和过滤服务等Map。它们共同描述同一集群状态,不能仅保证每个Map单独线程安全;更新过程整体持写锁,查询持读锁,才能避免跨表读到部分更新的数据。

整体路由表共用读写锁保留这一想法的依据。

原书依据 · 1 处

23-RocketMQ客户端如何在集群中找到正确的节点? / 客户端如何寻找Broker?

客户端周期获取相关主题路由并缓存。服务端查询先取主题队列、收集brokerName,再取对应BrokerData,组合TopicRouteData;缓存让每次生产消费无需重新访问NameServer。

客户端缓存主题路由

客户端定期向NameServer获取TopicRouteData,缓存队列和Broker信息。发送时由队列取brokerName,再取对应主节点物理地址。服务端查询在读锁内组合主题队列与关联Broker,保证一次返回的关联信息一致,同时减少寻址网络往返。

客户端缓存主题路由保留这一想法的依据。

原书依据 · 1 处

23-RocketMQ客户端如何在集群中找到正确的节点? / 小结

回顾NameServer的独立路由节点、主动注册与客户端查询,并抽象为通用NamingService:保存路由、接收节点注册、提供直接或代理查询。

23-RocketMQ客户端如何在集群中找到正确的节点? / 思考题

练习要求分析NameServer节点互不通信的优缺点,本页没有展开答案。

24-Kafka的协调服务ZooKeeper:实现分布式系统的“瑞士军刀” / 正文片段157

Kafka采用ZooKeeper协调元数据与集群,和只聚焦寻址的NameServer走不同路线。本讲使用的是当时依赖ZooKeeper的Kafka架构。

24-Kafka的协调服务ZooKeeper:实现分布式系统的“瑞士军刀” / ZooKeeper的作用是什么?

ZooKeeper以树形ZNode保存少量一致性元数据,临时节点随客户端会话失效清除,Watcher通知节点变化。这些原语可组合节点存活监测、选举、通信和锁。

ZooKeeper协调元数据

ZooKeeper提供树形ZNode存储和集群协调能力,适合节点信息与公共配置等少量共享元数据。业务利用其一致性与变化通知组合更高层的协调机制,而不是把它当作海量业务数据仓库。Leader与多数派维护本身也引入集群管理依赖。

ZooKeeper协调元数据保留这一想法的依据。

原书依据 · 1 处

临时节点与Watcher

客户端创建临时ZNode后,ZooKeeper以会话和心跳判断存活,连接会话失效后清除临时节点。其他节点通过Watcher订阅变化,能感知节点上线、下线并触发协调。临时状态加通知把故障感知从每对业务节点的互相探测中集中出来。

临时节点与Watcher保留这一想法的依据。

原书依据 · 1 处

24-Kafka的协调服务ZooKeeper:实现分布式系统的“瑞士军刀” / Kafka在ZooKeeper中保存了哪些信息?

本页展示Kafka Broker标识与主题分区元数据树,客户端寻址要从分区Leader的BrokerID再找到物理地址。图文中的实现描述带有历史版本语境,不将具体ZNode生命周期当作跨版本协议。

分区路由关联节点标识

Kafka元数据把Broker信息与主题分区信息分开存储:主题分区记录Leader等节点标识,再通过Broker标识查到节点地址。这样的间接映射避免每份分区信息都复制物理连接细节,客户端只需获取自己关心的主题子集。此处据本书ZooKeeper时代架构说明。

分区路由关联节点标识保留这一想法的依据。

原书依据 · 1 处

24-Kafka的协调服务ZooKeeper:实现分布式系统的“瑞士军刀” / Kafka客户端如何找到对应的Broker?

客户端请求Broker元数据,而非直连ZooKeeper;Broker从本地缓存返回主题与在线节点,缓存再由协调变更更新。请求先建Builder并入队,真正发送时才构造与批量发出。

Broker中转元数据

Kafka客户端仅与Broker通信,发送目标主题列表来请求元数据。Broker从本地MetadataCache取主题分区和在线Broker信息返回,避免每个客户端都直接读ZooKeeper。协调服务变化更新Broker缓存,客户端再保存自己需要的元数据子集。

Broker中转元数据保留这一想法的依据。

原书依据 · 1 处

24-Kafka的协调服务ZooKeeper:实现分布式系统的“瑞士军刀” / 小结

ZooKeeper不适合堆积大量数据,协调服务故障还可能扩大业务影响。本页建议对依赖它的大规模Kafka按独立小集群隔离;其替代路线是写作时的讨论,不视为今日产品现状。

控制协调服务故障域

协调服务既要保持少量元数据,也要避免成为所有业务请求的强依赖。本书建议将当时依赖ZooKeeper的大规模Kafka拆为独立小集群,每组配自己的协调集群,减少单组元数据规模与故障波及面。这是隔离思路,具体部署需按实际版本验证。

控制协调服务故障域保留这一想法的依据。

原书依据 · 1 处

24-Kafka的协调服务ZooKeeper:实现分布式系统的“瑞士军刀” / 思考题

练习要求继续分析Broker元数据缓存如何同步ZooKeeper,未提供具体源码答案。

25-RocketMQ与Kafka中如何实现事务? / 正文片段163

本讲深入事务实现,分别解释RocketMQ的本地事务与消息一致性,以及Kafka跨分区多消息事务与流计算语义。

25-RocketMQ与Kafka中如何实现事务? / RocketMQ的事务是如何实现的?

RocketMQ先写不可见半消息,再执行本地事务,随后单向提交或回滚;Broker定时反查兜底。半消息保存原主题队列属性后移入内部主题,提交才复制回业务队列,回滚只标处理完成。

半消息隔离未决事务

RocketMQ把事务消息标成半消息,保存原主题与队列后,改写到内部RMQ_SYS_TRANS_HALF_TOPIC的队列0。业务消费者看不到它,因此本地事务尚未确定时不会提前消费。提交后复制回真正业务队列,回滚则只结束半消息处理。

半消息隔离未决事务保留这一想法的依据。

原书依据 · 1 处

事务反查兜底提交

Producer在半消息写入成功后执行本地事务,再把提交或回滚结果以单向请求通知Broker。通知可能丢失,所以Broker定时读取未决半消息,要求Producer查询本地事务事实,再提交、回滚或稍后重查。反查依据必须能可靠说明真实业务结果。它使本地事务与消息达到最终一致,不把下游消费副作用自动纳入该事务;消费者仍需处理重试和幂等。

事务反查兜底提交保留这一想法的依据。

原书依据 · 1 处

不存在不等于事务失败

订单事务反查发现订单存在,可据此提交消息;查不到订单却可能意味着事务失败,也可能仍在执行,因此示例返回UNKNOW等待后续确认。把暂未可见当作确定失败会过早裁决未完成事务。半消息发送状态也应与本地业务最终结果区分。

不存在不等于事务失败保留这一想法的依据。

原书依据 · 1 处

25-RocketMQ与Kafka中如何实现事务? / Kafka的事务和Exactly Once可以解决什么问题?

RocketMQ事务关联本地事务与消息,Kafka事务关联多主题分区消息。本书讨论的Kafka Exactly Once限定为Kafka输入、计算、Kafka输出,不能据名称推成任意业务副作用只执行一次。

消息事务的两种范围

RocketMQ事务消息协调本地业务事务与发消息,并用反查补足未决状态;Kafka事务保证多条跨主题分区消息整体提交或回滚,没有同样的本地事务反查。两者名称相同但边界不同,不能以Kafka事务自动覆盖外部数据库提交。

消息事务的两种范围保留这一想法的依据。

原书依据 · 1 处

恰好一次先限定端点

本书Kafka Exactly Once针对从Kafka读取、计算、再写回Kafka的链路,要求计算结果不因故障重放而重复。它不表示任意生产者到任意消费业务天然恰好一次;外部副作用仍需相应事务或幂等协议。理解语义先说明哪两端和哪些状态受保证。

恰好一次先限定端点保留这一想法的依据。

原书依据 · 1 处

25-RocketMQ与Kafka中如何实现事务? / Kafka的事务是如何实现的?

Kafka事务协调者是Broker的一部分,以事务日志保存参与分区和提交状态。消息先入业务分区,消费者隔离未提交数据;预提交日志确定决议后,各参与分区写结束标记,最后记录事务完成。

Kafka事务日志协调

Kafka事务协调者运行于Broker内,使用专门事务日志主题记录事务ID、参与分区与状态;多个协调者分管日志分区以并行处理。业务消息可先写目标分区,事务状态由协调者日志管理,使跨分区提交能恢复推进。

Kafka事务日志协调保留这一想法的依据。

原书依据 · 1 处

事务标记控制可见性

Kafka先把事务消息写入实际业务分区,提交时协调者记录预提交,再向参与分区写“事务结束”标记,最后记录完成。消费者按事务隔离规则决定放行消息,与RocketMQ先放内部半消息队列不同。使用者需要配置只读已提交事务,不能假定默认过滤。

事务标记控制可见性保留这一想法的依据和关系图。

原书依据 · 1 处

25-RocketMQ与Kafka中如何实现事务? / 小结

总结两种事务都借助阶段化提交与特殊日志,但消息隔离位置和适用业务范围不同。

25-RocketMQ与Kafka中如何实现事务? / 思考题

练习要求细化Kafka事务时序并分析协调者故障恢复,正文没有提供恢复实现。

26-MQTT协议:如何支持海量的在线IoT设备? / 正文片段169

IoT把设备接入网络,MQTT是面向这类设备的标准消息通信协议,采用服务端转发的通信方式。

MQTT面向设备通信

MQTT为物联网设备提供标准消息通信,使设备连接支持该协议的Broker来收发消息。它沿用发布订阅和客户端—服务端结构,特殊性来自设备资源弱、无线网络不稳定和在线设备量大的使用环境,而非另造一套消息模型。

MQTT面向设备通信保留这一想法的依据。

原书依据 · 1 处

26-MQTT协议:如何支持海量的在线IoT设备? / MQTT和其他消息队列的传输协议有什么不同?

IoT设备资源有限且连接不稳定,MQTT精简报文与功能,用心跳及服务端会话支持重连。客户端专属主题还使主题规模随设备数量增长,形成海量连接与元数据挑战。

MQTT会话承接不稳定连接

低成本IoT设备算力和内存有限,无线连接中断是常态。MQTT精简报文和功能,并用心跳检测连接状态、服务端会话保留重连所需状态,把复杂度放到服务端。连接恢复后继续通信的能力必须与会话存储及路由一起设计。

MQTT会话承接不稳定连接保留这一想法的依据。

原书依据 · 1 处

26-MQTT协议:如何支持海量的在线IoT设备? / 如何选择MQTT产品?

MQTT服务端选型除协议兼容与吞吐,还应检验海量客户端、主题、集群及水平扩展能力。书中的开源/商业市场判断属于写作时经验,不将十万规模阈值当作当前产品通则。

MQTT选型看扩展维度

普通消息队列即使插件支持MQTT,也未必在元数据、主题数量和连接管理上适合海量设备。评估应覆盖客户端并发在线、主题基数、集群故障与水平扩容,不能只验证协议能否收发。书中对产品可选范围和数量阈值的评价有年代背景。

MQTT选型看扩展维度保留这一想法的依据。

原书依据 · 1 处

26-MQTT协议:如何支持海量的在线IoT设备? / MQTT集群如何支持海量在线的IoT设备?

前置Proxy承担海量连接、会话与转发,把设备连接收敛为较少Broker连接。会话可本地配sticky session或外置使Proxy无状态;大量主题可分到多组Broker小集群,由Proxy按主题分片。

Proxy收敛海量连接

MQTT前置Proxy承接设备连接并转发消息,每个Proxy到每个Broker只需较少连接,Broker面对的是Proxy数量而非设备数量。Proxy可水平扩容承担在线连接,后端Broker专注消息存储。代理也承担会话管理,不能只按网络转发器设计。

Proxy收敛海量连接保留这一想法的依据。

原书依据 · 1 处

会话位置约束负载均衡

会话存Proxy本地时,重连必须经sticky session回到原节点;会话放外部Redis或数据库后,Proxy可无状态调度,但外部集群要承担海量会话的容量与性能。两种方式在路由约束和存储依赖间取舍,外置状态并非零成本。

会话位置约束负载均衡保留这一想法的依据。

原书依据 · 1 处

主题分片到多组集群

当单个Broker集群无法承载全部主题元数据时,可部署多组小集群,每组只保存部分主题。Proxy根据主题名用一致性哈希等分片方法路由到目标集群,将主题基数压力拆开。接入连接扩容和后端主题分片是两个不同维度。

主题分片到多组集群保留这一想法的依据。

原书依据 · 1 处

26-MQTT协议:如何支持海量的在线IoT设备? / 总结

回顾MQTT的资源与连接场景,以及Proxy解决连接、会话和主题规模的三个职责。

26-MQTT协议:如何支持海量的在线IoT设备? / 思考题

练习要求画Proxy类图与消息收发时序图,没有给出实现类结构。

27-Pulsar的存储计算分离设计:全新的消息队列设计思路 / 正文片段175

Pulsar用与传统Broker本地存储不同的架构引出存储计算分离,作者关于未来方向的说法属于判断。

27-Pulsar的存储计算分离设计:全新的消息队列设计思路 / Pulsar的架构和其他消息队列有什么不同?

Pulsar将消息放BookKeeper、元数据放ZooKeeper,Broker负责收发及动态分区管理。Ledger只允许创建者写,关闭后只读,以单写者约束避开共享写锁;分区仍在一个时刻交给一个Broker。

Pulsar分离存储职责

Pulsar由BookKeeper保存消息、ZooKeeper保存元数据,Broker集中处理消息收发及分区管理,因此不依赖本地持久消息接管故障。客户端仍需先查当前分区归属再连Broker;无状态不表示多个Broker可以同时任意写同一分区。

Pulsar分离存储职责保留这一想法的依据。

原书依据 · 1 处

Ledger单写者避免争用

Ledger是一段连续日志,内部消息称Entry。创建Ledger的Broker独占写入,Ledger关闭后永久只读,需要继续写则新建Ledger。用所有权和生命周期消除共享写入,比给跨节点任意写者加分布式锁更简单,也更容易维持顺序。

Ledger单写者避免争用保留这一想法的依据。

原书依据 · 1 处

无状态Broker灵活接管

持久消息由BookKeeper负责后,Broker可按负载动态接管分区,故障时无需只能挑拥有相同本地消息的Broker替代。Load Balancer安排分区归属,Managed Ledger管理日志,Cache加速读。持久可靠性并未消失,而是由存储集群承担。

无状态Broker灵活接管保留这一想法的依据。

原书依据 · 1 处

27-Pulsar的存储计算分离设计:全新的消息队列设计思路 / 存储计算分离的设计有哪些优点?

存储计算分离让计算节点容易扩容、调度和故障替换,也让开发职责聚焦。它把一致性、复制与恢复移交存储层,并增加网络访问及集群管理成本;使用成熟存储时业务系统可获得净收益。

存储计算分离的收益

把持久数据交给存储节点后,计算节点专注业务处理,可按相同能力水平扩展、灵活分流并快速替换故障节点。计算开发者无需重复实现存储可靠性,存储实现也可聚焦安全高效读写。收益建立在状态职责分清和存储能力适配的前提上。

存储计算分离的收益保留这一想法的依据。

原书依据 · 1 处

分离没有消除复杂度

存储计算分离将复制、一致性、选举和恢复转移到存储集群,不会凭空解决它们。原来本地读变成远程请求,还可能增加网络传输与内存拷贝。业务系统若复用成熟存储,开发负担仍可能降低;自建底层系统则需评估整体复杂度与性能。

分离没有消除复杂度保留这一想法的依据。

原书依据 · 1 处

27-Pulsar的存储计算分离设计:全新的消息队列设计思路 / 小结

总结Pulsar架构及存储计算分离:计算无状态易管理,但系统整体复杂度和远程读写开销可能增加。

27-Pulsar的存储计算分离设计:全新的消息队列设计思路 / 思考题

思考题要求权衡为什么其他消息队列未普遍分离存储计算;后续答疑提供了观点,本页只有题目。

28-答疑解惑(二):我的100元哪儿去了? / 正文片段180

进阶篇结尾答疑,预告幂等、Leader协调和存储计算架构三个热点。

28-答疑解惑(二):我的100元哪儿去了? / 1. 我的100元哪儿去了?聊聊并发调用情况下的幂等性

设置固定余额在线性重复下看似幂等,但旧请求响应丢失后重试可覆盖后续转账。原子性本身不能解决跨请求顺序,带流水号的条件更新才把过期请求排除。

旧余额请求覆盖新入账

账户初始100元,设置为200成功但响应丢失;随后设置300成功;第一个请求重试又设200,最终少了100元。每次赋值即使原子且单独重复不改变结果,也会因旧请求夹入新请求之后而破坏余额。根因是请求没有携带能拒绝过期更新的身份或版本条件。见流水号约束余额更新。

旧余额请求覆盖新入账保留这一想法的依据。

原书依据 · 1 处

流水号约束余额更新

每次更新携带预期流水号v,只有账户当前流水号仍等于v时,才原子地加金额并把流水号加一。成功后同一请求重试的v已过期,不能再次入账或覆盖后续结果。检查版本、余额变更和流水号递增必须是一个原子操作。它解决旧余额请求覆盖新入账中的旧请求插入风险。

流水号约束余额更新保留这一想法的依据。

原书依据 · 1 处

28-答疑解惑(二):我的100元哪儿去了? / 2. Kafka和RocketMQ如何通过选举来产生新的Leader?

Kafka分区Leader由Controller从ISR指定;Controller则通过抢建同一ZooKeeper临时节点产生。抢占式选主依赖一致存储,自投票如Dledger/Raft减少外部依赖但实现更复杂。

抢占临时节点选主

所有候选尝试创建同一临时节点,只有一个能成功,成功者成为Leader;其余Watch节点,失效消失后重新竞争。它依赖共享存储能原子确保唯一创建,并具有有效的存活通知。Kafka此处用它产生Controller,Controller再指定分区Leader,二者不能混称同一选举。

抢占临时节点选主保留这一想法的依据。

原书依据 · 1 处

投票选举与外部抢占

Dledger以Raft等协议由节点投票达成一致,不依赖外部“唯一名额”存储。外部抢占实现简单,但依赖协调存储;自选举减少外部依赖,却要处理更多一致性细节和投票恢复过程。本节只比较设计路径,未展开Raft算法。

投票选举与外部抢占保留这一想法的依据。

原书依据 · 1 处

28-答疑解惑(二):我的100元哪儿去了? / 3. 为什么说Pulsar存储计算分离的架构是未来消息队列的发展方向?

消息队列从数据管道演为日志存储时,分离计算未必划算;若融合流计算,则分离可让计算和可靠存储各司其职。这是作者基于路线图的方向判断,并要求源码学习以动手跟踪和画图落实。

消息存储与计算融合

若消息队列主要只是高速日志存储,抽走存储后计算层所剩有限,却增加网络与集群复杂度;若它同时承担流计算,独立计算节点就有明确职责。作者以此解释为何Pulsar式分离可能适合消息与计算融合的发展方向,这属于架构推测而非已证实结局。

消息存储与计算融合保留这一想法的依据。

原书依据 · 1 处

29-流计算与消息(一):通过Flink理解流计算的原理 / 正文片段184

消息队列和流计算都处理实时流,共享异步通信、序列化等基础技术。本讲先用Flink统计,下一讲再补充Kafka端到端语义。

29-流计算与消息(一):通过Flink理解流计算的原理 / 哪些问题适合用流计算解决?

流计算适合实时生成数据的实时统计分析,框架提供并行计算和常用窗口、分组、求和等算子,特别适合按时间统计。

流计算的两个实时

流计算同时要求数据实时产生、分析结果实时更新,适合每分钟按IP统计请求、大促下单计数等场景。框架以时间窗口、分组和聚合算子组织连续输入,并自动并行执行。是否值得使用应先看时效要求,而不是数据量大就一律流计算。

流计算的两个实时保留这一想法的依据。

原书依据 · 1 处

29-流计算与消息(一):通过Flink理解流计算的原理 / 用代码定义Job并在Flink中执行

Flink Job用代码声明输入、计算和输出。示例从Socket读时间/IP日志,转换结构、提取事件时间、按IP分组,每5秒求count之和再打印;定义任务的代码不是逐条数据直接执行的完整程序。

Job声明输入计算输出

Flink任务定义由数据从哪里来、怎样转换计算、结果到哪里去组成。示例从Socket读日志,将文本转成日期/IP/count结构,再按IP和5秒事件时间窗口求和,最后输出。声明让框架构建执行图,不是让每条数据重新运行一次任务定义代码。

Job声明输入计算输出保留这一想法的依据。

原书依据 · 1 处

事件时间窗口计数

示例先把日志时间解析为date,并用assignAscendingTimestamps提供事件时间,再按IP分组,在5秒滚动事件时间窗口累加count。输入每条count为1,因此求和就是该IP在窗口内的请求数。这里假定时间戳递增,不能直接视为一般乱序流的完整处理方案。

事件时间窗口计数保留这一想法的依据。

原书依据 · 1 处

29-流计算与消息(一):通过Flink理解流计算的原理 / Job是如何在Flink集群中执行的?

JobManager解析任务、形成DAG并调度TaskManager执行;Task可拆成多个SubTask。REBALANCE分散上游负载,keyBy哈希则保证相同IP进入同一聚合子任务。

DAG拆分并行子任务

Flink将任务定义解析为有向无环的执行图,每个Task完成一组变换。并行度决定Task的SubTask数,这些子任务可由不同TaskManager执行,JobManager协调调度。数据依次经过Source、中间变换和Sink,分布式执行无需业务逐节点编排。

DAG拆分并行子任务保留这一想法的依据。

原书依据 · 1 处

哈希分流汇集同一键

按IP聚合时,必须让相同IP进入同一聚合SubTask,该子任务才能用本地状态累加完整结果。keyBy以哈希分流建立这个归属。普通REBALANCE只用于分摊负载,不能替代按键汇集;这与相同key消息映射同一分区的思想相通。

哈希分流汇集同一键保留这一想法的依据。

原书依据 · 1 处

29-流计算与消息(一):通过Flink理解流计算的原理 / 小结

自动拆分并行任务和经过优化的常用算子,是流计算框架高性能的重要来源。

框架性能来自并行与算子

流计算框架的性能并非来自神奇黑盒:一方面把任务拆成子任务并行执行,另一方面提供长期优化的统计与转换算子。使用框架既减少手写分布式统计的代码,也复用成熟优化;真正收益仍取决于任务能否分摊以及数据分布。

框架性能来自并行与算子保留这一想法的依据。

原书依据 · 1 处

29-流计算与消息(一):通过Flink理解流计算的原理 / 思考题

练习要求查清Task Slot与并行度关系,正文没有解释槽的语义,不补造对应卡。

30-流计算与消息(二):在流计算中使用Kafka链接计算任务 / 正文片段190

流计算失败时重启并回溯可避免丢失,却可能重算和重复输出;统计任务重复数据会改变结果,因此需要把内部恢复与外部输出一起纳入语义。

流恢复重放可能重复

把任务状态外置可替换故障节点,却不能自动找回尚在流中的数据。重启并回溯源可避免漏算,但也会重算已处理输入、重复输出,计数等非幂等计算会因此错误。恢复状态、源位置和输出提交需要共同设计。

流恢复重放可能重复保留这一想法的依据。

原书依据 · 1 处

30-流计算与消息(二):在流计算中使用Kafka链接计算任务 / Flink是如何保证Exactly Once语义的?

CheckPoint同时保存子任务状态与数据源位置,恢复要使两者对应。Barrier随数据流传播,各节点在相同边界保存状态;但已经发送到外部的结果不能单凭内部恢复撤回。

快照对齐状态与源位置

CheckPoint不仅保存中间累计状态,也保存数据源消费位置。恢复时,状态应恰好对应已处理完恢复位置之前的数据、尚未处理恢复位置之后的数据。只恢复位置或只恢复状态都会造成漏算或重复;快照的意义是保留一致的计算边界。

快照对齐状态与源位置保留这一想法的依据。

原书依据 · 1 处

Barrier标记快照边界

Barrier是一条插入数据流的特殊标记。它经过各计算节点时触发保存该节点状态,源节点同时记录输入位置;标记完成传播后形成一致CheckPoint。它把持续流中的一个恢复边界传递给各节点,而不是让各节点任意时刻各存一份互不对应的快照。

Barrier标记快照边界保留这一想法的依据。

原书依据 · 1 处

30-流计算与消息(二):在流计算中使用Kafka链接计算任务 / Kafka如何配合Flink实现端到端Exactly Once?

Kafka生产幂等用递增序号检测重复,事务使一组输出整体可见。Flink将每个CheckPoint对应一个Kafka事务,并以两阶段控制同步完成快照和提交输出。

序号检测生产重复

Kafka生产幂等给消息附加连续递增序号,由Broker检查重复并拒绝重复写入,从而抑制发送重试产生的副本。这个序号机制解决生产路径去重,单靠它不能约束计算重放后新生成的业务输出,还需要事务与快照配合。

序号检测生产重复保留这一想法的依据。

原书依据 · 1 处

快照对应输出事务

每个Flink CheckPoint对应一个Kafka事务:快照完成时同步提交该批输出,恢复时回到上一个完整快照及其已提交输出边界。未完成快照对应的未提交输出被丢弃。两阶段提交协调“保存状态”和“输出可见”,避免恢复后重复暴露已经输出的结果。

快照对应输出事务保留这一想法的依据。

原书依据 · 1 处

30-流计算与消息(二):在流计算中使用Kafka链接计算任务 / Exactly Once版本的Web请求的统计

示例改用Kafka源和输出,开启EXACTLY_ONCE CheckPoint、指定持久后端与自动重启,并将Kafka Sink设为EXACTLY_ONCE。结果消费者必须read_committed;本地临时目录仅适合实验。

端到端语义配置成套

书中Flink/Kafka示例需要同时开启CheckPoint及EXACTLY_ONCE模式、配置可靠StateBackend和自动恢复,并让Kafka Sink采用EXACTLY_ONCE事务语义。生产中快照需放可靠分布式存储,本地临时目录仅用于单机实验。只开启一个选项不足以证明链路可靠。

端到端语义配置成套保留这一想法的依据。

原书依据 · 1 处

消费者只读已提交结果

消费事务化计算结果时,应设置isolation.level=read_committed,只向业务暴露已提交输出。书中说明默认Consumer可能读取未提交事务消息;若忽略隔离级别,即使上游使用事务,也可能把尚未确定的输出用于后续业务。

消费者只读已提交结果保留这一想法的依据。

原书依据 · 1 处

30-流计算与消息(二):在流计算中使用Kafka链接计算任务 / 小结

总结端到端语义由快照、Barrier、生产幂等、事务及两阶段提交组合,强调学习各局部问题与适用方法,具体参数用到时再查版本文档。

30-流计算与消息(二):在流计算中使用Kafka链接计算任务 / 思考题

练习要求分析FlinkKafkaConsumer的消费确认与位置维护,未给出实现答案。

31-动手实现一个简单的RPC框架(一):原理和程序的结构 / 正文片段196

RPC案例用于迁移消息队列学到的通信、序列化与寻址能力;本课程把RPC限定为像调用本地方法一样透明调用远程接口。

31-动手实现一个简单的RPC框架(一):原理和程序的结构 / RPC框架是怎么调用远程服务的?

客户端拿到的是实现服务接口的Stub代理,它封装服务签名和参数发请求;服务端按名称调用已注册实现再返回结果。注册中心解决物理寻址,共同序列化与IDL支撑跨语言服务定义。

Stub代理远程调用

Stub是客户端本地代理,具有与服务接口相同的方法。调用时封装服务名、方法名和参数,经网络发送;服务端查找真实提供者并执行,再把结果返回代理,代理解析后交给调用方。接口调用看似本地,实际仍有网络失败与远端执行的边界。

Stub代理远程调用保留这一想法的依据和关系图。

原书依据 · 1 处

IDL统一跨语言服务

跨语言RPC要求请求和响应采用双方都能解析的序列化协议,还需用IDL统一描述服务接口,再转成各语言的接口或抽象类。语言实现虽不同,服务定义与线格式必须一致;网络传输相同并不自动意味着类型语义兼容。

IDL统一跨语言服务保留这一想法的依据。

原书依据 · 1 处

31-动手实现一个简单的RPC框架(一):原理和程序的结构 / RPC框架的总体结构是什么样的?

RpcAccessPoint提供获取远程代理、注册提供者及启停,NameService注册和查询服务地址;示例模块把接口契约、客户端、服务端与Netty实现分离。

RPC接入与寻址分责

RpcAccessPoint提供远程代理、注册提供者和服务启停;NameService单独负责服务名与URI的注册查询。客户端先寻址再取代理,服务端先启动并注册实现再发布地址。把RPC契约与寻址接口分开,允许通信和注册方式独立替换。

RPC接入与寻址分责保留这一想法的依据和关系图。

原书依据 · 1 处

31-动手实现一个简单的RPC框架(一):原理和程序的结构 / 小结

回顾Stub将接口调用变成请求并由服务端真实实现执行,是RPC透明调用的关键。

31-动手实现一个简单的RPC框架(一):原理和程序的结构 / 思考题

作业要求运行示例并阅读API、接口、客户端与服务端模块,为后续实现建立整体认识。

32-动手实现一个简单的RPC框架(二):通信与序列化 / 正文片段201

序列化与网络通信应抽象成可复用组件,既能供RPC也能供消息队列使用。原型为讲清主干而有简化。

32-动手实现一个简单的RPC框架(二):通信与序列化 / 如何设计一个通用的高性能序列化实现?

SerializeSupport隐藏Serializer实现,按对象Class及类型字节分别选择序列化和反序列化器。专用实现适合固定类型,RPC任意参数通常需通用实现;字符串两端必须约定编码。

专用与通用序列化

固定类型的内部命令可用专用序列化换取性能,但每类数据都要写转换器。RPC参数来自任意用户接口,成熟框架通常需要通用实现。书中专用方案用于演练,并通过可扩展注册器补类型,不应误认为已经自动支持所有参数。

专用与通用序列化保留这一想法的依据。

原书依据 · 1 处

类型标识路由序列化

Serializer定义长度计算、序列化、反序列化、类型字节和对象Class。SerializeSupport按对象Class找写入器,反向则从字节中的类型标识找到解析器。使用者只依赖统一入口,新增类型只需提供相应实现和注册,而不修改调用者。

类型标识路由序列化保留这一想法的依据和关系图。

原书依据 · 1 处

字符串编码必须显式

String与字节数组互转时,两端要显式使用同一字符编码,例如UTF-8。若依赖各机器默认编码,开发机正常的内容可能在服务器间变乱码。编码属于线格式契约的一部分,序列化器写出与解析必须匹配。

字符串编码必须显式保留这一想法的依据。

原书依据 · 1 处

32-动手实现一个简单的RPC框架(二):通信与序列化 / 使用Netty来实现异步网络通信

Transport以Future统一异步发送,命令头携带关联ID、版本和类型。NettyTransport登记在途请求后发送,响应按ID完成Future;异常和超时必须清理。信号量限制在途数补回异步缺失的背压。

Future统一调用方式

Transport.send返回CompletableFuture:调用get可阻塞取得结果,注册then类回调可异步处理。底层只需实现一次非阻塞发送,调用方选择等待方式。返回Future不代表请求成功,最终结果和异常都通过它完成。

Future统一调用方式保留这一想法的依据。

原书依据 · 1 处

命令头先做通用处理

Command由Header和已序列化payload组成。Header的requestId配对异步请求响应,type路由处理器,version标识协议;ResponseHeader另带code和error。先解析公共头可做校验与分发,而无需各层都解释业务载荷。

命令头先做通用处理保留这一想法的依据和关系图。

原书依据 · 1 处

协议版本独立演进

传输命令要携带协议版本,接收方先判断是否支持,再正常解析或明确拒绝,避免新旧格式混用。协议版本不等于程序发布版本。书中原型只有字段而未补版本校验,生产实现需要补足检查,不能因字段存在就认为兼容已实现。

协议版本独立演进保留这一想法的依据。

原书依据 · 1 处

在途请求必须有终点

异步发送先用requestId登记Future,响应回来按ID完成。发送异常、网络失败或对端永不响应都可能留下孤儿记录,因此正常完成、异常完成与兜底超时都必须移除在途请求并释放资源,避免内存随未响应请求无限增长。

在途请求必须有终点保留这一想法的依据。

原书依据 · 1 处

信号量限制异步在途

同步等待天然减慢发送速度,异步却可能在服务端跟不上时继续积压。为每个在途请求先获取信号量许可,结束时归还,可限制未完成总量;书中示例10个许可使上限为10。背压把处理能力反馈给发送者,而不是等内存耗尽再失败。

信号量限制异步在途保留这一想法的依据。

原书依据 · 1 处

32-动手实现一个简单的RPC框架(二):通信与序列化 / 小结

总结接口解耦、固定命令头、版本检查及异步背压,强调可复用通信和序列化模块不依赖具体业务调用者。

32-动手实现一个简单的RPC框架(二):通信与序列化 / 思考题

练习要求仅替换serialize.impl包改用其他序列化方案,其他模块不修改,以检验接口隔离是否有效。

33-动手实现一个简单的RPC框架(三):客户端 / 正文片段206

RPC客户端关键是生成与服务接口一致的Stub,再由其把调用封装为请求。

33-动手实现一个简单的RPC框架(三):客户端 / 如何来动态地生成桩?

代理在调用链中增加逻辑而不改上下游。Stub可在IDL编译时生成、运行时直接生成字节码,或像示例先生成源码再动态编译加载;原型限定单个String参数/返回值以简化教学。

代理注入非侵入逻辑

代理对象实现与委托对象相同的接口,在转发前后加入额外行为,因此不用修改调用链上下游即可记录耗时、鉴权或追踪。RPC Stub把真正调用转为远程通信。必须保持接口契约,使调用者仍能通过相同抽象使用对象。

代理注入非侵入逻辑保留这一想法的依据。

原书依据 · 1 处

Stub生成的三条路径

多语言框架可在编译IDL时生成源代码;支持运行时特性的框架可直接构造字节码;教学原型则填充Java源码模板、动态编译并加载,再注入Transport。生成方式不同,目标相同:实现服务接口并把方法名和参数转换为远程请求。

Stub生成的三条路径保留这一想法的依据。

原书依据 · 1 处

Stub工厂隔离生成细节

StubFactory.createStub接受Transport与服务接口Class,返回实现该接口的代理。DynamicStubFactory根据接口方法填模板并动态编译;AbstractStub承载通用远程调用。原型只支持单方法、单String参数和String返回,需扩展类型处理才能解除限制。

Stub工厂隔离生成细节保留这一想法的依据和关系图。

原书依据 · 1 处

33-动手实现一个简单的RPC框架(三):客户端 / 使用依赖倒置原则解耦调用者和实现

依赖倒置让调用方和实现共同依赖接口,但实例装配也必须解耦。Java SPI用META-INF/services配置实现类,使调用者按接口加载实例,无需在代码中依赖具体实现。

依赖倒置约束装配

调用方与实现都依赖接口,能使实现替换和接口复用更容易。但若调用方仍直接new具体实现,依赖并未消除;只把new搬到普通第三方工厂也可能保留间接静态依赖。实例装配应交给注入或插件加载机制。

依赖倒置约束装配保留这一想法的依据。

原书依据 · 1 处

SPI按接口加载实现

Java SPI以META-INF/services下的接口全名作为文件名,文件内容列实现类。接口、实现和配置进入CLASSPATH后,调用方以接口Class加载实现实例,无需在代码中写具体类名。这样新增实现可由部署配置装配,接口契约保持稳定。

SPI按接口加载实现保留这一想法的依据。

原书依据 · 1 处

33-动手实现一个简单的RPC框架(三):客户端 / 小结

回顾代理、动态生成Stub与依赖倒置,强调把模式迁移到实际调用链和可替换实现。

33-动手实现一个简单的RPC框架(三):客户端 / 思考题

练习要求解除单方法String限定,或用其他语言实现兼容客户端,正文没有给出扩展代码。

34-动手实现一个简单的RPC框架(四):服务端 / 正文片段211

RPC服务端分为寻址注册中心和实际调用服务,前者返回服务地址,后者接收请求并执行已注册业务方法。

34-动手实现一个简单的RPC框架(四):服务端 / 注册中心是如何实现的?

示例注册中心用共享本地文件,只支持单机。NameService按URI scheme经SPI选择实现,可扩展远程注册中心;跨进程共享文件必须用操作系统文件锁,进程内锁无效。

URI协议选择注册中心

NameService通过supportedSchemes声明支持的URI协议,通过connect连接地址。RpcAccessPoint按URI scheme从SPI实现中选择适配者,新增注册方式只需添加插件。本书file实现靠本地文件共享,只支持单机,不能据统一接口推断具备跨机器服务能力。

URI协议选择注册中心保留这一想法的依据。

原书依据 · 1 处

跨进程文件用文件锁

多个客户端和服务端进程共同读写注册文件时,线程锁只能约束本进程,挡不住另一个进程。应使用操作系统提供的文件锁,把读取修改共享文件的完整区间保护起来,并在结束或异常时释放。锁作用域必须覆盖实际竞争者。

跨进程文件用文件锁保留这一想法的依据。

原书依据 · 1 处

34-动手实现一个简单的RPC框架(四):服务端 / RPC服务是怎么实现的?

RequestInvocation按命令类型分发处理器,RpcRequestHandler再按服务名找到实例、反射调用方法并封装响应。注册与调用共享同一个服务表,单例确保两个接口取到相同状态。

两层分发保持抽象边界

网络层按Header.type选RequestHandler,RPC业务层再按请求中的服务名找服务实例。两次查找分别解决通信命令路由和业务服务调用,不是同一层重复判断。注册表替代大段分支后,新命令可以增加处理器而不修改网络分发主流程。

两层分发保持抽象边界保留这一想法的依据。

原书依据 · 1 处

服务注册表与反射调用

RpcRequestHandler把服务名映射到提供者实例;处理请求时解析RpcRequest、查服务、反序列化参数并反射调用,再序列化结果。它同时实现RequestHandler和ServiceProviderRegistry,注册与请求处理必须使用同一实例,否则读不到注册状态。

服务注册表与反射调用保留这一想法的依据和关系图。

原书依据 · 1 处

34-动手实现一个简单的RPC框架(四):服务端 / 小结

网络路由与RPC服务分发属于不同抽象层,两层都根据类型选择实现,在各自职责内保持高内聚和低耦合。

34-动手实现一个简单的RPC框架(四):服务端 / 思考题

练习要求通过新插件实现JDBC注册中心,不改框架源码并兼容多种JDBC数据库,下一讲给参考实现。

35-答疑解惑(三):主流消息队列都是如何存储消息的? / 正文片段216

案例篇答疑把重点落在把模式和编码技巧真正用于业务代码,而非只理解示例。

35-答疑解惑(三):主流消息队列都是如何存储消息的? / 1. 主流消息队列都是如何存储消息的?

消息队列的分区接近只能尾部追加的WAL。Kafka按分区分段并建稀疏索引,RocketMQ Broker共用消息文件、每队列建20字节稠密索引,两者以写顺序、迁移灵活性和索引空间换寻址性能。

消息日志只追加顺序读

分区可看作WAL:写入只在尾部追加,不修改已有消息;读取先根据序号定位,再连续批量顺序读。消息文件配索引文件,把快速追加与消费定位分开。找到起点后无需为每条消息重新寻址,是队列存储简单高效的基础。

消息日志只追加顺序读保留这一想法的依据。

原书依据 · 1 处

Kafka稀疏索引定位

Kafka每个分区分成消息段及配对索引,文件名取该段首条序号。查找先定位段,再二分查最近的稀疏索引,从其指向的消息位置顺序扫描目标。少建索引节省空间,代价是额外扫描;定位后可批量顺序读取。

Kafka稀疏索引定位保留这一想法的依据。

原书依据 · 1 处

稠密队列索引直接寻址

RocketMQ把同Broker各队列消息追加到共享消息文件,每队列另有ConsumeQueue索引。本书索引项固定20字节,按队列序号乘固定长度可定位索引,再按记录位置找消息。稠密索引使定位直接,但每条消息都付出索引空间。

稠密队列索引直接寻址保留这一想法的依据。

原书依据 · 1 处

存储粒度影响写入与迁移

Kafka按分区保存消息段,分区迁移与扩容较灵活;RocketMQ按Broker合并消息追加,活跃主题很多时同时写的文件更少,顺序批写更集中。稀疏与稠密索引还分别偏向省空间与快定位,选择需结合小消息、主题数和迁移需求。

存储粒度影响写入与迁移保留这一想法的依据。

原书依据 · 1 处

35-答疑解惑(三):主流消息队列都是如何存储消息的? / 2. 流计算与批计算的区别是什么?

流计算边产生边统计、结果及时;批计算保存原始数据后再统计,延迟较大但便于故障重算和需求改变后重算。窗口相同并不意味着两种执行方式相同。

流批计算按需求权衡

流计算边接收边统计,窗口结束即可及时给出结果;批计算先保存原始数据再处理,结果较晚,但可用新算法重算,也更便于故障回放。同样按小时汇总仍可能采用不同执行方式,选择取决于结果时效与保留重算能力,而非只有窗口长短。

流批计算按需求权衡保留这一想法的依据。

原书依据 · 1 处

35-答疑解惑(三):主流消息队列都是如何存储消息的? / 3. RPC框架的JDBC注册中心

JDBC注册中心把元数据放数据库,实现NameService;不同数据库SQL方言拆成按类型命名资源,运行时配套驱动,减少核心Java代码变化。图示表仅服务名和URI两列。

JDBC注册中心隔离方言

JDBC统一连接接口却不统一SQL语法。示例JdbcNameService把服务注册/查询和建表SQL移为按数据库类型命名的资源文件,并与驱动一起在运行时提供。元数据表保存service_name与uri,核心注册逻辑不必因数据库方言重写。

JDBC注册中心隔离方言保留这一想法的依据。

原书依据 · 1 处

35-答疑解惑(三):主流消息队列都是如何存储消息的? / 4. 完成作业的最佳姿势

GitHub Fork把示例复制到个人账号,适合在副本修改和分享作业。

Fork保存实验副本

在示例项目页面使用Fork,可在自己账号下创建项目副本,随后在副本扩展和修改并分享链接。它让练习基于同一来源又保有个人修改空间,适合围绕原项目交付可查看的作业。

Fork保存实验副本保留这一想法的依据。

原书依据 · 1 处

35-答疑解惑(三):主流消息队列都是如何存储消息的? / 总结

案例篇收尾强调运行与修改代码,通过练习消化前两篇知识;没有新增具体技术机制。

期中测试丨10个消息队列热点问题自测

期中测试正文实际由图像承载,并非空页。10题分别检查:消息队列用途;端到端Exactly Once的边界;扩分区时的同key顺序;消费组竞争关系;RocketMQ事务适用场景;刷盘、确认消费和队列分布等使用方式;并发账户幂等;MySQL与Redis账户一致性;气象消息序列化选择;PageCache与宕机风险。题图给出选项,没有嵌入答案解析,尾部只提供“答案和解析”按钮。它承接前文自测,不根据选项自行编造本书答案,也不把题干当成已展开的概念解释。

结束语-程序员如何构建知识体系?

结束语把技术体系比成倒锥:基础原理少而相对稳定,上层应用多且变化快。个人应先在同一领域扩展使用广度,再选择核心组件向下追到原理,连通后再扩展新方向,以减少碎片学习带来的未知感。

技术体系要上下贯通

技术上层应用不断增多,底层原理相对稳定。个人学习不只堆产品名称,还应把日常接口调用追到组件实现、数据结构与系统基础,例如从写数据库追到传输、数据库处理和磁盘布局。贯通能支撑疑难排查,也让相邻新技术只需补上层差异。

技术体系要上下贯通保留这一想法的依据。

原书依据 · 1 处

先领域广度再核心深度

先在同一技术领域熟悉常用工具和职责分类,再挑核心框架、容器或数据库深入实现与底层技术。过早跨跨度很大的方向容易形成碎片。一个领域上下连通后,可继续拓宽或进入新方向,通过共有基础逐渐连成更大的知识体系。

先领域广度再核心深度保留这一想法的依据。

原书依据 · 1 处

第二季回归丨这次我们一起实战后端存储

本页推广第二季《后端存储实战课》,说明以电商阶段案例讲解存储,并回顾存储的重要性;没有展开新的存储机制或具体问题解法。保留为课程附记及引用,不重复创建知识卡。

跨章综合

可靠性首先是边界问题。生产端确认、Broker耐久、消费进度和数据库副作用分别处在不同阶段,不能因为某一层支持重试或事务,就声称整条业务链恰好执行一次。第05–06讲的先完成再确认与幂等,第18和28讲的原子更新及流水号,以及第25和30讲对事务/流处理作用范围的讨论,都在回答同一件事:哪些状态必须一起改变,哪些失败允许稍后恢复。

吞吐优化的共同手法是减少重复工作与等待,而非无限增加并发。异步让线程不必在IO期间空等,批量摊薄协议和存储开销,顺序日志与页缓存提高访问局部性,零拷贝减少特定路径的中转。更多线程会带来锁竞争、对象压力和在途状态,因此第14–19讲的内存、缓存、锁和CAS与高吞吐设计紧密相连;优化前仍要知道瓶颈和正确性约束。

业务模型和内部实现需要分开认识。主题、分区、订阅和消费组帮助使用者理解“谁能看到哪份数据”,NameServer、ZooKeeper或具体复制协议则回答系统内部怎样找到节点并在故障后继续。课程用不同产品比较这些设计,其历史实现不能代表今天所有部署;固定版本研究是将原理重新落到真实代码的办法。

流计算与RPC案例把前面的工具放进新组合。流计算需要使计算状态、输入位置和输出提交对应,不能把单次消息去重等同于端到端语义;RPC则需要发现服务、编码请求、关联响应并处理异步结果。课程最后的知识体系建议也要求这种横向连接:能解释共通问题,才可能把经验迁移到陌生系统。

发散与实践

读者延伸:优先从固定Kafka版本追聚批、日志与明文/TLS传输,从固定RocketMQ版本追半消息、二阶段确认和回查。首轮已实际读取相关代码段并保存可复核材料,两层阅读计划将未读链路明确留下,而不冒充完整源码理解。第三项实践用隔离的模拟状态检查幂等窗口,安排同ID重放、并发先查后改和故障后重试。

对应计划和首轮材料入口在概览的实践进度中。尚未完整运行测试、部署集群或执行真实账户操作;表中的未来验证条件不等于已经获得的效果。

生成进度与管理记录

消息队列高手课

Skill 版本:v23

本次实际使用规则:book-workflow v4 / book-notes v23,2026-10-24。

执行模式:light

建档进度:done

四象限结论:工程实践(高信息浓度 + 较低稳定性)

理由:课程持续解释可靠性、幂等、异步、锁、缓存与复制的原因和权衡,信息浓度高;但主要论证依托具体时期Kafka/RocketMQ/Flink/Java/Go实现、产品选型与API,部分市场、协议与内核描述已有时点或简化边界。因此原理可长期迁移,整门课程作为工程实现教材仍需按版本核对,定为工程实践。

内容形态:问题思考型。多数讲围绕具体问题、分析、方案与取舍组织;概念解释、代码结构和局部操作按实际内容分别保留。

书籍身份:目录“消息队列高手课”沿用既有身份;OPF标题“消息队列高手课[更新完毕]”是同一本课程汇编。作者由讲师介绍及开篇自述交叉确认为李玥;OPF网站creator与0101年日期不作为真实作者/出版时间,其他未知出版字段为null。

整书笔记:_book_note.md;阅读与取舍见_coverage.md。原书35讲、开篇/预习/JMQ加餐/测试图题/结束语等按实际225spine计划处理,分片不是新造的讲号。

章节进度追踪表

章节号 章节标题 状态(pending/done) 卡片数
00 简介 · 课程介绍(intro-s03) done 0
00 简介 · 模块介绍(intro-s04) done 0
00 开篇词-优秀的程序员,你的技术栈中不能只有“增删改查”(opening-s00) done 0
00 开篇词-优秀的程序员,你的技术栈中不能只有“增删改查” · 底层技术知识,给你深入解决业务问题的能力(opening-s01) done 1
00 开篇词-优秀的程序员,你的技术栈中不能只有“增删改查” · 课程设置(opening-s02) done 0
00 开篇词-优秀的程序员,你的技术栈中不能只有“增删改查” · 写在最后(opening-s03) done 0
00 预习-怎样更好地学习这门课?(prep-s00) done 0
00 预习-怎样更好地学习这门课? · 哪些人适合学消息队列?(prep-s01) done 0
00 预习-怎样更好地学习这门课? · 学习消息队列,有哪些门槛?(prep-s02) done 0
00 预习-怎样更好地学习这门课? · 由浅入深学习消息队列(prep-s03) done 1
00 预习-怎样更好地学习这门课? · 一份知识图谱(prep-s04) done 0
00 预习-怎样更好地学习这门课? · 学习资源推荐(prep-s05) done 1
01 01-为什么需要消息队列?(ch01-s00) done 1
01 01-为什么需要消息队列? · 哪些问题适合使用消息队列来解决?(ch01-s01) done 4
01 01-为什么需要消息队列? · 小结(ch01-s02) done 1
01 01-为什么需要消息队列? · 思考题(ch01-s03) done 0
02 02-该如何选择消息队列?(ch02-s00) done 1
02 02-该如何选择消息队列? · 选择消息队列产品的基本标准(ch02-s01) done 1
02 02-该如何选择消息队列? · 可供选择的消息队列产品(ch02-s02) done 3
02 02-该如何选择消息队列? · 第二梯队的消息队列(ch02-s03) done 2
02 02-该如何选择消息队列? · 总结(ch02-s04) done 0
02 02-该如何选择消息队列? · 思考题(ch02-s05) done 0
03 03-消息模型:主题和队列有什么区别?(ch03-s00) done 0
03 03-消息模型:主题和队列有什么区别? · 主题和队列有什么区别?(ch03-s01) done 2
03 03-消息模型:主题和队列有什么区别? · RabbitMQ的消息模型(ch03-s02) done 1
03 03-消息模型:主题和队列有什么区别? · RocketMQ的消息模型(ch03-s03) done 3
03 03-消息模型:主题和队列有什么区别? · Kafka的消息模型(ch03-s04) done 0
03 03-消息模型:主题和队列有什么区别? · 小结(ch03-s05) done 1
03 03-消息模型:主题和队列有什么区别? · 思考题(ch03-s06) done 0
04 04-如何利用事务消息实现分布式事务?(ch04-s00) done 1
04 04-如何利用事务消息实现分布式事务? · 什么是分布式事务?(ch04-s01) done 1
04 04-如何利用事务消息实现分布式事务? · 消息队列是如何实现分布式事务的?(ch04-s02) done 1
04 04-如何利用事务消息实现分布式事务? · RocketMQ中的分布式事务实现(ch04-s03) done 1
04 04-如何利用事务消息实现分布式事务? · 小结(ch04-s04) done 0
04 04-如何利用事务消息实现分布式事务? · 思考题(ch04-s05) done 0
05 05-如何确保消息不会丢失?(ch05-s00) done 0
05 05-如何确保消息不会丢失? · 检测消息丢失的方法(ch05-s01) done 1
05 05-如何确保消息不会丢失? · 确保消息可靠传递(ch05-s02) done 3
05 05-如何确保消息不会丢失? · 小结(ch05-s03) done 0
05 05-如何确保消息不会丢失? · 思考题(ch05-s04) done 0
06 06-如何处理消费过程中的重复消息?(ch06-s00) done 0
06 06-如何处理消费过程中的重复消息? · 消息重复的情况必然存在(ch06-s01) done 1
06 06-如何处理消费过程中的重复消息? · 用幂等性解决重复消息问题(ch06-s02) done 6
06 06-如何处理消费过程中的重复消息? · 小结(ch06-s03) done 0
06 06-如何处理消费过程中的重复消息? · 思考题(ch06-s04) done 0
07 07-消息积压了该如何处理?(ch07-s00) done 0
07 07-消息积压了该如何处理? · 优化性能来避免消息积压(ch07-s01) done 3
07 07-消息积压了该如何处理? · 消息积压了该如何处理?(ch07-s02) done 1
07 07-消息积压了该如何处理? · 小结(ch07-s03) done 0
07 07-消息积压了该如何处理? · 思考题(ch07-s04) done 0
08 08-答疑解惑(一)-网关如何接收服务端的秒杀结果?(ch08-s00) done 0
08 08-答疑解惑(一)-网关如何接收服务端的秒杀结果? · 1. 网关如何接收服务端的秒杀结果?(ch08-s01) done 1
08 08-答疑解惑(一)-网关如何接收服务端的秒杀结果? · 2. 详解RocketMQ和Kafka的消息模型(ch08-s02) done 1
08 08-答疑解惑(一)-网关如何接收服务端的秒杀结果? · 3. 如何实现单个队列的并行消费?(ch08-s03) done 1
08 08-答疑解惑(一)-网关如何接收服务端的秒杀结果? · 4. 如何保证消息的严格顺序?(ch08-s04) done 1
08 08-答疑解惑(一)-网关如何接收服务端的秒杀结果? · 写在最后(ch08-s05) done 0
09 09-学习开源代码该如何入手?(ch09-s00) done 0
09 09-学习开源代码该如何入手? · 通过文档来了解开源项目(ch09-s01) done 1
09 09-学习开源代码该如何入手? · 用以点带面的方式来阅读源码(ch09-s02) done 2
09 09-学习开源代码该如何入手? · 小结(ch09-s03) done 0
09 09-学习开源代码该如何入手? · 思考题(ch09-s04) done 0
10 10-如何使用异步设计提升系统性能?(ch10-s00) done 0
10 10-如何使用异步设计提升系统性能? · 异步设计如何提升系统性能?(ch10-s01) done 1
10 10-如何使用异步设计提升系统性能? · 简单实用的异步框架: CompletableFuture(ch10-s02) done 1
10 10-如何使用异步设计提升系统性能? · 小结(ch10-s03) done 1
10 10-如何使用异步设计提升系统性能? · 思考题(ch10-s04) done 0
11 11-如何实现高性能的异步网络传输?(ch11-s00) done 1
11 11-如何实现高性能的异步网络传输? · 理想的异步网络框架应该是什么样的?(ch11-s01) done 1
11 11-如何实现高性能的异步网络传输? · 使用Netty来实现异步网络通信(ch11-s02) done 1
11 11-如何实现高性能的异步网络传输? · 使用NIO来实现异步网络通信(ch11-s03) done 1
11 11-如何实现高性能的异步网络传输? · 小结(ch11-s04) done 0
11 11-如何实现高性能的异步网络传输? · 思考题(ch11-s05) done 0
12 12-序列化与反序列化:如何通过网络传输结构化的数据?(ch12-s00) done 1
12 12-序列化与反序列化:如何通过网络传输结构化的数据? · 你该选择哪种序列化实现?(ch12-s01) done 2
12 12-序列化与反序列化:如何通过网络传输结构化的数据? · 实现高性能的序列化和反序列化(ch12-s02) done 1
12 12-序列化与反序列化:如何通过网络传输结构化的数据? · 小结(ch12-s03) done 0
12 12-序列化与反序列化:如何通过网络传输结构化的数据? · 思考题(ch12-s04) done 0
13 13-传输协议:应用程序之间对话的语言(ch13-s00) done 1
13 13-传输协议:应用程序之间对话的语言 · 如何“断句”?(ch13-s01) done 1
13 13-传输协议:应用程序之间对话的语言 · 用双工收发协议提升吞吐量(ch13-s02) done 1
13 13-传输协议:应用程序之间对话的语言 · 小结(ch13-s03) done 0
13 13-传输协议:应用程序之间对话的语言 · 思考题(ch13-s04) done 0
14 14-内存管理:如何避免内存溢出和频繁的垃圾回收?(ch14-s00) done 0
14 14-内存管理:如何避免内存溢出和频繁的垃圾回收? · 自动内存管理机制的实现原理(ch14-s01) done 2
14 14-内存管理:如何避免内存溢出和频繁的垃圾回收? · 为什么在高并发下程序会卡死?(ch14-s02) done 1
14 14-内存管理:如何避免内存溢出和频繁的垃圾回收? · 高并发下的内存管理技巧(ch14-s03) done 1
14 14-内存管理:如何避免内存溢出和频繁的垃圾回收? · 小结(ch14-s04) done 0
14 14-内存管理:如何避免内存溢出和频繁的垃圾回收? · 思考题(ch14-s05) done 0
00 加餐-JMQ的Broker是如何异步处理消息的?(jmq-extra-s00) done 0
00 加餐-JMQ的Broker是如何异步处理消息的? · JMQ的Broker是如何异步处理消息的?(jmq-extra-s01) done 2
00 加餐-JMQ的Broker是如何异步处理消息的? · 俩大爷的思考题(jmq-extra-s02) done 1
00 加餐-JMQ的Broker是如何异步处理消息的? · 思考题(jmq-extra-s03) done 0
15 15-Kafka如何实现高性能IO?(ch15-s00) done 0
15 15-Kafka如何实现高性能IO? · 使用批量消息提升服务端处理能力(ch15-s01) done 1
15 15-Kafka如何实现高性能IO? · 使用顺序读写提升磁盘IO性能(ch15-s02) done 1
15 15-Kafka如何实现高性能IO? · 利用PageCache加速消息读写(ch15-s03) done 1
15 15-Kafka如何实现高性能IO? · ZeroCopy:零拷贝技术(ch15-s04) done 1
15 15-Kafka如何实现高性能IO? · 小结(ch15-s05) done 0
15 15-Kafka如何实现高性能IO? · 思考题(ch15-s06) done 0
16 16-缓存策略:如何使用缓存来减少磁盘IO?(ch16-s00) done 1
16 16-缓存策略:如何使用缓存来减少磁盘IO? · 选择只读缓存还是读写缓存?(ch16-s01) done 1
16 16-缓存策略:如何使用缓存来减少磁盘IO? · 保持缓存数据新鲜(ch16-s02) done 2
16 16-缓存策略:如何使用缓存来减少磁盘IO? · 缓存置换策略(ch16-s03) done 2
16 16-缓存策略:如何使用缓存来减少磁盘IO? · 小结(ch16-s04) done 0
16 16-缓存策略:如何使用缓存来减少磁盘IO? · 思考题(ch16-s05) done 1
17 17-如何正确使用锁保护共享数据,协调异步线程? / 共享资源与锁(ch17-s00) done 1
17 17-如何正确使用锁保护共享数据,协调异步线程? / 避免滥用锁(ch17-s01) done 1
17 17-如何正确使用锁保护共享数据,协调异步线程? / 锁的用法(ch17-s02) done 1
17 17-如何正确使用锁保护共享数据,协调异步线程? / 如何避免死锁?(ch17-s03) done 2
17 17-如何正确使用锁保护共享数据,协调异步线程? / 使用读写锁要兼顾性能和安全性(ch17-s04) done 1
17 17-如何正确使用锁保护共享数据,协调异步线程? / 小结(ch17-s05) done 0
17 17-如何正确使用锁保护共享数据,协调异步线程? / 思考题(ch17-s06) done 0
18 18-如何用硬件同步原语(CAS)替代锁? / 引入CAS(ch18-s00) done 1
18 18-如何用硬件同步原语(CAS)替代锁? / 什么是硬件同步原语?(ch18-s01) done 2
18 18-如何用硬件同步原语(CAS)替代锁? / CAS版本的账户服务(ch18-s02) done 4
18 18-如何用硬件同步原语(CAS)替代锁? / 小结(ch18-s03) done 0
18 18-如何用硬件同步原语(CAS)替代锁? / 思考题(ch18-s04) done 0
19 19-数据压缩:时间换空间的游戏 / 压缩与吞吐(ch19-s00) done 1
19 19-数据压缩:时间换空间的游戏 / 什么情况适合使用数据压缩?(ch19-s01) done 1
19 19-数据压缩:时间换空间的游戏 / 应该选择什么压缩算法?(ch19-s02) done 1
19 19-数据压缩:时间换空间的游戏 / 如何选择合适的压缩分段?(ch19-s03) done 1
19 19-数据压缩:时间换空间的游戏 / Kafka是如何处理消息压缩的?(ch19-s04) done 1
19 19-数据压缩:时间换空间的游戏 / 小结(ch19-s05) done 0
19 19-数据压缩:时间换空间的游戏 / 思考题(ch19-s06) done 0
20 20-RocketMQProducer源码分析:消息生产的实现过程 / 正文片段133(ch20-s00) done 0
20 20-RocketMQProducer源码分析:消息生产的实现过程 / 从单元测试看Producer API的使用(ch20-s01) done 2
20 20-RocketMQProducer源码分析:消息生产的实现过程 / 启动过程(ch20-s02) done 4
20 20-RocketMQProducer源码分析:消息生产的实现过程 / 消息发送过程(ch20-s03) done 3
20 20-RocketMQProducer源码分析:消息生产的实现过程 / 小结(ch20-s04) done 0
20 20-RocketMQProducer源码分析:消息生产的实现过程 / 思考题(ch20-s05) done 0
21 21-KafkaConsumer源码分析:消息消费的实现过程 / 正文片段139(ch21-s00) done 1
21 21-KafkaConsumer源码分析:消息消费的实现过程 / 订阅过程如何实现?(ch21-s01) done 2
21 21-KafkaConsumer源码分析:消息消费的实现过程 / 拉取消息的过程如何实现?(ch21-s02) done 2
21 21-KafkaConsumer源码分析:消息消费的实现过程 / 小结(ch21-s03) done 1
21 21-KafkaConsumer源码分析:消息消费的实现过程 / 思考题(ch21-s04) done 0
22 22-Kafka和RocketMQ的消息复制实现的差异点在哪? / 正文片段144(ch22-s00) done 0
22 22-Kafka和RocketMQ的消息复制实现的差异点在哪? / 消息复制面临什么问题?(ch22-s01) done 2
22 22-Kafka和RocketMQ的消息复制实现的差异点在哪? / RocketMQ如何实现复制?(ch22-s02) done 2
22 22-Kafka和RocketMQ的消息复制实现的差异点在哪? / Kafka是如何实现复制的?(ch22-s03) done 1
22 22-Kafka和RocketMQ的消息复制实现的差异点在哪? / 总结(ch22-s04) done 0
22 22-Kafka和RocketMQ的消息复制实现的差异点在哪? / 思考题(ch22-s05) done 0
23 23-RocketMQ客户端如何在集群中找到正确的节点? / 正文片段150(ch23-s00) done 1
23 23-RocketMQ客户端如何在集群中找到正确的节点? / NameServer是如何提供服务的?(ch23-s01) done 1
23 23-RocketMQ客户端如何在集群中找到正确的节点? / NameServer的总体结构(ch23-s02) done 1
23 23-RocketMQ客户端如何在集群中找到正确的节点? / NameServer如何处理Broker注册的路由信息?(ch23-s03) done 1
23 23-RocketMQ客户端如何在集群中找到正确的节点? / 客户端如何寻找Broker?(ch23-s04) done 1
23 23-RocketMQ客户端如何在集群中找到正确的节点? / 小结(ch23-s05) done 0
23 23-RocketMQ客户端如何在集群中找到正确的节点? / 思考题(ch23-s06) done 0
24 24-Kafka的协调服务ZooKeeper:实现分布式系统的“瑞士军刀” / 正文片段157(ch24-s00) done 0
24 24-Kafka的协调服务ZooKeeper:实现分布式系统的“瑞士军刀” / ZooKeeper的作用是什么?(ch24-s01) done 2
24 24-Kafka的协调服务ZooKeeper:实现分布式系统的“瑞士军刀” / Kafka在ZooKeeper中保存了哪些信息?(ch24-s02) done 1
24 24-Kafka的协调服务ZooKeeper:实现分布式系统的“瑞士军刀” / Kafka客户端如何找到对应的Broker?(ch24-s03) done 1
24 24-Kafka的协调服务ZooKeeper:实现分布式系统的“瑞士军刀” / 小结(ch24-s04) done 1
24 24-Kafka的协调服务ZooKeeper:实现分布式系统的“瑞士军刀” / 思考题(ch24-s05) done 0
25 25-RocketMQ与Kafka中如何实现事务? / 正文片段163(ch25-s00) done 0
25 25-RocketMQ与Kafka中如何实现事务? / RocketMQ的事务是如何实现的?(ch25-s01) done 3
25 25-RocketMQ与Kafka中如何实现事务? / Kafka的事务和Exactly Once可以解决什么问题?(ch25-s02) done 2
25 25-RocketMQ与Kafka中如何实现事务? / Kafka的事务是如何实现的?(ch25-s03) done 2
25 25-RocketMQ与Kafka中如何实现事务? / 小结(ch25-s04) done 0
25 25-RocketMQ与Kafka中如何实现事务? / 思考题(ch25-s05) done 0
26 26-MQTT协议:如何支持海量的在线IoT设备? / 正文片段169(ch26-s00) done 1
26 26-MQTT协议:如何支持海量的在线IoT设备? / MQTT和其他消息队列的传输协议有什么不同?(ch26-s01) done 1
26 26-MQTT协议:如何支持海量的在线IoT设备? / 如何选择MQTT产品?(ch26-s02) done 1
26 26-MQTT协议:如何支持海量的在线IoT设备? / MQTT集群如何支持海量在线的IoT设备?(ch26-s03) done 3
26 26-MQTT协议:如何支持海量的在线IoT设备? / 总结(ch26-s04) done 0
26 26-MQTT协议:如何支持海量的在线IoT设备? / 思考题(ch26-s05) done 0
27 27-Pulsar的存储计算分离设计:全新的消息队列设计思路 / 正文片段175(ch27-s00) done 0
27 27-Pulsar的存储计算分离设计:全新的消息队列设计思路 / Pulsar的架构和其他消息队列有什么不同?(ch27-s01) done 3
27 27-Pulsar的存储计算分离设计:全新的消息队列设计思路 / 存储计算分离的设计有哪些优点?(ch27-s02) done 2
27 27-Pulsar的存储计算分离设计:全新的消息队列设计思路 / 小结(ch27-s03) done 0
27 27-Pulsar的存储计算分离设计:全新的消息队列设计思路 / 思考题(ch27-s04) done 0
28 28-答疑解惑(二):我的100元哪儿去了? / 正文片段180(ch28-s00) done 0
28 28-答疑解惑(二):我的100元哪儿去了? / 1. 我的100元哪儿去了?聊聊并发调用情况下的幂等性(ch28-s01) done 2
28 28-答疑解惑(二):我的100元哪儿去了? / 2. Kafka和RocketMQ如何通过选举来产生新的Leader?(ch28-s02) done 2
28 28-答疑解惑(二):我的100元哪儿去了? / 3. 为什么说Pulsar存储计算分离的架构是未来消息队列的发展方向?(ch28-s03) done 1
29 29-流计算与消息(一):通过Flink理解流计算的原理 / 正文片段184(ch29-s00) done 0
29 29-流计算与消息(一):通过Flink理解流计算的原理 / 哪些问题适合用流计算解决?(ch29-s01) done 1
29 29-流计算与消息(一):通过Flink理解流计算的原理 / 用代码定义Job并在Flink中执行(ch29-s02) done 2
29 29-流计算与消息(一):通过Flink理解流计算的原理 / Job是如何在Flink集群中执行的?(ch29-s03) done 2
29 29-流计算与消息(一):通过Flink理解流计算的原理 / 小结(ch29-s04) done 1
29 29-流计算与消息(一):通过Flink理解流计算的原理 / 思考题(ch29-s05) done 0
30 30-流计算与消息(二):在流计算中使用Kafka链接计算任务 / 正文片段190(ch30-s00) done 1
30 30-流计算与消息(二):在流计算中使用Kafka链接计算任务 / Flink是如何保证Exactly Once语义的?(ch30-s01) done 2
30 30-流计算与消息(二):在流计算中使用Kafka链接计算任务 / Kafka如何配合Flink实现端到端Exactly Once?(ch30-s02) done 2
30 30-流计算与消息(二):在流计算中使用Kafka链接计算任务 / Exactly Once版本的Web请求的统计(ch30-s03) done 2
30 30-流计算与消息(二):在流计算中使用Kafka链接计算任务 / 小结(ch30-s04) done 0
30 30-流计算与消息(二):在流计算中使用Kafka链接计算任务 / 思考题(ch30-s05) done 0
31 31-动手实现一个简单的RPC框架(一):原理和程序的结构 / 正文片段196(ch31-s00) done 0
31 31-动手实现一个简单的RPC框架(一):原理和程序的结构 / RPC框架是怎么调用远程服务的?(ch31-s01) done 2
31 31-动手实现一个简单的RPC框架(一):原理和程序的结构 / RPC框架的总体结构是什么样的?(ch31-s02) done 1
31 31-动手实现一个简单的RPC框架(一):原理和程序的结构 / 小结(ch31-s03) done 0
31 31-动手实现一个简单的RPC框架(一):原理和程序的结构 / 思考题(ch31-s04) done 0
32 32-动手实现一个简单的RPC框架(二):通信与序列化 / 正文片段201(ch32-s00) done 0
32 32-动手实现一个简单的RPC框架(二):通信与序列化 / 如何设计一个通用的高性能序列化实现?(ch32-s01) done 3
32 32-动手实现一个简单的RPC框架(二):通信与序列化 / 使用Netty来实现异步网络通信(ch32-s02) done 5
32 32-动手实现一个简单的RPC框架(二):通信与序列化 / 小结(ch32-s03) done 0
32 32-动手实现一个简单的RPC框架(二):通信与序列化 / 思考题(ch32-s04) done 0
33 33-动手实现一个简单的RPC框架(三):客户端 / 正文片段206(ch33-s00) done 0
33 33-动手实现一个简单的RPC框架(三):客户端 / 如何来动态地生成桩?(ch33-s01) done 3
33 33-动手实现一个简单的RPC框架(三):客户端 / 使用依赖倒置原则解耦调用者和实现(ch33-s02) done 2
33 33-动手实现一个简单的RPC框架(三):客户端 / 小结(ch33-s03) done 0
33 33-动手实现一个简单的RPC框架(三):客户端 / 思考题(ch33-s04) done 0
34 34-动手实现一个简单的RPC框架(四):服务端 / 正文片段211(ch34-s00) done 0
34 34-动手实现一个简单的RPC框架(四):服务端 / 注册中心是如何实现的?(ch34-s01) done 2
34 34-动手实现一个简单的RPC框架(四):服务端 / RPC服务是怎么实现的?(ch34-s02) done 2
34 34-动手实现一个简单的RPC框架(四):服务端 / 小结(ch34-s03) done 0
34 34-动手实现一个简单的RPC框架(四):服务端 / 思考题(ch34-s04) done 0
35 35-答疑解惑(三):主流消息队列都是如何存储消息的? / 正文片段216(ch35-s00) done 0
35 35-答疑解惑(三):主流消息队列都是如何存储消息的? / 1. 主流消息队列都是如何存储消息的?(ch35-s01) done 4
35 35-答疑解惑(三):主流消息队列都是如何存储消息的? / 2. 流计算与批计算的区别是什么?(ch35-s02) done 1
35 35-答疑解惑(三):主流消息队列都是如何存储消息的? / 3. RPC框架的JDBC注册中心(ch35-s03) done 1
35 35-答疑解惑(三):主流消息队列都是如何存储消息的? / 4. 完成作业的最佳姿势(ch35-s04) done 1
35 35-答疑解惑(三):主流消息队列都是如何存储消息的? / 总结(ch35-s05) done 0
91 期中测试丨10个消息队列热点问题自测(ch91-midterm) done 0
90 结束语-程序员如何构建知识体系?(ch90-ending) done 2
91 第二季回归丨这次我们一起实战后端存储(ch91-supplement) done 0

非正文排除

spine项 类型 排除理由
1 titlepage.xhtml 封面 讲师肖像封面,无教学正文;SVG引用cover.jpeg已实际查看
2 text/part0000.html 目录 纯课程链接目录;已用于核对35讲和其他正文顺序
3 text/part0001_split_000.html 优惠广告 价格与拼团活动,无实质教学内容
4 text/part0001_split_001.html 课程收益宣传 列举学习收益,未展开概念与方法
5 text/part0001_split_002.html 讲师简介 作者身份背景用于出版元数据
8 text/part0001_split_005.html 课程目录图 只列课程导航,实际spine计划已完整记录
9 text/part0001_split_006.html 活动广告 邀请奖励、充值和社群宣传
10 text/part0001_split_007.html 订阅条款 订购价格、退款与平台使用规则
223 text/part0041.html 平台答题入口 期末页说明含5道单选和5道多选,要求进入答题系统,但EPUB仅存入口按钮,没有实际题干或解析。

待关联术语

术语名 出现章节 一句话语境
UML / 设计模式 00 学习前置知识清单,未逐项教学。
JMS / AMQP / OpenMessaging 00 消息协议地图,仅列名称,未在此解释机制。
Scala / Erlang 00 实现语言地图,未介绍语言语义。
Erlang 02 RabbitMQ维护技能背景,未展开语言机制。
2PC / TCC 04 分布式事务可选路径,仅说明不在本讲展开。
SETNX 06 作为条件插入替代示例,没有解释Redis可靠性边界。
RxJava 10 异步框架选择中提名,未展开其模型。
Flink自管内存 14 作者提及历史实现评价,具体机制待后续课程。
哈夫曼编码 19 作为压缩原理的自学建议,未展开编码算法
弹性分布式集群 23 作为命名服务的应用背景,未展开伸缩调度
分布式锁 24 列为ZooKeeper可组合的用途,没有讲实现
一致性哈希 26 仅作为主题分片可选算法,未展开环与迁移机制
四层与七层负载均衡 26 列为接入选择,未解释协议分层
YARN 27 举例说明计算任务调度,未展开
Kubernetes 27 举例说明计算任务调度,未展开
Raft 28 仅说明Dledger采用的算法,未讲协议
Watermark 29 仅说明用于触发时间汇总,未展开乱序与水位线机制
Task Slot 29 作为课后自查对象,没有给出定义
allowedLateness 30 只出现示例API,未解释迟到数据策略
REST 31 用于对照本课透明RPC范围,未展开资源协议
IOC 33 只作为Spring代理应用背景,未展开机制
AOP 33 只作为Spring代理应用背景,未展开切面模型
Java反射 34 用于调用服务提供者方法,未展开反射底层
JDBC驱动 35 作为运行时配套依赖,未展开驱动实现

引用文献

标题 类型(书/论文/框架/源码项目) 出现章节 一句话语境
The Log: What every software engineer should know about real-time data’s unifying abstraction 论文 09 推荐作为理解Kafka日志思想的理论文章,未在本课阅读全文展开。
Confluo: Distributed Monitoring and Diagnosis Stack for High-speed Networks 论文 18 引出硬件原语并发写日志;文中对吞吐对比条件持保留意见
LZ4 框架 19 作为侧重速度的压缩实现例子
GZIP 框架 19 作为侧重压缩比的例子
XZ 框架 19 作为更高压缩比的例子
SNAPPY 框架 19 只列压缩算法名称
ZIP 框架 19 只列压缩格式/算法名称
Dubbo 框架 23 注册中心承担NamingService的类比
Nginx 源码项目 26 作为软件负载均衡选项
Tomcat 源码项目 26 会话放置策略的类比
Redis 源码项目 26 作为外置会话存储选项
MySQL 源码项目 26 作为外置会话存储选项
HDFS 源码项目 27 作为外置分布式存储例子
Kafka Streams 框架 28 作为消息队列扩展流计算的路线图例子
Pulsar Functions 框架 28 作为消息队列扩展流计算的路线图例子
Storm 框架 28 仅列流计算平台
gRPC 框架 31 举例说明IDL及跨语言RPC
simple-rpc-framework 源码项目 31 课程RPC示例项目,后续讲解其模块与实现
Protobuf 框架 32 通用序列化的举例,未展开其协议
Hessian2 框架 32 Dubbo支持的序列化举例,原文写hession2
Spring 框架 33 代理与依赖注入的背景例子
JavaStringCompiler 源码项目 33 示例调用动态编译工具,未展开实现
HSQLDB 源码项目 35 作为已有SQL与驱动示例
后端存储实战课 书 91 推广第二季以电商场景讲存储的课程

资金安全问题案例

问题标题 问题卡 解决方案卡(如有) 出现章节 一句话说明
重复加款 [[重复加款使余额多增]] [[唯一流水限定一次变更]] 06 重复投递叠加非幂等加法,以业务单号/账户唯一流水限定变更登记。
并发先查后改双加款 [[分离检查导致双重加款]] [[检查变更登记需要原子性]] 06 两个消费者都通过未处理检查造成重复副作用,须共同保护检查/业务/登记边界。
过期余额覆盖并发入账 [[过期余额覆盖并发入账]] [[CAS重试保护入账]]、[[余额累加优先FAA]] 18 单变量余额先读后写在竞争下覆盖;原子条件写或累加保护
旧余额请求覆盖新入账 [[旧余额请求覆盖新入账]] [[流水号约束余额更新]] 28 旧赋值请求重试覆盖后续300元结果;预期流水号原子更新拒绝旧请求

实践卡进度

序号 实践标题 实践方式 状态(pending/done) 关联章节 产出
1 Kafka批量与IO深读 实现深读 done 15、19 Kafka批量与IO深读;固定源码首轮材料和两层计划
2 RocketMQ事务消息深读 实现深读 done 04、25 RocketMQ事务消息深读;固定源码首轮材料和两层计划
3 幂等故障窗口模拟 真实任务 done 06、28 幂等故障窗口模拟;隔离模拟用例、时序与验证计划

实践候选筛选:done

优先执行Kafka批量/IO与RocketMQ事务实现深读,第三项为幂等窗口的有限模拟任务。未另选自研消息队列或完整RPC框架:现有成熟实现和课程代码可支持理解,完整重建超出当前问题需要;未选MQTT部署/流处理集群实验:先完成已有机制阅读,避免同时引入无关环境成本。两项研究已有真实官方代码相关段及文档材料,三卡交付均为计划,不代表现实实践执行。

本次生成说明

  • 全部225spine逐项核对,216正文项完整读取,9项有据排除;期中测试的10道题存在于图内,已实际读取,不将无解析题目补造成答案。
  • 194张新知识卡,3实践卡;所有知识卡唯一primary与真实来源。
  • 图片实际查看:封面及图片00001–00062(正文图、代码/表格、题目和按钮/品牌图),来源字节不改动。
  • 生成时已处理的已知简化/时点边界见 _work-v4-20261024/generation-boundaries.md,包括令牌桶、Selector、HTTP1、GC、事务和当前固定版本实现差异。
  • 轻量模式未执行笔记复核、独立审查及审查结果优化;没有新建全局主题或执行导入。

相关主题

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

暂无公开主题。