来源书籍

Go并发编程实战 (汪明)

Skill 版本:v23 198 张卡片

晁岳攀(正文课程讲师) · 极客时间

全书导读

实际输入是晁岳攀(鸟窝)的极客时间《Go并发编程实战课》20讲及开篇、结束语。文件名与OPF署名“汪明”不符,目录名保留用于追溯输入;OPF中的纸书ISBN与日期不绑定这份课程,出版日期、版次及ISBN明确未知。全文依据214个spine项,排除8项封面、营销、履历或纯导航,保留206项实质介绍、技术正文、归纳与思考题。

课程回答的是如何选择并正确组合并发原语,而非全面讲解Go调度器。许多源码处于Go1.15附近的历史背景,标准TryLock等有后来补注;实现布局、第三方API和服务路径按版本理解。生成时已核对公开契约和明确示例错误,未执行生成后的内容复核或独立审查。

全书主线

先把共享状态放入清楚的访问协议:Mutex保护临界区,RWMutex允许只读并发,WaitGroup确认任务完成,Cond等待业务谓词,Once发布一次初始化。接着用map、Pool和Context看到这些职责怎样组合进数据容器、复用及取消。原子操作和Channel把同步落实为小动作与通信,内存模型说明结果为何可见。最后扩展到许可、请求合并、分代会合、错误分组,以及跨节点选举、锁、队列和事务。

这些工具并非必然依次调用。选取工具的依据是要维护什么不变量、谁等待谁、谁负责结束、返回值表示什么;简单API也可能因为组合错误形成死锁、泄漏或虚假的完成判断。

flowchart TD
 A[确定共享状态或任务关系] --> B[选择保护 完成 通知或准入]
 B --> C[明确状态转换和退出责任]
 C --> D[检查同步顺序及失败边界]
 D --> E[按实际负载权衡成本]
 E --> A

S004 简介 / 课程介绍

课程介绍把难点分成原语选择、方案权衡、任务顺序、异常排查和工具组合;它解释为什么只会启动goroutine不等于能写好并发程序。这里先定问题范围,开篇的学习矩阵再给组织方法。

S005 简介 / 课程模块设计

课程分基本原语、原子操作、Channel、扩展原语和分布式原语五个模块。前几类处理进程内协作,后者借助etcd协调跨节点状态。模块设计说明学习地图,不把当时关于标准库扩充意向的评价当作现在的承诺。

S010 开篇词-想吃透Go并发编程,你得这样学!

开篇明确讲师是晁岳攀,网名鸟窝,所读对象为极客时间课程。这与当前文件名和OPF署名冲突,因而笔记保留输入目录身份,同时以正文确认实际讲师,其他冲突出版字段保持未知。

S011 开篇词-想吃透Go并发编程,你得这样学! / 并发编程,为什么选Go?

讲师从Go便于部署、工具链完整和goroutine/Channel的表达能力解释选用Go的经历,并介绍其rpcx和基础设施开发背景。这里提供课程经验来源;性能排名与企业采用情况属于当时叙述,不作为本次重新核验后的选型事实。

S012 开篇词-想吃透Go并发编程,你得这样学! / 学习Go并发编程,有哪些困难?

学习并发的困难既有不知道选哪个工具,也有时序不确定、错误难复现及已有原语不适配。这些问题引出后面的双主线学习法:同时建立工具广度和机制深度,不能只背一个最流行的用法。

S013 开篇词-想吃透Go并发编程,你得这样学! / 怎么提升Go并发编程能力?

并发工具应围绕共享资源保护、任务编排和消息传递来理解。先学基本用法,再追实现、误用与真实项目缺陷,才能说明为什么某场景选锁、Channel或组合原语。共享资源用锁、编排用Channel可作入门线索,不能替代对生命周期、等待关系和成本的具体判断。 深入机制与原文位置见按用途建立并发原语库。

原书依据 · 1 处

S014 01-Mutex:如何解决资源并发访问问题?

多个goroutine同时更新用户账户却没有互斥控制,可能使账户状态异常乃至透支;秒杀库存也可能超卖。课程在开篇列举这些具体后果,根因是共享更新未按临界区协调,并未展开完整支付流程或数据库隔离级别。此卡仅记录问题,不把通用例子扩写成真实线上事故。 深入机制与原文位置见账户并发更新缺少互斥会失真。

原书依据 · 1 处

S015 01-Mutex:如何解决资源并发访问问题? / 互斥锁的实现机制

临界区是对共享状态进行访问或修改、需要协调的一段操作。互斥锁使同一时刻只有一个持有者进入受保护范围;关键是把同一个不变量涉及的访问纳入同一协议,而不是单独给某个字段放一把锁。竞争者阻塞并不代表业务失败,只有取得锁后才继续访问。 深入机制与原文位置见临界区是保护的操作范围。

共享资源保护避免对同一数据的冲突访问,任务编排建立完成或先后关系,消息传递在执行单元间交流数据。这些责任可能组合,但不能互相冒充:等待任务结束不会自动保护同时自增的计数,给计数加锁也不会替主任务等待所有工作结束。 深入机制与原文位置见并发协调的三类责任。

将同一共享更新涉及的状态访问纳入临界区,并要求竞争者取得同一互斥锁后才能执行,可避免在这一进程内同时修改受保护资源。它针对课程列举的账户或库存并发访问问题提供通用保护思路,不能替代跨进程数据库事务、重试幂等和外部资金一致性协议。 深入机制与原文位置见共同临界区互斥保护更新。

原书依据 · 3 处

S016 01-Mutex:如何解决资源并发访问问题? / Mutex的基本使用方法

sync.Locker只要求Lock和Unlock两个无参数方法,*sync.Mutex通过方法集隐式实现它。接口便于把获取与释放这一契约交给协作者,但不会把所有锁的公平性、重入性和性能统一起来。具体选择仍需看实现及调用约定。 深入机制与原文位置见锁接口只约束操作契约。

count++包含读取、计算和回写。两个执行单元可能从同一旧值各算出相同新值,覆盖彼此更新;WaitGroup即使确认它们全已结束,也无法恢复被覆盖的计数。需要把读改写整体置于同步协议内,不能把示例输出恰好正确当作没有竞争。 深入机制与原文位置见自增不是原子动作。

race detector在编译时插入内存访问观测代码,在运行中查找缺少同步的冲突访问,可用go run -race或go test -race启用。报告中的访问位置和goroutine栈有助于定位;它只覆盖实际执行的路径和交互,无报告不能证明所有输入与调度都安全,并会增加运行成本。 深入机制与原文位置见竞态检测依赖实际执行。

计数器应把递增和读取方法都放进同一个互斥协议,避免调用者绕过锁直接读字段。Mutex零值可用,嵌入包含锁的结构体也无须额外初始化锁;匿名嵌入虽然便利,却可能暴露Lock等方法。封装的目的在于让受保护状态和访问规则保持一致。 深入机制与原文位置见把状态访问封装在锁内。

原书依据 · 4 处

S017 01-Mutex:如何解决资源并发访问问题? / 总结

互斥保护计数器的例子说明同步应覆盖共享读改写,race detector帮助发现实际执行中的冲突访问。后续增加功能可能把原本私有的状态变成共享,因而并发保护必须随访问方式变化。列出的Docker与Kubernetes编号留作文献线索。

S018 01-Mutex:如何解决资源并发访问问题? / 思考题

本节提出释放后哪个等待者先获得锁的问题,没有在这里给答案。下一讲通过新来者竞争、自旋及饥饿交接说明,不能简单假定所有Mutex请求严格先到先得。

S019 02-Mutex:庖丁解牛看实现

Mutex的演进按简单计数、允许新来者竞争、有限自旋、处理饥饿四步展开。后续源码不是四个必须同时调用的步骤,而是历史方案及其性能、公平性取舍。

S020 02-Mutex:庖丁解牛看实现 / 初版的互斥锁

历史Mutex以原子增减key记录持有者与等待者数量:增为1可直接进入,其余通过sema等待;释放后若仍有人等待,唤醒一个接手。它把状态竞争和阻塞机制分开,代码短,但严格交接可能增加调度成本。原文历史代码用来理解演进,不能当作现代Go内存模型下可直接复制的用户态实现。 深入机制与原文位置见初版锁用计数衔接睡眠。

Go的Mutex不记录所属goroutine,因此可以由另一个goroutine释放已锁住的锁。这样做必须属于明确设计的交接协议,否则原持有者继续访问时可能失去互斥保护。常规代码在同一作用域获取和释放更易审查;这是一条使用建议,并非API强制的所有者检查。 深入机制与原文位置见互斥锁不绑定执行者。

Lock后立即安排defer Unlock能减少分支漏释放;但defer延迟到函数返回,临界区若只占函数开头,可能让后续慢操作也持锁。应把操作封装成更小作用域或在正确位置显式释放,比较可维护性与持锁长度,不能一概把defer视为最早释放。 深入机制与原文位置见释放时机服从临界区。

原书依据 · 3 处

S021 02-Mutex:庖丁解牛看实现 / 给新人机会

历史改进版把锁状态、唤醒标记和等待人数压进state。被唤醒者仍要与正在运行的新请求竞争,而不是自动拥有锁;唤醒标记用来避免无谓地重复唤醒。这个设计减少立即交接的调度成本,却可能让队列中的等待者反复落败。 深入机制与原文位置见唤醒不等于已经拿到锁。

原书依据 · 1 处

S022 02-Mutex:庖丁解牛看实现 / 多给些机会

锁很快释放时,运行中的goroutine短暂自旋重试,可能比睡眠后再调度便宜。自旋也消耗CPU,因此实现按运行条件与次数决定是否继续,失败后仍需阻塞。它适合缩短短临界区的交接成本,不能让应用用无限忙循环替代所有等待。 深入机制与原文位置见有限自旋换取少量等待。

原书依据 · 1 处

S023 02-Mutex:庖丁解牛看实现 / 解决饥饿

课程所示Mutex把持锁、已唤醒、饥饿及等待者计数放进一个state,用CAS让检查和更新基于同一旧状态提交。多个标志的组合共同决定是否自旋、排队或交接;单看某一位可能误判。位布局是特定实现细节,不应由业务代码依赖。 深入机制与原文位置见状态位压缩协同更新。

原书依据 · 1 处

S024 02-Mutex:庖丁解牛看实现 / 饥饿模式和正常模式

课程所示Mutex正常模式允许新来者和被唤醒者竞争,提高运行中任务继续执行的机会;等待过久时切入饥饿模式,锁交给队首等待者,新来者排队。最后一位等待者或等待已缩短时回到正常模式。1毫秒是该实现的模式切换阈值,不是业务一定能在1毫秒内获得锁的时限保证。 深入机制与原文位置见饥饿模式直接交接锁。

Lock先以小段CAS处理无竞争成功,复杂的自旋、排队和公平性逻辑移入慢路径。这使常见路径便于内联,并把少见成本留在需要它的情形。拆方法的收益来自编译器与负载条件,不等于所有短函数都应机械拆出slow方法。 深入机制与原文位置见快路径为常见情况减负。

原书依据 · 2 处

S025 02-Mutex:庖丁解牛看实现 / 总结

Mutex从简单flag和信号量演变为自旋、公平性及饥饿处理,使用者仍通过锁的公开契约操作。这说明内部复杂度增长未必需要让调用方承受相同变化。稳定不表示接口永不增加功能:课程补注中的标准TryLock就是后来扩展,应区分既有契约兼容与方法集永久不变。 深入机制与原文位置见稳定接口允许内部演进。

原书依据 · 1 处

S026 02-Mutex:庖丁解牛看实现 / 思考题

思考题要求辨认state各部分和可表示等待者数量。它让读者回到前面的位布局推导,不构成新的公开API或业务并发数保证。

S027 03|Mutex:4种易错场景大盘点

本讲从正常用法转向失效路径,依次分析配对、复制、重入及资源等待环。简单接口也能因调用链或分支变化出错,后面的项目案例用于展示错误如何实际出现。

S028 03|Mutex:4种易错场景大盘点 / 常见的4种错误场景

四类错误是导航分类,具体触发机制在后续小节分别解释。配对错误影响释放义务,复制破坏同一协调对象,重入与锁序则改变等待依赖。

S029 03|Mutex:4种易错场景大盘点 / Lock/Unlock不是成对出现

锁取得后遗漏Unlock,会使后续请求一直等;对未锁定的Mutex调用Unlock则是严重误用,运行时会报错终止,不能依赖recover把它当作普通业务失败。分支和重构容易破坏配对,应在生成代码时核对所有取得锁后的退出路径。 深入机制与原文位置见漏释放与多释放后果不同。

原书依据 · 1 处

S030 03|Mutex:4种易错场景大盘点 / Copy已使用的Mutex

使用后的Mutex不能复制。按值传递包含锁的结构体会复制其内部状态,新的副本可能携带锁定标志,却没有正确的交接关系;两个副本也不再保护同一锁域。优先通过指针传递此类对象,并用go vet的copylocks分析帮助发现调用、赋值、返回或遍历中的复制。 深入机制与原文位置见复制锁会复制协调状态。

原书依据 · 1 处

S031 03|Mutex:4种易错场景大盘点 / 重入

同一goroutine已持有Mutex时再次调用Lock,会和其他竞争者一样等待,而它又无法走到原来的Unlock,造成自我等待。Go不记录锁所属goroutine,不能自动识别递归。把已加锁内部方法和外部加锁入口分清,比假设递归会被自动放行更可靠。 深入机制与原文位置见普通互斥锁不可重入。

可重入锁须识别同一个执行者,并记录递归深度:相同所有者再次进入只加深度,退出逐次减,到零才释放底层锁。课程分别用goroutine标识和显式token演示。前者依赖未公开的运行时信息;后者要求不同并发调用者不共用token,且不能使用代表空闲的零token。示例不能无条件拿来即用。 深入机制与原文位置见重入锁需要所有者和深度。

显式token把所有者身份交给调用方,Lock(token)和Unlock(token)已不同于Locker要求的无参数方法,因此并未实现原接口。它减少获取goroutine内部标识的依赖,却增加token唯一性、有效期和传递约束。多个goroutine共用同一token会被误判为重入,破坏互斥。 深入机制与原文位置见令牌重入改变接口边界。

原书依据 · 3 处

S032 03|Mutex:4种易错场景大盘点 / 死锁

多个执行单元各持有对方需要的资源并互相等待,可能形成无法推进的环。互斥、持有并等待、不可剥夺和循环等待是经典资源死锁的必要条件;破坏条件之一可消除这一类环。运行时全局死锁检查不能保证发现仍有其他活跃任务的局部死锁。 深入机制与原文位置见死锁是依赖无法推进。

证明办理示例中,派出所先拿自己的锁再要物业锁,物业反向申请,形成环路。协调入口统一串行办理,或去掉某个必须先持有资源的前提,才能使依赖可推进。仅延长等待时间或重复调度不会改变资源依赖;具体方案仍应权衡吞吐与业务办理规则。 深入机制与原文位置见打破等待环需要改协议。

原书依据 · 2 处

S033 03|Mutex:4种易错场景大盘点 / 流行的Go开发项目踩坑记

Docker案例中,持锁的hotAddVHDsAtStart再调用也加同一锁的hotRemoveVHDsAtStart,导致不可重入死锁。提供约定调用者已持锁的内部NoLock入口,可避免第二次加锁。外部入口仍负责保护状态,内部入口的调用前提必须清楚,不能把取消重复加锁变成取消所有保护。 深入机制与原文位置见已持锁方法分开内部入口。

Docker案例在发现非管理节点时新增提前返回,却遗漏c.mu释放。返回条件可能业务上完全正确,资源释放义务却仍然存在。重构和新增分支要检查取得锁后的每条退出路径;用同作用域的defer配对,可降低此类遗漏概率。 深入机制与原文位置见提前返回也要释放锁。

原书依据 · 2 处

S034 03|Mutex:4种易错场景大盘点 / Kubernetes

Kubernetes案例通过增加Mutex保护共享资源以修复data race。加锁的关键是让所有相关访问遵循相同协议;只在某个写点加一把别人不用的锁,不能消除并发访问。项目名气和既有测试都不能代替检查访问范围。 深入机制与原文位置见竞态修复先确定保护范围。

原书依据 · 1 处

S035 03|Mutex:4种易错场景大盘点 / gRPC

gRPC以远程过程调用方式连接服务,课程介绍其基于HTTP/2传输并使用Protocol Buffers描述接口。调用抽象能简化服务通信,但不能消除框架内部的锁误用:课程中Unlock误写成Lock的案例仍会造成等待。框架封装与本地状态正确性是不同责任。 深入机制与原文位置见远程调用框架的职责。

原书依据 · 1 处

S036 03|Mutex:4种易错场景大盘点 / etcd

etcd提供具有一致性语义的键值存储,可用于配置共享和服务发现。课程随后把它作为分布式选举、锁与队列的协调基础:各节点通过共享协调状态交流,而不是靠某进程内的一把Mutex。它承担的是协调数据的一致性,业务访问仍需遵循相应协议。 深入机制与原文位置见一致存储用于节点协调。

原书依据 · 1 处

S037 03|Mutex:4种易错场景大盘点 / issue 10419

etcd案例中Store持锁再进入同样请求锁的Compact,形成自我等待;提供不再加锁的内部Compact入口解决这一调用链问题。审查锁时应沿实际调用关系检查,而不能只看每个方法内部的Lock和Unlock是否成对。 深入机制与原文位置见跨层调用也会重复加锁。

原书依据 · 1 处

S038 03|Mutex:4种易错场景大盘点 / 总结

一组goroutine互相等待时,进程中其他任务仍能运行,Go的全局死锁检测未必报错。应结合业务流程未结束的现象、goroutine堆栈及阻塞剖析定位等待对象和代码位置。短期测试没有复现,也不能证明所有时序都无死锁。 深入机制与原文位置见局部死锁未必触发全局检测。

原书依据 · 1 处

S039 03|Mutex:4种易错场景大盘点 / 思考题

TiDB相关issue查找是留给读者的开放练习,没有给出可核验的问题分析或修复结论,因此不据此编造TiDB案例卡。

S040 04|Mutex:骇客编程,如何拓展额外功能?

试锁适用于工作允许稍后再做的情形,状态观测则服务于锁竞争诊断。这两类扩展分别回答是否取得锁和当前观测到什么,后续不能用状态查询替代真正取得锁。

S041 04|Mutex:骇客编程,如何拓展额外功能? / TryLock

TryLock非阻塞尝试获取锁,成功才进入临界区并承担Unlock义务;失败立即返回,适合本次工作允许放弃或延后的场景。失败不能据此读取受锁保护数据,也不能承诺以后必然成功。课程包含Go1.18已有标准TryLock的补注,实际使用应优先公开API。 深入机制与原文位置见试锁失败是未取得锁。

课程以unsafe读取Mutex首部并按位CAS演示扩展TryLock,依赖state所在偏移及标志含义。代码证明特定布局下可以组合状态判断,不提供跨版本稳定契约。已有公开TryLock时无须复制此技巧;即使CAS失败,也只表示这次未取得锁,不应据此推断完整竞争历史。 深入机制与原文位置见穿透私有锁布局有代价。

原书依据 · 2 处

S042 04|Mutex:骇客编程,如何拓展额外功能? / 获取等待者的数量等指标

通过atomic读取私有state可估算课程实现中的持有者、等待者、唤醒和饥饿状态,但这些指标在读取后就可能变化。分开调用多个查询也不是一致快照;Count示例还把持有者计入,不能直接解释为纯等待人数。适合作诊断线索,不能作为随后安全访问的授权。 深入机制与原文位置见锁状态观测只是瞬间值。

原书依据 · 1 处

S043 04|Mutex:骇客编程,如何拓展额外功能? / 使用Mutex实现一个线程安全的队列

SliceQueue以同一Mutex包围append入队和取首元素出队,让队列结构修改互斥。NewSliceQueue(n)只预留容量,并不限制最多元素;空队列返回nil也无法区分存储的nil值。结构线程安全不代表元素对象可任意并发修改,接口语义仍须按业务需要设计。 深入机制与原文位置见锁包装队列保护结构修改。

原书依据 · 1 处

S044 04|Mutex:骇客编程,如何拓展额外功能? / 总结

扩展章节将TryLock、私有state诊断和锁包装队列放在一起,说明可组合已有原语。前两者的unsafe实现依赖布局,后一种通过公开Lock/Unlock组织业务访问,兼容边界不同。

S045 04|Mutex:骇客编程,如何拓展额外功能? / 思考题

为获取Mutex增加超时是开放思考题。这里没有完整实现或证明,不将超时等待自动等同于撤销一个可能稍后成功的获取。

S046 05|RWMutex:读写锁的实现原理及避坑指南

读写锁章节由读多写少场景引入:多个只读操作可以并发,写入仍须独占。它拓展上一讲单一Mutex的保护方式,是否减少成本仍取决于目标负载。

S047 05|RWMutex:读写锁的实现原理及避坑指南 / 什么是RWMutex?

RWMutex允许多个只读持有者并发访问,写者独占;读操作用RLock/RUnlock,修改用Lock/Unlock,零值可用。读多写少且读工作足够明显时值得评估,但锁内部计数也有成本,不能仅凭读写比例保证它一定快于Mutex。写者等待后还会阻止后来读者。 深入机制与原文位置见读写锁区分访问权限。

RLocker返回一个Locker,其Lock和Unlock分别调用同一RWMutex的RLock和RUnlock。它让只要求无参数锁接口的组件使用读锁语义,并没有创建一把独立锁。调用者仍须遵守受保护操作只读的条件,不能因接口名称统一就把它用于写入。 深入机制与原文位置见读锁适配器复用锁接口。

原书依据 · 2 处

S048 05|RWMutex:读写锁的实现原理及避坑指南 / RWMutex的实现原理

读优先让新读者继续进入,可能使写者长期等待;写优先在写者等待后阻止新读者,使既有读者结束后写者有机会推进。无显式优先级则交给具体排队机制,不能仅凭不区分读写就断言无饥饿。Go的RWMutex提供阻塞写者会挡住新读者这一约束。 深入机制与原文位置见读写优先级改变饥饿风险。

原书依据 · 1 处

S049 05|RWMutex:读写锁的实现原理及避坑指南 / RLock/RUnlock的实现

课程实现把readerCount变为负值以表示写者正在等待或持有锁;后来读者计数后阻塞。原来已取得读锁的读者继续执行,释放时递减readerWait,最后一位唤醒写者。写优先针对后来的请求,不会抢占既有读者,因此持读锁的慢操作也能拖延写者。 深入机制与原文位置见写者优先不赶走已有读者。

原书依据 · 1 处

S050 05|RWMutex:读写锁的实现原理及避坑指南 / Lock

课程RWMutex先通过内部Mutex串行化多个写者,再登记当前读者数量并等待既有读者释放。只有两层条件都满足,写者才能独占共享状态。释放时先恢复读者计数并唤醒被阻塞的读者,再释放内部写者锁;顺序是协调协议的一部分,不宜随意互换。 深入机制与原文位置见写锁分两层等待。

原书依据 · 2 处

S051 05|RWMutex:读写锁的实现原理及避坑指南 / Unlock

写者释放时,课程实现先恢复readerCount并唤醒被挡住的读者,再解开内部写者互斥锁。与获取时先锁内部Mutex再登记读者互为协议两端,改变顺序可能破坏对共享计数的保护。

这一部分与前面所述同一机制连续展开,补充定位见写锁分两层等待。

原书依据 · 2 处

S052 05|RWMutex:读写锁的实现原理及避坑指南 / RWMutex的3个踩坑点

RWMutex使用后包含互斥状态、读者计数及等待信息;复制产生一套不会随原对象释放而自动更新的状态。包含它的结构体同样要避免赋值、按值参数和返回造成的隐式复制。可用vet发现部分路径,但工具告警范围不能替代对象所有权设计。 深入机制与原文位置见读写锁也不能按值复制。

原书依据 · 1 处

S053 05|RWMutex:读写锁的实现原理及避坑指南 / 坑点2:重入导致死锁

持有RLock期间再调用Lock,写者要等所有已有读者退出,其中包括当前尚未释放的读锁;当前调用又等写锁返回才释放,于是互相等待。RWMutex不提供原子的读锁升级。若业务另行释放再获取写锁,中间状态可能已变化,必须重新检查条件。 深入机制与原文位置见读锁升级会等待自己。

同一调用链已持读锁,再次RLock看似只读并发,遇到等待的写者却会阻塞:写者等旧读者退出,旧读者等新读锁返回,新读锁又被写者挡住。因而不能把RWMutex当作可重入读锁。课程阶乘代码用于制造等待时序,其错误的阶乘基例不是数学实现参考。 深入机制与原文位置见递归读锁遇写者会死锁。

原书依据 · 2 处

S054 05|RWMutex:读写锁的实现原理及避坑指南 / 坑点3:释放未加锁的RWMutex

写锁用Unlock释放,读锁用RUnlock释放,二者不能混用。多加少解会留下未结束的持锁状态,多解或解错类型属于严重运行时误用。方法名只标出访问模式,不能自动确认当前执行者是否真的按约定取得了相应锁。 深入机制与原文位置见读写释放方法必须配对。

原书依据 · 1 处

S055 05|RWMutex:读写锁的实现原理及避坑指南 / 流行的Go开发项目中的坑

这一项是从机制讲解过渡到Docker和Kubernetes案例的引导,没有额外技术结论。后两项分别展示错误地用读锁保护写入,以及重复读锁与写者形成依赖环。

S056 05|RWMutex:读写锁的实现原理及避坑指南 / Docker

Docker修复案例在findNode后还会调用changeNodeState,整个范围包含修改,却只拿读锁。多个读锁可同时进入,因此这并不保护写入。决定锁类型要检查整个临界区及调用链的副作用,不能仅按开头一个查询方法命名推断只读。 深入机制与原文位置见读锁不能保护后续写入。

原书依据 · 1 处

S057 05|RWMutex:读写锁的实现原理及避坑指南 / Kubernetes

Kubernetes原始PR说明GetCPUSetOrDefault重复取得RLock,另有写者等待时形成读者依赖环;课程把内部调用概括为请求写锁并不准确。修复移除外层重复读锁,让内部访问入口自行协调。Get前缀不能替代检查锁调用关系,读锁递归也可能因写者优先而死锁。 深入机制与原文位置见查询封装可能藏写锁调用。

原书依据 · 1 处

S058 05|RWMutex:读写锁的实现原理及避坑指南 / 总结

总结建议先选可清楚说明正确性的保护,再按实际访问模式评估读写锁,并回顾不可复制、不可重入及释放配对。原文称读写问题即可毫不犹豫选RWMutex是较强建议,实际仍要验证收益。

S059 05|RWMutex:读写锁的实现原理及避坑指南 / 思考题

扩展读写锁的试锁和诊断指标是练习,不在这里提供新实现。公开TryLock已在课程补注中出现;直接解释私有位布局仍属版本依赖方案。

S060 06-WaitGroup:协同等待,任务编排利器

WaitGroup处理的是一个执行者等待一组任务完成,阻塞等待避免不断轮询。它建立完成检查点,与互斥锁保护临界区的责任不同,后面分别说明计数、等待者与复用边界。

S061 06-WaitGroup:协同等待,任务编排利器 / WaitGroup的基本用法

WaitGroup的Add(delta)调整未完成任务数,Done相当于Add(-1),Wait等待计数归零。Add是增量而不是给计数器赋值;通常在启动worker前登记任务,并在worker结束路径Done。它确认的是约定的任务完成点,不收集错误,也不自动取消其他任务。 深入机制与原文位置见任务计数归零才结束等待。

原书依据 · 1 处

S062 06-WaitGroup:协同等待,任务编排利器 / WaitGroup的实现

课程旧WaitGroup把任务计数与调用Wait的等待者数放进同一64位状态,并用另一个信号量阻塞。Wait在任务数非零时登记自己,最后一次Done使计数归零并唤醒所有登记等待者。多个等待者并不增加工作任务,两个计数表达不同责任。 深入机制与原文位置见任务数与等待者数分开。

课程旧WaitGroup用三个uint32安排一个8字节对齐的64位状态和一个信号量,并根据地址选择前两个或后两个元素。这样避免32位平台上的64位原子访问不满足对齐约束。数组布局是历史实现技巧,现代typed atomic和WaitGroup布局须按所用版本另查,不能凭旧数组偏移读取状态。 深入机制与原文位置见原子状态需要满足对齐。

原书依据 · 2 处

S063 06-WaitGroup:协同等待,任务编排利器 / 使用WaitGroup时的常见错误

若把初次Add(1)放在worker里,主任务可能先看到计数为零,Wait立即返回,随后worker才登记。应在启动worker前完成该轮初始任务登记。规则要结合计数状态理解:非零期间可按契约追加任务,并非所有Add与Wait的重叠都违法。 深入机制与原文位置见任务登记必须早于零值等待。

WaitGroup计数不能降到负数,重复Done或减得过多会panic;少Done则可能让Wait永久等待。为每个登记的任务指定唯一完成路径,常在worker开始后defer Done。它记录协议上的未完成数,不自动检查业务是否真正完成。 深入机制与原文位置见完成次数不能超过登记数。

旧一轮任务数刚降为零,已被唤醒的Wait调用可能尚未返回。此时马上Add开始新一轮,可能与旧等待者冲突并panic。复用须等上一轮所有Wait返回;若批次边界难协调,使用独立的新WaitGroup更清楚。 深入机制与原文位置见复用要等全部等待者返回。

原书依据 · 3 处

S064 06-WaitGroup:协同等待,任务编排利器 / noCopy:辅助vet检查

noCopy是带空Lock/Unlock方法的辅助类型,让vet的copylocks分析识别包含它的结构不能在使用后复制。它不提供实际互斥,也不阻止语言赋值。课程把内部命名字段说成使WaitGroup实现Locker并不准确:命名字段的方法不会提升给外部结构;分析器会识别内部含锁类字段。 深入机制与原文位置见禁复制标记服务静态分析。

原书依据 · 1 处

S065 06-WaitGroup:协同等待,任务编排利器 / 流行的Go开发项目中的坑

复制已使用的WaitGroup后,某个演示仍能打印Finished,但这不证明复制合法。正确性还要满足对象的使用约束与所有等待者的协议,不应把一次输出正确当作同步保证。静态检查和并发场景检查分别能发现不同类别的问题。 深入机制与原文位置见成功运行也可能违反锁契约。

原书依据 · 1 处

S066 06-WaitGroup:协同等待,任务编排利器 / 总结

总结用预先登记、完成配对、避免跨轮混用来降低误用风险。不传负数和不复用是简化使用的建议,API实际允许在契约范围内减量及复用;不能把建议改写为语言禁止。

S067 06-WaitGroup:协同等待,任务编排利器 / 思考题

查询WaitGroup计数是开放扩展题。任务未完成数量不同于调用Wait的等待者数量,直接读取内部状态还会依赖布局及瞬间值,不能据此判断未来不会再登记任务。

S068 07-Cond:条件变量的实现机制及避坑指南

容量有限队列的满与空会使不同操作等待,Cond围绕这些共享条件协调通知。本节先提出适用场景,后面再把业务谓词、关联锁和等待队列分开解释。

S069 07-Cond:条件变量的实现机制及避坑指南 / Go标准库的Cond

Cond用于等待可计算为真假的共享条件,例如队列非空或所有运动员就绪。它并不保存业务条件本身,只协调等待和通知;条件由调用方维护,并在同一锁协议下读取和更新。相比WaitGroup固定任务计数,它可以等待任意业务状态。 深入机制与原文位置见条件变量等待业务谓词。

原书依据 · 1 处

S070 07-Cond:条件变量的实现机制及避坑指南 / Cond的基本用法

Signal唤醒一个当前等待者,Broadcast唤醒全部;无人等待时不会为以后保存一份通知。调用通知方法不强制持有c.L,但修改条件仍须正确同步。Wait调用前必须持锁,返回后仍持锁;不要把通知时可不持锁误解成条件可以无锁读写。 深入机制与原文位置见通知粒度与持锁义务不同。

原书依据 · 1 处

S071 07-Cond:条件变量的实现机制及避坑指南 / Cond的实现原理

Cond.Wait先登记等待票号,再释放关联锁,随后阻塞;得到通知后重新取得同一锁才返回。先登记再解锁避免在两步之间遗漏通知,释放锁又让其他执行者有机会更新条件。唤醒和重新拿到锁是不同阶段。 深入机制与原文位置见等待先登记再释放条件锁。

原书依据 · 1 处

S072 07-Cond:条件变量的实现机制及避坑指南 / 使用Cond的2个常见错误

运动员每次ready加一都可能通知裁判,单次Wait返回并不能说明十人全部就绪。调用方应持锁循环检查谓词,不满足则继续Wait。Go的Cond不会无故返回,但真实通知仍可能对应尚不满足的条件,或条件在重新拿锁前已被其他执行者改变。 深入机制与原文位置见被唤醒只获得检查机会。

原书依据 · 1 处

S073 07-Cond:条件变量的实现机制及避坑指南 / 知名项目中Cond的使用

关闭Channel可以一次性广播,此后不能重新打开同一通道;Cond可以在条件反复变化时多次Broadcast,并支持单个Signal。课程说Channel只能支持其中一种,是针对简单单通道模式的比较,不是证明任意Channel组合都无法实现相同协议。选择取决于状态及生命周期复杂度。 深入机制与原文位置见可重复广播区别于关闭通道。

Kubernetes优先队列Pop在activeQ为空时循环Wait,同时检查closed。Add入队后广播,Close设置关闭状态后也广播,使空队列上的等待者能返回错误。只更新closed却不通知,等待者可能永远没有机会再次检查退出条件。 深入机制与原文位置见队列关闭必须唤醒等待者。

原书依据 · 2 处

S074 07-Cond:条件变量的实现机制及避坑指南 / 总结

WaitGroup等待登记的任务数归零,Cond等待调用方自己的谓词成立;后者还支持Signal、Broadcast及反复等待。百米赛跑能用两者表达,选择应先确认需要任务完成还是可变化业务条件。

S075 07-Cond:条件变量的实现机制及避坑指南 / 思考题

思考题让读者解释唤醒为何要复检,并尝试有界队列,没有给出额外答案。关键依据已在运动员和优先队列案例中展开,不把开放题补造成已执行实现。

S076 08-Once:一个简约而不简单的并发原语

包变量、init或main入口初始化把准备工作放在启动阶段,延迟初始化则到首次需要时才建立资源。后者可以避免不必要的启动成本,却须协调并发首次访问以及失败结果。sync.Once适合一次执行的发布;需要失败重试时应另定义协议,不能把调用一次与业务成功视为相同。 深入机制与原文位置见延迟初始化推迟资源成本。

原书依据 · 1 处

S077 08-Once:一个简约而不简单的并发原语 / Once的使用场景

同一Once的多个Do调用只执行一个函数,其他调用须等该次函数结束后才返回;传不同函数也不会使后来的函数执行。常把Once与结果字段封装,让访问入口先Do再读结果。并发竞争中哪次调用胜出不由go语句书写顺序保证。 深入机制与原文位置见一次执行仍须发布完成。

原书依据 · 1 处

S078 08-Once:一个简约而不简单的并发原语 / 如何实现一个Once?

先CAS把done从0改为1再执行f,只保证一个调用者进入f,不能保证其他调用者返回时f已结束。正确发布必须让竞争者等待初始化完成,课程用互斥慢路径、锁内双检和最后原子写done来实现。开始、完成和业务成功是三个不同事实。 深入机制与原文位置见占位标记不能代替初始化完成。

原书依据 · 1 处

S079 08-Once:一个简约而不简单的并发原语 / 使用Once可能出现的2种错误

Once.Do执行f时持有内部协调锁;f直接或间接再次调用同一个Once.Do,会等待自身初始化结束,导致死锁。避免在初始化依赖链中回到同一Once。不同对象的初始化若互相依赖,也要检查整个调用环,不能只搜索显式递归。 深入机制与原文位置见一次初始化函数不可回调自身。

原书依据 · 1 处

S080 08-Once:一个简约而不简单的并发原语 / 第二种错误:未初始化

sync.Once把f正常返回或panic都视为该次执行已发生,之后不重试。若f忽略网络错误得到nil连接,Do已返回也不能把连接当作可用。应保留并检查初始化的业务结果;一次动作的完成标记不同于资源成功建立。 深入机制与原文位置见执行一次不承诺初始化成功。

课程扩展Once让f返回error,在锁内执行并仅在err为nil时设置done;失败保留未完成状态,后来的调用可以重试。返回的error表示本次初始化结果,快速路径nil表示先前已成功,均不表示本次创建了资源。重试仍要求失败时能清理部分资源,避免重复副作用。 深入机制与原文位置见失败重试需要独立发布协议。

若其他方法不经过Do也需要知道初始化是否完成,可在初始化成功后原子发布一个inited标记,再由读者原子读取。这个标记应表达资源就绪,而非仅表达调用过Do。课程用unsafe窥探Once内部done属于布局依赖技巧,不能据此推断业务成功。 深入机制与原文位置见就绪查询应有公开状态。

原书依据 · 3 处

S081 08-Once:一个简约而不简单的并发原语 / Once的踩坑案例

课程的refresh在Once.Do内部把当前Once重置为零值;原执行路径仍要解锁内部Mutex,却已变成未锁定的新状态,因而崩溃。需要新一轮初始化时可在明确排除旧使用者后更换独立实例,不能在旧实例正在执行时原地覆盖。 深入机制与原文位置见执行中覆盖一次锁会破坏释放。

原书依据 · 1 处

S082 08-Once:一个简约而不简单的并发原语 / 总结

导出的全局变量可能被外部重新赋值,改变如io.EOF一类共享约定。把变量隐藏并通过访问方法返回可限制直接重绑定,但若返回指针、map或切片,调用者仍可能修改其可达对象。单例的初始化次数、变量可见性和对象可变性要分别设计。 深入机制与原文位置见隐藏变量不等于对象不可变。

原书依据 · 1 处

S083 08-Once:一个简约而不简单的并发原语 / 思考题

慢路径拆分服务于常见路径内联;Once使用后的复制同样受禁复制约束。这些思考题连接前面的实现和通用同步对象规则,而不引入新的初始化协议。

S084 09-map:如何实现线程安全的map类型?

map用键定位关联值,支持增加、查找和删除。不同键可能发生哈希冲突,不能把哈希索引理解为键天然各占唯一桶;唯一的是映射中按相等规则辨认的键。内建map提供访问抽象,是否并发安全仍是另一个问题。 深入机制与原文位置见哈希映射把键关联到值。

原书依据 · 1 处

S085 09-map:如何实现线程安全的map类型? / map的基本使用方法

map键类型须可比较;可比较元素组成的数组和结构体也可作键。插入结构体键会保存当时的值,后来修改本地变量,只是用另一个键去查,并不改变已保存的键。接口键还要注意动态值是否可比较,不能仅凭接口类型可比较就认为任意值都合法。 深入机制与原文位置见映射键依照值相等查找。

读取map中不存在的键会得到元素零值,与真实保存的零值相同。使用v, ok := m[k]才能区分存在与缺失,ok表达键是否存在,不代表值是否满足业务条件。nil map可读取,但写入前必须初始化。 深入机制与原文位置见零值与键不存在要区分。

内建map迭代顺序未指定,也不保证重复遍历一致。要按键顺序输出,可在适当同步下收集键、排序后读取;要保留插入顺序,则需另维护顺序结构。排序并不自动把持续变化的map变为一致快照,仍要确定读期间的修改规则。 深入机制与原文位置见映射遍历不承诺顺序。

原书依据 · 3 处

S086 09-map:如何实现线程安全的map类型? / 使用map的2种常见错误

make或字面量创建的空map可写,零值nil map读取返回零值、赋值会panic。map嵌在结构体里也要单独初始化;分配外层结构并不会自动创建内部map。构造函数可集中保证可写状态,调用方仍要遵守对象的初始化约定。 深入机制与原文位置见空映射和未初始化不同。

内建map的不同键仍共享内部结构,无同步地一边写一边读,即使键不相同也属于不安全使用;运行时可能报致命错误,不能依赖recover处理。只读并发与含写入的并发要区分。删除同样是写操作,不能遗漏同步。 深入机制与原文位置见不同键也不使映射并发安全。

原书依据 · 2 处

S087 09-map:如何实现线程安全的map类型? / 如何实现线程安全的map类型?

RWMap把查询、长度和遍历置于读锁,增加修改删除置于写锁,让同一map的所有入口遵守协议。单次Get和Set各自安全,不等于Get后计算再Set构成原子事务。Each在持读锁时调用回调,回调再申请写锁还可能死锁,需明确回调限制。 深入机制与原文位置见映射包装统一所有访问入口。

orcaman/concurrent-map示例按键哈希选取分片,每片有独立map和RWMutex,使不同片可并发访问。热点键仍集中同片,跨片操作和遍历也要另定一致性协议;32片是课程版本默认值,不是通用最佳配置。是否更快要以目标负载评估。 深入机制与原文位置见分片降低无关键锁竞争。

原书依据 · 2 处

S088 09-map:如何实现线程安全的map类型? / 应对特殊场景的sync.Map

sync.Map为并发键值访问提供专门实现,典型适用情形是单键写一次多次读,或不同goroutine主要操作不相交键集。普通map加锁更便于类型约束和维护跨键不变量;是否采用应对目标场景测量,不能从标准库身份推出所有负载都更快。 深入机制与原文位置见并发映射按负载选择。

课程旧sync.Map用原子发布的read视图和锁保护的dirty映射减少读锁开销。read的键集合不随意原地变更,但它指向的entry值可原子更新,read和dirty可能共享entry。只读指视图结构,并非业务值永远不可变;这个布局仅描述课程所示历史实现。 深入机制与原文位置见只读视图共享可更新条目。

旧sync.Map读取先找read;缺失且amended提示dirty可能有新键时,才加锁访问dirty并累计miss。miss达到阈值后把dirty发布为新read,随后清空dirty和miss。锁内再次检查read,是因为等锁期间其他操作可能已提升视图,不能依据加锁前结果直接访问旧结构。 深入机制与原文位置见读缺失促进视图提升。

课程旧sync.Map的entry.p可为有效值、nil或expunged。逻辑删除可先把指针CAS为nil;建dirty时标记并排除已删项,dirty里的独有键还需实际delete。把所有删除都说成直接写expunged不准确,键结构回收与业务值不可见发生在不同步骤。 深入机制与原文位置见删除状态与键移除分开。

原书依据 · 4 处

S089 09-map:如何实现线程安全的map类型? / 总结

并发map方案要围绕访问模式与实测选择:单锁、分片和专用sync.Map各有边界。带过期功能的timedmap、键有序的treemap在这里仅作拓展阅读线索,没有展开算法或使用流程。

S090 09-map:如何实现线程安全的map类型? / 思考题

两个问题回指旧sync.Map机制:加锁后视图可能已变,删除的值与键结构回收也分离。答案由前文双检和删除状态分析承接,不按提问再重复生卡。

S091 10-Pool:性能提升大杀器

池化把昂贵的创建成本与重复使用分开,但保留资源也会带来内存和生命周期成本。本章依次区分临时sync.Pool、长连接池和执行任务的worker池,不能只因都叫Pool就互换。

S092 10-Pool:性能提升大杀器 / sync.Pool

sync.Pool存放可独立复用的临时对象,条目可在无通知下被移除。它本身可并发使用且使用后不能复制;池的并发安全不允许多个使用者同时修改同一个借出对象。它适合减轻临时分配成本,不应当作必须长期保存的资源仓库。 深入机制与原文位置见临时对象池不保证保留。

原书依据 · 1 处

S093 10-Pool:性能提升大杀器 / sync.Pool的使用方法

Get取走可用对象,无可用对象且配置New函数时调用工厂,否则可返回nil;Put交还对象,nil会被忽略。New是函数字段,不是Pool的方法,不能和Get并发修改。取出后的重置及所有权转交仍由调用方管理,不能把返回池中的对象继续当作私有对象使用。 深入机制与原文位置见对象池取还与工厂各有职责。

原书依据 · 1 处

S094 10-Pool:性能提升大杀器 / 实现原理

课程Pool按P维护private和shared;当前P优先取私有对象及本地队列,失败再从其他P队尾窃取。pin让操作期间保持在同一P,避免private被多个执行流同时访问。P是调度资源,不等于固定OS线程;这些存取顺序是实现细节,不是Get返回次序契约。 深入机制与原文位置见本地复用减少共享竞争。

课程所示Pool在GC清理时丢弃旧victim,把local转作下一轮victim并清空local;Get仍可从victim捡回对象。它给闲置对象多一次复用机会,但不能承诺对象至少保留多少轮GC,公开契约始终允许随时移除。未取回且无其他引用的对象最终可回收。 深入机制与原文位置见受害缓存延缓对象淘汰。

原书依据 · 2 处

S095 10-Pool:性能提升大杀器 / sync.Pool的坑

bytes.Buffer.Reset清空逻辑内容,不缩小底层容量。偶发大请求扩容后的Buffer若长期被池反复复用,会增加内存保留;应按容量上限决定是否放回。课程把此现象称为泄漏,更准确是复用策略造成的保留风险,并非Pool永远不能回收对象。 深入机制与原文位置见重置缓冲区仍保留容量。

把小、中、大缓冲区放进不同池,借用时按需求选档,可避免常用小请求总拿到巨型缓冲区。分层要控制最大可保留容量,也要防止太多档增加闲置资源。vitess的bucketpool展示按最小最大尺寸组织分层的思路;具体档位应随负载验证。 深入机制与原文位置见尺寸分层降低过量保留。

原书依据 · 2 处

S096 10-Pool:性能提升大杀器 / 第三方库

课程介绍bytebufferpool在sync.Pool基础上统计使用规模并校准defaultSize和maxSize,使创建和保留更贴近日常尺寸分布,同时拒收过大对象。它解决的是容量选择与复用策略,不是所有负载下的性能保证;偏好分布变化后仍要观察保留成本。 深入机制与原文位置见自适应缓冲池调整容量偏好。

bpool示例用有界Channel限制池里闲置对象数,池空时Get仍可创建新对象,满时Put丢弃。因此固定容量限制的是缓存数量,不保证同时借出的对象数也有上限。SizedBufferPool还检查容量,选择库时要分别确认数量、尺寸和借用并发这三种边界。 深入机制与原文位置见空闲容量上限不等于总量上限。

原书依据 · 2 处

S097 10-Pool:性能提升大杀器 / 连接池

TCP及TLS连接创建有握手和认证成本,长期复用可省去重复建立。连接池要明确空闲、借出、失效及实际关闭的生命周期,不能用会无通知丢条目的sync.Pool代替。连接对象失去引用也不等于按业务需要及时关闭底层资源。 深入机制与原文位置见连接复用需要确定关闭协议。

原书依据 · 1 处

S098 10-Pool:性能提升大杀器 / 标准库中的http client池

http.Client的连接复用主要由Transport维护,课程以idleConn保存可重用连接作例子。复用同一客户端及传输层才能利用池,不能把每次创建全新Transport当作必然共享同一组空闲连接。请求结束时仍要按HTTP响应体协议归还资源。 深入机制与原文位置见传输层负责客户端连接复用。

原书依据 · 1 处

S099 10-Pool:性能提升大杀器 / TCP连接池

fatih/pool的PoolConn包装net.Conn,将正常Close转成归还空闲池;标为unusable后Close才关闭底层连接。这让调用方沿用关闭动作表达租借结束,但包装对象须遵守一次归还和不再使用的所有权约定。课程称归档后稳定可即用属于当时评价,实际选型仍需核验维护和安全情况。 深入机制与原文位置见连接包装把关闭改为归还。

原书依据 · 1 处

S100 10-Pool:性能提升大杀器 / 数据库连接池

sql.DB以连接池管理数据库连接,MaxOpenConns限制打开连接的总量,MaxIdleConns限制可保留的空闲连接数。两者影响不同:前者关联并发数据库压力,后者关联复用与闲置成本。课程所列默认空闲数是版本背景,配置应按数据库容量和请求负载验证,不能一概认定默认值太小。 深入机制与原文位置见总连接与空闲连接分别限额。

原书依据 · 1 处

S101 10-Pool:性能提升大杀器 / Memcached Client连接池

gomemcache示例以map把服务器地址映射到连接切片,用同一Mutex保护取还。归还时超过该地址空闲上限就真正关闭,获取时从切片尾部取走一个。它控制的是分地址空闲复用,不自动代表所有借出连接的全局并发上限。 深入机制与原文位置见按目标地址组织空闲连接。

原书依据 · 1 处

S102 10-Pool:性能提升大杀器 / Worker Pool

固定数量worker通过任务Channel接收工作,可减少每项任务都新建goroutine的调度和栈成本。worker数限制同时处理数,队列容量限制排队量,两者分别配置;无限提交的队列仍可能积累大量内存。停止接收、排空、取消和结果回收也要单独定义。 深入机制与原文位置见工作池限制工作并发资源。

课程比较workerpool的Submit/SubmitWait、grpool的有界任务Channel、goworkers的ResultChan/ErrChan,说明提交、等待和结果交付可能采用不同协议。选型须确认队列是否有界、调用是否阻塞、关闭后谁收结果,而不能只比较worker数量。这里是课程版本接口概览,不承诺这些库当前仍相同。 深入机制与原文位置见工作池接口反映等待方式。

原书依据 · 2 处

S103 10-Pool:性能提升大杀器 / 总结

池化应针对重复创建的临时对象、连接建立或过量goroutine等具体成本。它可能减少分配与调度,也可能增加闲置保留;需要先知道目标成本再选择池,不把名称直接等同于性能提升。

S104 10-Pool:性能提升大杀器 / 思考题

net/rpc请求复用代码查找是留给读者的源码练习,没有在本项展开实现。因此登记项目入口,保留为后续问题,不将其当作本次已深读结论。

S105 11-Context:信息穿透上下文

上下文在调用链传递请求范围信息,例如身份、接收时间和Trace ID,帮助不同处理阶段关联同一请求。Go Context还承载截止与取消;后文会区分这些信息和任务真正结束。

S106 11-Context:信息穿透上下文 / Context的来历

x/net/context迁移到标准库后,type Context = context.Context使旧包名称引用同一类型,避免仅因命名来源不同造成兼容障碍。等号别名不同于type T Base定义新类型;迁移的是类型身份,取消与值传递的行为契约仍由实际Context实现决定。 深入机制与原文位置见类型别名可衔接接口迁移。

原书依据 · 1 处

S107 11-Context:信息穿透上下文 / Context基本使用方法

Context提供Deadline截止时刻、Done取消信号、Err取消原因、Value请求范围数据。Done关闭表示取消或截止发生,不证明工作已退出;没有取消能力的Context可返回nil Done。函数通常把ctx放首参,不传nil,也不把请求上下文长期持久化或缓存成全局业务状态。 深入机制与原文位置见取消上下文的四类信息。

Background作为初始化、测试和根请求的空上下文;TODO表达调用位置尚未决定上下文来源。两者都非nil、无取消无截止,行为相近仍有可读性区别,不应因旧实现相似就混淆含义。请求链已有ctx时应传播它,避免随意新建根而切断取消。 深入机制与原文位置见根上下文也表达使用意图。

原书依据 · 2 处

S108 11-Context:信息穿透上下文 / 创建特殊用途Context的方法

本项列出WithValue、WithCancel、WithTimeout及WithDeadline,作为后续四类派生上下文的导航。它们分别增加值、取消能力或时间边界,而非都修改同一个父对象。

S109 11-Context:信息穿透上下文 / WithValue

WithValue创建携带一个键值对的子Context,查询先检查当前键,再沿parent找,因此可叠加请求范围信息而不修改父对象。键须可比较,宜用包内自定义类型减少冲突。它不提供对所存可变值的并发保护,也不适合作可选业务参数的万能容器。 深入机制与原文位置见值上下文沿父链查找。

原书依据 · 1 处

S110 11-Context:信息穿透上下文 / WithCancel

WithCancel派生可取消的子上下文;调用cancel或父上下文取消,会使子Done关闭,并继续通知它的可取消后代。取消子节点不会取消父节点。实际任务须主动观察Done或把ctx交给支持取消的API;关闭信号本身不会强制杀掉goroutine。 深入机制与原文位置见取消向子树传播不向父传播。

WithCancel返回的cancel既用于放弃工作,也用于结束后释放父子注册等关联资源;通常取得后立即defer cancel。不能只在失败分支调用,留下正常路径关联未释放。cancel可重复调用,但不会等待实际工作退出,完成等待须另有机制。 深入机制与原文位置见正常结束也应释放取消资源。

原书依据 · 2 处

S111 11-Context:信息穿透上下文 / WithTimeout

WithTimeout把相对时长加到当前时间后调用WithDeadline。相对预算与绝对截止只是表达方式不同,均受父上下文更早截止限制;这部分并入截止时间卡的解释和来源。

这一部分与前面所述同一机制连续展开,补充定位见截止时间不能延长父预算。

原书依据 · 2 处

S112 11-Context:信息穿透上下文 / WithDeadline

WithDeadline派生的截止时间不晚于请求值,也受父截止限制;父更早到期时子任务不能借此获得额外时间。WithTimeout按当前时间加时长构造截止。到期、显式cancel和父取消都可使Done关闭,即使预计会自动到期,也应尽早调用返回的cancel释放资源。 深入机制与原文位置见截止时间不能延长父预算。

原书依据 · 2 处

S113 11-Context:信息穿透上下文 / 总结

ctx超时可以让支持它的客户端结束等待,但请求可能仍在服务器执行。是否关闭连接、取消数据库工作或停止本地I/O,取决于底层API及远端协议。不能从客户端收到超时推断服务器未产生业务结果,也不能把cancel当作完成确认。 深入机制与原文位置见客户端超时不证明远端停止。

原书依据 · 1 处

S114 11-Context:信息穿透上下文 / 思考题

级联上下文验证是开放练习,要求组合WithValue与WithCancel观察父子关系。这里没有执行结果,笔记只沿前面的父取消向下传播机制给出待验证方向。

S115 12-atomic:要保证原子操作,一定要使用这几种方法

atomic是课程前面锁与其他原语实现中反复出现的底层工具;本章把接口意义、可见性及无锁结构实现分开。先理解单个原子动作的责任,再判断能否组成完整业务协议。

S116 12-atomic:要保证原子操作,一定要使用这几种方法 / 原子操作的基础知识

原子操作提供其他执行者看不到中间状态的契约,其机器实现随体系结构而变。64位赋值在32位目标上可能拆成多步,单条指令的观测也不足以证明语言层面的同步。并发共享状态应使用atomic或其他同步机制,不能以某次反汇编恰好一条指令替代保证。 深入机制与原文位置见原子性不能靠指令数猜测。

原书依据 · 1 处

S117 12-atomic:要保证原子操作,一定要使用这几种方法 / atomic原子操作的应用场景

原子读写适合简单状态发布,但先Load发现未启动、再Store启动,仍可让多个调用者同时进入。若业务责任是唯一取得启动资格,应使用CAS等把判断与更新合成一个原子动作。标志安全也不会自动保证任务初始化完成或退出,需另定义状态转换。 深入机制与原文位置见原子标记不包办复合协议。

原书依据 · 1 处

S118 12-atomic:要保证原子操作,一定要使用这几种方法 / atomic提供的方法

旧版atomic按可操作类型分别提供函数,参数使用目标变量的地址,而不是变量当前值。现代typed atomic简化部分调用,但仍需按返回值确认操作结果,不能把类型扩展当作新并发保证。

S119 12-atomic:要保证原子操作,一定要使用这几种方法 / Add

Add把delta加到目标地址并返回新值;对无符号整数可用补码表示负的增量,例如uint32减1可加^uint32(0)。运算按位宽回绕,若计数承担剩余资源含义,还须保证业务上不会下溢。不能把机器上的模减法当作合法额度校验。 深入机制与原文位置见原子加法支持模运算减量。

原书依据 · 1 处

S120 12-atomic:要保证原子操作,一定要使用这几种方法 / CAS (CompareAndSwap)

CAS原子比较当前位置是否等于old,只有相等才写new,返回值swapped表示这次替换是否发生。失败后若重试,须重新加载并计算所需状态;成功也只证明比较和写这一动作,不证明围绕它的整个业务已经完成。它比调用方的继续或跳过分支更接近操作本身的责任。 深入机制与原文位置见比较交换返回是否替换成功。

原书依据 · 1 处

S121 12-atomic:要保证原子操作,一定要使用这几种方法 / Swap

Swap无条件替换并返回旧值,Load读取原子值,Store原子发布新值;Add返回更新后值,CAS返回是否替换。选API要先确认业务需要旧状态、新状态还是实际发生标记,不能因都能修改数值就互换返回值语义。 深入机制与原文位置见交换与加载存储返回不同结果。

原书依据 · 3 处

S122 12-atomic:要保证原子操作,一定要使用这几种方法 / Load

Load原子读取目标值,是发布协议读端的一种操作;它需要和其他访问遵守同一同步规则。这里与Swap、Store的结果语义一并保留,不将简单类型列表逐项拆成重复卡。

这一部分与前面所述同一机制连续展开,补充定位见交换与加载存储返回不同结果。

原书依据 · 3 处

S123 12-atomic:要保证原子操作,一定要使用这几种方法 / Store

Store原子发布目标值,避免读者看到这一个原子值的中间写入;它没有返回此前值,也不会自动保护被发布对象内部的后续修改。与Load的配合须按内存模型理解。

这一部分与前面所述同一机制连续展开,补充定位见交换与加载存储返回不同结果。

原书依据 · 3 处

S124 12-atomic:要保证原子操作,一定要使用这几种方法 / Value类型

atomic.Value可让读者原子取得一次发布的配置对象,避免读到部分替换的接口值。存取须遵守相同具体类型、禁止nil Store等契约;发布后的可变成员仍需独立同步。课程称它只有Load和Store是历史范围,新版已有Swap及CompareAndSwap,不能把课程API列表当作当前完整列表。 深入机制与原文位置见原子值发布整体配置。

课程先Store配置再Broadcast,读者无谓词地Wait后Load,能演示读取当前配置,却可能错过进入Wait前的广播,或合并多次变化。若要等待下一版本,应把版本谓词纳入同一等待协议;若要逐次处理所有更新,则需具备保存每次事件的交付机制。 深入机制与原文位置见通知不保证逐版配置都被消费。

原书依据 · 2 处

S125 12-atomic:要保证原子操作,一定要使用这几种方法 / 第三方库的扩展

uber-go/atomic把Bool、Int64等状态与Load、Store、CAS等操作封装为类型,减少地址函数调用的重复并约束使用方式。它是课程介绍的扩展库,不意味着标准库今天缺少typed atomic;选择时要对照目标Go版本的公开API,避免仅为旧语法习惯增加依赖。 深入机制与原文位置见原子包装把操作附着类型。

原书依据 · 1 处

S126 12-atomic:要保证原子操作,一定要使用这几种方法 / 使用atomic实现Lock-Free queue

课程Michael–Scott队列以一个不代表有效元素的头部哨兵开始,head和tail初始同指它。入队先CAS链接新节点,再推进tail;出队从head.next取值并CAS推进head。头节点的角色随出队推进,避免为空与首元素设计完全不同的更新路径。 深入机制与原文位置见无锁队列用哨兵简化边界。

队列中tail可能落后于已链接的最后节点;发现tail.next非空的调用者会帮助CAS前移tail,再继续操作。因此head==tail不能单独证明队列为空,还须检查next。无锁指整体进展的算法性质,不承诺每个goroutine都无等待或总比互斥版本快。 深入机制与原文位置见帮助推进尾指针促进进展。

原书依据 · 2 处

S127 12-atomic:要保证原子操作,一定要使用这几种方法 / 总结

一次赋值在某机器上没有撕裂,并不意味着与其他goroutine共享时可以无同步访问。Go原子操作同时提供内存模型约定的顺序关系;不能把它简化为每次都刷新所有CPU缓存,或保证每个并发读取一定取得墙钟意义上最新值。普通与原子访问混用也会破坏协议。 深入机制与原文位置见无撕裂不同于语言同步保证。

原书依据 · 1 处

S128 12-atomic:要保证原子操作,一定要使用这几种方法 / 思考题

给atomic.Value增加Swap与CAS是历史练习;Go1.17起公开API已提供相应方法。继续学习应比较它的类型和nil约束,而非按旧题误认标准库仍没有这两种操作。

S129 13-Channel:另辟蹊径,解决并发问题

Channel是语言内建类型,与通过库提供的Mutex和atomic有不同入口。它提供消息与同步表达,后续仍需理解阻塞、关闭和所有权协议,内建身份不代表更不容易误用。

S130 13-Channel:另辟蹊径,解决并发问题 / Channel的发展

CSP用独立顺序执行组件及消息交互描述并发系统,启发了Go的goroutine和Channel组合。它提供观察任务交互的方法,并不意味着Go禁止共享内存,或每个问题都必须采用Channel。需要保护共享状态时,传统同步原语仍是课程工具库的一部分。 深入机制与原文位置见通信进程模型组织交互。

原书依据 · 1 处

S131 13-Channel:另辟蹊径,解决并发问题 / Channel的应用场景

Channel可把数据或引用交给另一个goroutine,形成逻辑上的处理权转交。但发送指针、切片或map不会深复制底层对象,也不会强制原发送者停止访问。若以通信避免共享写冲突,双方仍须遵守交出后不再修改或另行同步的约定。 深入机制与原文位置见交接引用需要逻辑所有权约定。

原书依据 · 1 处

S132 13-Channel:另辟蹊径,解决并发问题 / Channel基本用法

chan T可收发,chan<- T只发送,<-chan T只接收,方向约束由静态类型限定。嵌套通道中箭头尽可能结合左侧chan,必要时用括号明确结构。方向限制不会复制底层通道,也不能代替确定谁负责关闭、何时所有发送者都已退出。 深入机制与原文位置见通道方向限制可用操作。

有缓冲通道在有空位时可发送、有元素时可接收;无缓冲通道须匹配收发方。nil通道上的普通发送和接收永远阻塞,适当用于select时可禁用对应分支。len只描述观测瞬间缓冲元素数,不能据此保证下一步发送不会阻塞。 深入机制与原文位置见通道容量决定何时阻塞。

接收的第二个返回值ok表示是否实际取到一个已发送元素;关闭后已有缓冲元素仍以ok=true被取走,排空后才返回零值和false。单看零值无法区分真实消息与关闭;range也要等关闭且排空才结束,而不是队列临时为空就退出。 深入机制与原文位置见关闭后要先读完缓冲数据。

原书依据 · 3 处

S133 13-Channel:另辟蹊径,解决并发问题 / Channel的实现原理

实现部分沿hchan状态、分配、发送、接收及关闭展开。数据缓冲与执行者等待队列相互协调,后续对错误状态的解释来自这些分支,而非仅背操作结果。

S134 13-Channel:另辟蹊径,解决并发问题 / chan数据结构

课程hchan以循环缓冲保存已发送未取出的值,sendx和recvx记录槽位索引;sendq和recvq保存因满或空而阻塞的执行者。索引按槽位循环推进,不能把课程文字里的加elemsize理解为字段本身一定是字节指针。容量队列与等待队列承担不同责任。 深入机制与原文位置见通道把缓存和等候队列分开。

原书依据 · 1 处

S135 13-Channel:另辟蹊径,解决并发问题 / 初始化

课程makechan根据容量乘元素大小,以及元素是否含指针来安排内存:无数据区时仅创建hchan,不含指针的元素可与hchan连续分配,含指针则单独分配可扫描的缓冲区。它解释GC扫描与布局的关系,具体分配分支属于所示运行时版本。 深入机制与原文位置见通道分配取决于元素布局。

原书依据 · 1 处

S136 13-Channel:另辟蹊径,解决并发问题 / send

课程发送流程先处理nil和关闭,再在通道锁下寻找等待接收者;有则直接交付,没有则在缓冲有空位时复制入队,否则阻塞发送者。对关闭通道发送会panic;多方发送时,关闭协议必须确保不会再发送,不能凭一次状态检查避免并发关闭。 深入机制与原文位置见发送优先匹配等待接收者。

原书依据 · 1 处

S137 13-Channel:另辟蹊径,解决并发问题 / recv

课程接收流程在关闭且排空时返回零值与false;若有等待发送者,无缓冲可直接交接,有缓冲则取队头并把等待发送者的值放入队尾。没有等待发送者时取缓冲元素并清空槽位,避免继续保留引用;无数据且未关闭才阻塞。 深入机制与原文位置见接收可把等待发送填入空位。

原书依据 · 1 处

S138 13-Channel:另辟蹊径,解决并发问题 / close

close将通道标为关闭并唤醒等待接收者和发送者;接收者可观察排空后的零值与false,而未完成发送者被唤醒后会panic。关闭nil或重复关闭也会panic。关闭不是向每个等待方成功送达一个消息,而是改变该通道生命周期状态。 深入机制与原文位置见关闭会唤醒两类等待者。

原书依据 · 1 处

S139 13-Channel:另辟蹊径,解决并发问题 / 使用Channel容易犯的错误

示例process超时后返回,后台任务后来向无缓冲结果通道发送,却再无接收者,导致goroutine泄漏。一次性单结果可用容量1缓冲让发送完成,或设计取消感知发送;这不自动取消计算。若结果有多次发送,容量1不能普遍解决。 深入机制与原文位置见等待超时可能留下阻塞发送。

原书依据 · 1 处

S140 13-Channel:另辟蹊径,解决并发问题 / 它们踩过的坑

etcd Status案例把结果通道交给节点处理,节点停止后可能不再写入。只在提交请求时监听done不够:提交成功后的等待结果也可能遇停止。应覆盖每个阻塞点的终止条件,而非认为请求已入队就保证未来一定有人答复。 深入机制与原文位置见每次等待都要考虑节点停止。

etcd测试案例在循环内反复发送完成信号,外部读一次就返回,子goroutine却继续下一次发送并阻塞。将唯一完成通知移到整个循环工作完成之后,让信号含义与等待者的业务判断一致。收到一次进度事件不等于整个任务结束。 深入机制与原文位置见完成通知应在循环工作结束后。

原书依据 · 2 处

S141 13-Channel:另辟蹊径,解决并发问题 / 总结

不同状态下的收发与关闭形成一张行为表:nil收发阻塞,nil关闭panic;缓冲满空决定普通等待,关闭后排空返回零值,发送或重复关闭panic。无缓冲场景还需要匹配方,不能套用有缓冲的空槽直觉。

S142 13-Channel:另辟蹊径,解决并发问题 / 思考题

有序输出和方向通道赋值是两道开放题。前者在下一讲用令牌传递实现,后者回指静态方向约束;此处不凭题目增加未经推导的运行结果。

S143 14-Channel:透过代码看典型的应用模式

当Channel集合在运行期决定时,固定写出的select不够表达,反射选择成为后续动态合并的工具。然后按通信、传递、通知、锁和编排分别讲解,并不主张所有问题采用同一模式。

S144 14-Channel:透过代码看典型的应用模式 / 使用反射操作Channel

reflect.Select以SelectCase切片描述运行期收发分支,返回chosen索引、接收值及recvOK。无可用分支且无default时会阻塞;recvOK不是是否选中任何分支,而是接收是否取得已发送的值,关闭且排空时为false,发送分支也不靠它表示发送失败。课程对此返回值的口述需校正。 深入机制与原文位置见反射选择支持动态通道集合。

原书依据 · 1 处

S145 14-Channel:透过代码看典型的应用模式 / 典型的应用场景

这一项从反射的动态选择过渡到典型场景,后面的例子各说明不同的数据流与生命周期。消息队列、令牌、关闭通知及汇流属于并列用途,不是固定依次执行的链条。

S146 14-Channel:透过代码看典型的应用模式 / 消息交流

worker池示例以chan Job接收待办,再把任务分派给可用worker的chan Job。前端提交和后端处理由队列解耦,各worker只读取自己的任务信箱。解耦不意味着无上限承接压力,缓冲和worker容量仍决定阻塞与积压位置。 深入机制与原文位置见任务信箱分离提交与处理。

原书依据 · 1 处

S147 14-Channel:透过代码看典型的应用模式 / 数据传递

四个worker各有信箱,只有取得唯一令牌者输出,随后把令牌交给下家,最后一位回传第一位。输出顺序由令牌依赖建立,而非由goroutine启动顺序或Sleep建立。课程示例永久循环,若用于有限生命周期还需约定退出与阻塞发送处理。 深入机制与原文位置见令牌传递形成固定执行顺序。

原书依据 · 1 处

S148 14-Channel:透过代码看典型的应用模式 / 信号通知

closing表示请求结束业务,closed表示清理动作完成;主任务可先广播停止,再启动清理,并在清理完成与最长等待之间select。超时选择只表示不再等,不会使后台清理完成。示例未等待业务goroutine真正退出,不能把一次closing关闭视为全部工作已安全收尾。 深入机制与原文位置见停止请求和清理完成要分开。

原书依据 · 1 处

S149 14-Channel:透过代码看典型的应用模式 / 锁

容量1的通道预放一个令牌,接收令牌取得锁、放回释放;只有一位使用者能持有令牌。也可反向以唯一空槽作为许可。它须显式初始化,零值并不可用;TryLock可用default,超时等待可增加Timer分支,但通道关闭或重复释放仍需明确协议。 深入机制与原文位置见单令牌通道可以提供互斥。

原书依据 · 1 处

S150 14-Channel:透过代码看典型的应用模式 / 任务编排

Or-Done将多个输入完成信号合为一个,任一输入可接收就关闭输出。递归合并或reflect.Select都能组织等待;完成后还要处理未被选中的监听协程,否则永久不关闭的分支可能留下等待。收到任一返回也不等于收到成功结果,成功判据需另定义。 深入机制与原文位置见任一完成信号只合并通知。

fan-in让多个源通道的值流入单一输出,消费者只监听一个入口。反射版本删去关闭的输入,双路merge可把已关闭输入置nil禁用;直到所有源结束才关闭输出。下游若提前停止读取,上游发送也可能阻塞,因此实际流水线须传播取消。 深入机制与原文位置见扇入汇集多个数据源。

课程fan-out将每个输入值复制到各输出,属于广播,与多个worker竞争消费分工不同。同步发送会受最慢目标牵制;示例异步起goroutine发送,却在输入结束后直接关闭输出,可能与未完成发送冲突。必须协调全部发送完成及取消后才能关闭,不能原样用于生产。 深入机制与原文位置见广播扇出不能提前关闭输出。

takeN保留前n项,takeFn逐项筛选,takeWhile只保留连续满足条件的前缀;skipN跳过前n项,skipWhile只跳过满足条件的前缀。前缀操作一旦条件改变就切换阶段,不等于全流过滤。有限消费还需通知上游停止,避免留下等待发送者。 深入机制与原文位置见流筛选按前缀或逐项判断。

示例takeN在select中写takeStream <- <-valueStream,内部接收作为发送值表达式会先求值,可能在进入选择前阻塞,导致done分支也无法及时响应。应把输入接收和输出发送分别做可取消的select,并检查输入ok;否则提前关闭输入还会产生额外零值。 深入机制与原文位置见选择分支前也会求发送值。

map阶段对每个输入应用函数形成输出流,reduce累积这些结果。示例1到5各乘10再求和,预期为150;这个单机管道不因叫map-reduce就自动并行。空输入、函数错误、类型断言和取消需要独立定义,课程reduce直接取首项只是简化边界。 深入机制与原文位置见映射与规约组合数据处理。

原书依据 · 6 处

S151 14-Channel:透过代码看典型的应用模式 / 总结

Channel可以组合出多种模式,但每种组合都增加关闭、取消和背压责任。知识图回顾的是模式地图,不证明示例中的异步发送与提前关闭自动安全。

S152 14-Channel:透过代码看典型的应用模式 / 思考题

容量1可以表达互斥,容量更大可表达有限资源许可。该思考题通向后面的信号量;许可数量改变的是准入并发度,而非把一次锁自动变得更快。

S153 15-内存模型:Go如何保证并发读写的顺序?

Go内存模型描述多个goroutine读写共享变量时,哪些写入可被读取以及怎样建立顺序保证;它不同于对象分配或垃圾回收策略。编译器和硬件可在不违反规定行为的条件下优化,因此跨goroutine正确性应依靠公开同步契约。 深入机制与原文位置见内存模型约束可见性与顺序。

原书依据 · 1 处

S154 15-内存模型:Go如何保证并发读写的顺序? / 重排和可见性的问题

普通变量done被置true、指针变非nil,不足以保证另一goroutine安全读到之前填入的数据;无同步的忙等本身还可能存在data race。重复运行没有遇见错误只是观测,不能替代语言保证。发布必须使用锁、通道或恰当的原子协议。 深入机制与原文位置见观察到标志不证明数据已发布。

原书依据 · 1 处

S155 15-内存模型:Go如何保证并发读写的顺序? / happens-before

happens-before用程序内顺序和跨执行者同步关系建立可传递的先后约束。两个事件若互不先行,称并发,是逻辑上缺少顺序而非必须在同一物理时刻执行。读者要确定共享变量的观察结果,应检查写到读的同步路径以及是否存在其他未排序写入。 深入机制与原文位置见先行关系是可传递的偏序。

原书依据 · 1 处

S156 15-内存模型:Go如何保证并发读写的顺序? / Go语言中保证的happens-before关系

接下来逐项建立初始化、启动、Channel和同步原语的先行关系。把这些边组合起来,才能说明某次结果读取为何有保证;没有关联边的事件仍然可能并发。

S157 15-内存模型:Go如何保证并发读写的顺序? / init函数

被导入包先完成初始化,再初始化依赖它的包,全部包初始化完成后才进入main。包级变量先按依赖关系选择可初始化项,再按声明顺序处理。跨文件顺序关联编译器收到文件的顺序,工具通常按文件名排序,不能把所有构建环境的词法文件名顺序都当成语言硬保证。 深入机制与原文位置见初始化顺序先尊重依赖。

原书依据 · 1 处

S158 15-内存模型:Go如何保证并发读写的顺序? / goroutine

go语句先于新goroutine开始执行,因此启动前准备的参数及数据可沿该关系发布给新任务。goroutine自行退出却不会自动让其他任务得到完成信号;要安全观察其结果,应通过Channel、WaitGroup或其他同步建立结果写入到读取的顺序。 深入机制与原文位置见启动有发布保证退出没有。

原书依据 · 1 处

S159 15-内存模型:Go如何保证并发读写的顺序? / Channel

一次发送先于对应接收完成,关闭先于因关闭且排空而返回的接收;无缓冲通道的接收又先于对应发送完成。此处保证的是匹配操作与程序内顺序,不是收到数据后全部业务处理已完成。若发送者要确认处理结束,还需显式回执或完成信号。 深入机制与原文位置见通道同步到对应操作完成。

容量C的通道上,第k次接收先于第k+C次发送完成。缓冲使发送者最多在相应接收之前超前C个位置,因此可用槽位表达并发许可。C为0时体现无缓冲交接;规则约束收发同步,不能推出接收方后续处理已结束。 深入机制与原文位置见缓冲容量限制超前发送次数。

原书依据 · 2 处

S160 15-内存模型:Go如何保证并发读写的顺序? / Mutex/RWMutex

Mutex的Unlock先于随后成功Lock返回,使同一锁协议内的写对后续读可见。RWMutex还需区分写解锁到读锁、相应读解锁到后续写锁的关系;不能把互相并发的多个读者理解为自动相互发布写入。原文此处有方法名笔误,按公开锁契约理解。 深入机制与原文位置见解锁向后续持锁者发布状态。

原书依据 · 1 处

S161 15-内存模型:Go如何保证并发读写的顺序? / WaitGroup

按照WaitGroup协议结束任务,Done之前写入的结果可通过其与Wait返回的同步关系被后续读取。计数要涵盖全部需要等待的任务,不能在零计数Wait返回后才补登记。这个保证让结果读取有顺序,不负责互相并发的worker之间的数据保护。 深入机制与原文位置见完成动作发布到等待返回。

原书依据 · 1 处

S162 15-内存模型:Go如何保证并发读写的顺序? / Once

Once执行f结束后,各次Do才可返回,因此在f中设置共享结果、再经过Do读取,是一种延迟初始化发布协议。它不支持在f未结束时把done视为已就绪,也不把f的panic或业务失败变为初始化成功。 深入机制与原文位置见初始化结束先于各次调用返回。

原书依据 · 1 处

S163 15-内存模型:Go如何保证并发读写的顺序? / atomic

课程以Go1.15背景讨论原子顺序尚未明确,但当前Go文档已经定义顺序一致的原子操作语义。若原子读取观察到某次原子写入,可建立相应同步关系;不得继续把所有atomic顺序保证说成只存在于某版实现。具体协议仍需分析,不能混入未同步普通访问。 深入机制与原文位置见原子顺序应按现行契约理解。

原书依据 · 1 处

S164 15-内存模型:Go如何保证并发读写的顺序? / 总结

内存模型用于理解同步保证,不用于鼓励难以验证的技巧。已有成熟互斥锁时应先复用公开契约;若要组合新原语,则明确需要的同步边与失败边界。

S165 15-内存模型:Go如何保证并发读写的顺序? / 思考题

Channel锁的发布关系是开放推导题,前面收发规则已给所需依据。这里只记录推导入口,没有声称已实现或运行新的锁。

S166 16-Semaphore:一篇文章搞懂信号量

信号量控制多份资源的同时访问,扩展了互斥锁只能允许一个进入者的常见场景。本节引出计数及P/V操作,再比较官方加权实现和简单通道方案。

S167 16-Semaphore:一篇文章搞懂信号量 / 信号量是什么?都有什么操作?

信号量表示一组资源的可用许可,取得许可后数量减少,释放后增加;资源不足时调用者等待。许可表达准入资格,不等同于实际资源对象本身。容量为1可提供互斥效果,更大的容量允许有限多个执行者同时进入受控范围。 深入机制与原文位置见计数信号量协调资源许可。

原书依据 · 1 处

S168 16-Semaphore:一篇文章搞懂信号量 / P/V操作

P或Acquire取得许可,V或Release归还许可;每次取得多少,应在相应工作结束后归还多少。课程先用非负可用量、再用可为负的等待计数讲解,这是两种内部记账方式,不应混成同一变量规则。外部语义是资源不足就不能成功进入。 深入机制与原文位置见取得与归还维护同一许可账。

原书依据 · 1 处

S169 16-Semaphore:一篇文章搞懂信号量 / Go官方扩展库的实现

Weighted可用Acquire(ctx,n)一次取得n个许可,无足够资源时等待且可受取消影响;TryAcquire要么整批成功要么不取得,Release归还数量。不能用n次独立单许可获取直接替代:多个调用者各拿一部分再等剩余,可能造成互相等待。 深入机制与原文位置见加权许可支持整批取得。

课程dispatcher先Acquire再启动worker,完成后由worker Release,让没有许可的任务停在提交者处,而非先创建大量等待goroutine。末尾取得全部许可可确认此前许可已归还,前提是无新提交且归还时机确实在工作结束后;若最终Acquire取消失败,不能据此读取未完成结果。 深入机制与原文位置见先取许可再启动限制协程数。

Weighted等待队列按先后处理,资源不足以满足队首时,即使够后方小请求也暂不放行,避免大请求一直被小请求越过而饥饿。代价是部分资源暂时闲置和队首阻塞。公平性与瞬时利用率是不同目标,选并发机制时要明确负载需求。 深入机制与原文位置见队首大请求会挡住小请求。

原书依据 · 3 处

S170 16-Semaphore:一篇文章搞懂信号量 / 使用信号量的常见错误

取得许可却忘记释放会消耗后续可用量;未取得就使用则绕过限制。负数或超过容量的请求不应交给库猜测业务意图,过量归还可能panic,超大请求可能一直等取消。多个信号量也会形成锁顺序死锁,数量上限本身不能消除资源依赖环。 深入机制与原文位置见许可数量越界破坏准入协议。

原书依据 · 1 处

S171 16-Semaphore:一篇文章搞懂信号量 / 其它信号量的实现

容量n的空Channel中,每次发送占一个槽位,接收归还一个槽位,即可限制最多n个持有者。课程示例以Lock/Unlock命名方便适配Locker,但n大于1时它提供并发准入而非互斥。扩展为整批获取时还需新的原子协议,不能循环抢单个槽位就宣称等价于Weighted。 深入机制与原文位置见通道空槽可表达单个许可。

原书依据 · 1 处

S172 16-Semaphore:一篇文章搞懂信号量 / 总结

通道容量可以表示多个许可,Weighted则把一次取得多份许可作为同一动作。总结强调选择的差异是取得协议,不能仅因实现代码短就假定功能完全等价。

S173 16-Semaphore:一篇文章搞懂信号量 / 思考题

如何用Channel表达信号量及为何采用有符号资源计数是思考题,没有在这里展开实现与证明。取材保留前文已有P/V和加权机制,未知推导保持开放。

S174 17-SingleFlight和CyclicBarrier:请求合并和循环栅栏该怎么用?

SingleFlight减少同键在途重复工作,CyclicBarrier让固定参与者在共同点会合。它们因篇幅安排在同一讲,并不构成必须串联使用的依赖关系。

S175 17-SingleFlight和CyclicBarrier:请求合并和循环栅栏该怎么用? / 请求合并SingleFlight

SingleFlight合并同一key的同时请求,让一个执行函数的结果交给等待者;该次结束后下一次请求可以重新执行。Once则面向整个实例的一次执行。合并键应包含结果差异所需的请求维度,不能把不同参数或不同权限结果误合到一起。 深入机制与原文位置见请求合并只覆盖同键在途工作。

原书依据 · 1 处

S176 17-SingleFlight和CyclicBarrier:请求合并和循环栅栏该怎么用? / 实现原理

Group.Do(key,fn)返回结果、错误及shared,shared表示结果是否被多个调用者共享,不是本次是否真正执行fn。DoChan异步交付结果,Forget只让后续请求不再等待旧调用,不会取消旧fn。Forget期间同键旧新调用可能并存,不能把它当作业务幂等保证。 深入机制与原文位置见合并调用返回共享结果标记。

原书依据 · 1 处

S177 17-SingleFlight和CyclicBarrier:请求合并和循环栅栏该怎么用? / 应用场景

缓存击穿是热键失效后大量请求同时回源。SingleFlight在同key的在途加载中只执行一次回源并共享结果,groupcache据此合并加载。它不保存永久缓存,仍须缓存写入与失效策略;跨进程实例也不会自动共享同一个Group,读请求仍需按一致的查询条件合并。 深入机制与原文位置见热键失效可合并回源读取。

原书依据 · 1 处

S178 17-SingleFlight和CyclicBarrier:请求合并和循环栅栏该怎么用? / 循环栅栏CyclicBarrier

CyclicBarrier让固定数量参与者到达共同点后再放行,并能进入下一代重复使用;WaitGroup更常用于等待一组已登记任务结束。会合不代表线程物理上同时执行,栅栏后的调度仍有差异。适用关键是分代到齐,而非只看都存在一个Wait方法。 深入机制与原文位置见循环栅栏协调批次会合。

原书依据 · 1 处

S179 17-SingleFlight和CyclicBarrier:请求合并和循环栅栏该怎么用? / 实现原理

课程NewWithAction在最后一位参与者到达后、其他参与者放行前执行动作,可用于统一更新本轮状态。Await受取消影响时会打断这一代,Reset会使现有等待者得到中断错误。参与方须检查错误并决定退出或重建,不能把失败会合当作已经组成完整批次。 深入机制与原文位置见栅栏动作发生在放行之前。

原书依据 · 1 处

S180 17-SingleFlight和CyclicBarrier:请求合并和循环栅栏该怎么用? / 并发趣题:一氧化二氢制造工厂

H2O示例用容量2的氢许可和容量1的氧许可限制本轮组分,每个原子先取得许可并输出,再等待三人栅栏,放行后归还许可。配额决定两个H一个O,栅栏让这一组全部到齐后下一组才进入。示例使用不会取消的上下文,推广到可取消场景必须处理取得或会合失败后的清理。 深入机制与原文位置见配额与栅栏共同约束组分。

原书依据 · 1 处

S181 17-SingleFlight和CyclicBarrier:请求合并和循环栅栏该怎么用? / 总结

课程用WaitGroup模拟多代H2O:Done后Wait,氧方返回后马上Add(3),可能在其他旧Wait仍未返回时重用而panic。问题是代际交接尚未完成,不是少一个计数。循环会合需要显式代际协议,不能靠任一参与者看见零就重置。 深入机制与原文位置见计数归零不能直接重开栅栏。

原书依据 · 1 处

S182 17-SingleFlight和CyclicBarrier:请求合并和循环栅栏该怎么用? / 思考题

双氧水练习改变了组分配额,原题H2O的两个H一个O需改为两个H两个O,并检查分代会合人数。这里只给学习方向,不声称已实现测试。

S183 18-分组操作:处理一组子任务,该用什么并发原语?

分组操作把一个父任务拆成多个子任务,接下来分别处理首错、全量结果、部分成功及按时间调度。共享的外形是任务集合,返回和取消语义却不同。

S184 18-分组操作:处理一组子任务,该用什么并发原语? / ErrGroup

ErrGroup在等待全部任务的基础上增加错误向上传播及可选Context集成。拆任务可以增加并发度,但收益受依赖与资源限制,后面用具体API解释等待、首错与取消。

这一部分与前面所述同一机制连续展开,补充定位见错误分组仍会等待全部任务。

原书依据 · 2 处

S185 18-分组操作:处理一组子任务,该用什么并发原语? / 基本用法

errgroup.Go启动返回error的子任务,Wait等待所有已登记任务结束并返回首先记录的非nil错误。WithContext派生的ctx在首错或Wait返回时取消,但任务须主动响应ctx;取消不是强制终止。零值Group可用,却没有派生取消上下文。 深入机制与原文位置见错误分组仍会等待全部任务。

原书依据 · 2 处

S186 18-分组操作:处理一组子任务,该用什么并发原语? / ErrGroup使用例子

errgroup.Wait只返回首个错误;若要每个任务的结果,可预分配与输入对应的切片,每个worker独占一个索引写入,全部Wait完成后再读取。不同元素的独立写入不等于可并发append同一个切片,结果对象内部共享状态也需另行保护。 深入机制与原文位置见全量结果需要独立收集位置。

目录遍历者负责关闭paths,有限worker读取路径并产生摘要;独立等待者在所有worker结束后关闭结果c,消费者持续读到关闭,再检查最终错误。关闭结果的责任在确认全部发送者退出者,不在任意一个worker。省略号中的收发仍须实现取消响应,不能把课程简化代码当完整可执行实现。 深入机制与原文位置见流水线关闭须等待所有生产者。

原书依据 · 2 处

S187 18-分组操作:处理一组子任务,该用什么并发原语? / 扩展库

课程bilibili扩展用固定worker、错误取消和panic转error,但超额任务可能等Wait才执行;neilotoole扩展把并发数与排队容量分开,队满时Go阻塞。相似Group名称不表示相同提交时机。课程版本的并发append示例还有外部提交未全部结束就Wait的问题,应分别分析库契约和调用方边界。 深入机制与原文位置见并发限制也要定义提交行为。

facebookgo/errgroup示例扩展WaitGroup,调用方仍负责Add、启动goroutine及Done,worker通过Error登记错误,Wait返回聚合结果。它和官方errgroup自动启动函数的接口责任不同。采用相同包名时也要确认谁管理任务生命周期、谁保存错误。 深入机制与原文位置见错误聚合与任务启动可以分离。

原书依据 · 2 处

S188 18-分组操作:处理一组子任务,该用什么并发原语? / 其它实用的Group并发原语

课程SizedGroup默认先起goroutine再限制工作段,因此可能有许多等待者;Preemptive先在提交处等待许可,才限制创建数。示例注释称默认只创建十个goroutine与正文矛盾,应按实际准入位置理解。ErrSizedGroup另提供首错取消或错误收集,须以选用版本核验差异。 深入机制与原文位置见任务并发数不同于协程总数。

原书依据 · 1 处

S189 18-分组操作:处理一组子任务,该用什么并发原语? / gollback

gollback.All等待全部异步函数,分别返回结果和错误切片,顺序与传入函数一致,不是完成先后顺序。这样可按输入逐项检查结果。ctx传入任务只提供协作取消信号,函数若忽略它,不能因调用方取消就认为所有副作用已停止。 深入机制与原文位置见批量结果按输入顺序对齐。

课程gollback.Race等待首个无错误结果;若全失败返回错误,并在成功后取消其他子任务上下文。它不同于最早任意返回就结束的Or-Done信号合并。取消能否减少剩余工作取决于各任务是否响应,也不保证已发出的远程动作回滚。 深入机制与原文位置见竞速结果应区分成功与最早完成。

gollback.Retry对一个函数重复调用,成功即返,失败达到次数上限后返错;课程约定次数0代表持续尝试。配合超时ctx可限制等待,但函数本身也须响应取消。涉及副作用时还需评估重复执行语义,不能从重试工具自动推出业务幂等。 深入机制与原文位置见重试需要次数和取消边界。

原书依据 · 3 处

S190 18-分组操作:处理一组子任务,该用什么并发原语? / Hunch

课程Hunch的All遇错返回nil结果,Take取前num个成功结果但任一错误也可导致失败,Last保留最后num个正常结果。选择策略不同于gollback按输入返回全量结果;数量和首错策略会影响调用方能获得哪些证据,接口名相似不能推断同义。 深入机制与原文位置见取部分结果须定义错误语义。

Hunch.Waterfall把前一子任务结果交给下一任务,按顺序串行执行,成功后返回最后结果,遇错终止。它组织的是数据依赖而非并行加速。适合后一步确实需要前一步产物的流程;独立任务不必为接口统一而强加串行依赖。 深入机制与原文位置见瀑布流程逐步传递前步结果。

原书依据 · 2 处

S191 18-分组操作:处理一组子任务,该用什么并发原语? / schedgroup

课程schedgroup用Delay相对时间或Schedule绝对时间安排任务,Wait等待已排定任务并响应取消。该版本约定Wait只能调用一次,开始等待后不能再提交,否则panic。实现用堆按时间排序降低大量独立Timer管理成本,时间到达也不承诺函数在该瞬间已经执行完。 深入机制与原文位置见定时分组有单次等待协议。

原书依据 · 1 处

S192 18-分组操作:处理一组子任务,该用什么并发原语? / 总结

本讲将不同Group按结果收集、并发限制、取消和时间调度比较。库名相似不意味着接口责任相同;真正的复用来自识别一组任务的共同协议,而非不断叠加包装。

S193 18-分组操作:处理一组子任务,该用什么并发原语? / 思考题

原文最后要求实现可取消ErrGroup,但前面已说明WithContext能产生取消信号。应区分提供信号和强制停止子任务:任务要检查ctx或使用支持它的调用,不能用新包装消除协作要求。

S194 19-在分布式环境中,Leader选举、互斥锁和读写锁该如何实现?

进程内锁协调同一运行时的共享状态,分布式原语则通过etcd等协调不同机器和进程的访问。网络、节点和服务可用性都可能变化,调用有延迟和失败,不能把本地Lock的直觉直接套入跨节点业务。使用成熟基础服务减少实现工作,不会消除调用方的异常处理责任。 深入机制与原文位置见跨节点协调另有失败边界。

原书依据 · 1 处

S195 19-在分布式环境中,Leader选举、互斥锁和读写锁该如何实现? / Leader选举

Leader选举为业务集群确定主节点,在主节点失效后选择替代者,以协调写入职责。它与所有节点轮流竞争的互斥锁不同,主角色常有较长生命周期。etcd多节点可提高基础服务容错能力,但不能因此保证永远可用,业务仍要处理会话与网络失败。 深入机制与原文位置见选举区分主从角色。

原书依据 · 1 处

S196 19-在分布式环境中,Leader选举、互斥锁和读写锁该如何实现? / 选举

Campaign阻塞等待当选、错误或ctx取消;Proclaim修改当前Leader值,不重新选举;Resign放弃自己的Leader资格。Resign返回表示辞职动作完成或失败,不表示新Leader已当选,课程对此口述不准确。应另外查询或观察选举结果,不能用辞职成功代替接任确认。 深入机制与原文位置见参选声明和辞职责任不同。

原书依据 · 1 处

S197 19-在分布式环境中,Leader选举、互斥锁和读写锁该如何实现? / 查询

Election.Leader从服务查询当前主的键值,失败时不能继续解引用响应;示例仅打印err后访问Kvs存在错误路径问题。Rev提供本Election对象关联的选举修订信息,不应当作任意时候的全局最新领导变更计数。先确定返回值责任,才能选择查询或监控。 深入机制与原文位置见查询当前主与本地修订有别。

原书依据 · 1 处

S198 19-在分布式环境中,Leader选举、互斥锁和读写锁该如何实现? / 监控

Observe返回观察通道,用于取得当前Leader及后续观察变化,不保证补出所有历史领导事件。接收者应检查通道关闭、错误和Kvs有效性;不能固定接收次数后把空响应当有效Leader。它适合跟随协调状态,审计全历史需要另外的数据来源。 深入机制与原文位置见领导观察不提供完整历史。

原书依据 · 1 处

S199 19-在分布式环境中,Leader选举、互斥锁和读写锁该如何实现? / 互斥锁

分布式互斥锁用于平等竞争的节点在同一协调资源上轮流进入,不要求固定主从角色。选举决定谁承担主职责,锁则决定当前哪位调用者取得某次排他资格。

S200 19-在分布式环境中,Leader选举、互斥锁和读写锁该如何实现? / Locker

etcd.NewLocker返回sync.Locker,便于只接受无参数Lock/Unlock的代码使用,但接口本身没有error返回值。分布式协调失败的处理方式须查实际适配实现,不能因接口简单就认为远程操作不会失败。需要明确取消和错误时应选择能表达这些结果的具体Mutex API。 深入机制与原文位置见锁适配器隐藏不了网络失败。

原书依据 · 1 处

S201 19-在分布式环境中,Leader选举、互斥锁和读写锁该如何实现? / Mutex

etcd的Mutex.Lock(ctx)和Unlock(ctx)带上下文及error,Key还暴露协调键;这些签名不同于标准Locker,不构成其隐式实现。使用者可限制等待并处理失败。拿到协调锁后仍须关注session有效性,不能只在取得时检查一次就忽略后续失效。 深入机制与原文位置见远程锁方法保留取消和错误。

原书依据 · 1 处

S202 19-在分布式环境中,Leader选举、互斥锁和读写锁该如何实现? / 读写锁

课程recipes.RWMutex在不同节点提供读共享与写独占,并通过RLock/RUnlock及Lock/Unlock表达访问模式。方法返回错误,不能按本地标准库无返回值方式忽略。旧coreos导入路径属于课程版本,采用前须核对依赖版本、故障语义和部署条件。 深入机制与原文位置见分布式读写锁按协议共享权限。

原书依据 · 1 处

S203 19-在分布式环境中,Leader选举、互斥锁和读写锁该如何实现? / 总结

远程原语减少自写协调算法的工作,却引入网络延迟、可用性和错误处理。节点断连或会话失效时,业务必须重新确认权限,不能把一次成功获取理解成永久持有。

S204 19-在分布式环境中,Leader选举、互斥锁和读写锁该如何实现? / 思考题

节点宕机后锁释放与读写优先级是留给读者的故障语义问题。本项没有展开租约和协议证明,笔记不补造特定失效时限,后续实际采用前需按版本核查。

S205 20-在分布式环境中,队列、栅栏和STM该如何实现?

本讲将协调范围从选举和锁扩展到共享队列、阶段栅栏和多键事务。队列交付待办,栅栏组织进入条件,STM协调读写集合,三者解决的业务责任不同。

S206 20-在分布式环境中,队列、栅栏和STM该如何实现? / 分布式队列和优先级队列

课程etcd recipes.Queue以公共前缀组织字符串元素,多节点可入队和出队;空队列Dequeue阻塞等待。它说明跨节点交付待办的抽象,不自动承诺取走后的业务执行恰好一次。实际系统还须定义失败重试、处理确认与停止等待的边界。 深入机制与原文位置见分布式队列让节点共享待办。

PriorityQueue入队同时携带uint16优先级,用调度优先规则决定先取哪个元素。它不同于纯FIFO,优先值的数值方向和同级排序须按实现确认;课程没有充分说明时不能自行假定数大更优先。示例Atoi后直接转uint16会截断越界值,使用前需校验范围并检查入队错误。 深入机制与原文位置见优先队列改变出队次序。

原书依据 · 2 处

S207 20-在分布式环境中,队列、栅栏和STM该如何实现? / 分布式栅栏

Barrier由持有者开门释放等待者,DoubleBarrier通过参与计数分别等待进入和离开。两者都能跨节点组织执行阶段,但不保证节点在同一墙钟瞬间开始或结束。

S208 20-在分布式环境中,队列、栅栏和STM该如何实现? / Barrier:分布式栅栏

Barrier.Hold建立关闭的门,Wait在门存在时等待,Release移除门使等待方继续;门不存在时Wait直接返回。它等待的是共享门状态,不会统计有多少参与者到齐。初始化顺序若没先Hold,后来者可能直接通过,应按实际业务建立阶段前提。 深入机制与原文位置见分布式栅栏等待门被打开。

原书依据 · 1 处

S209 20-在分布式环境中,队列、栅栏和STM该如何实现? / DoubleBarrier:计数型栅栏

DoubleBarrier初始化count,Enter等待参与者到齐后一起进入阶段,Leave等待本批全部离开后再继续。它组织两个会合边界,不保证各节点在同一物理瞬间执行。参与者失效会影响等待进展,实际部署须处理会话、错误与批次重建。 深入机制与原文位置见双栅栏分别等待进入和离开。

原书依据 · 1 处

S210 20-在分布式环境中,队列、栅栏和STM该如何实现? / STM

etcd事务以If比较当前键修订,成功执行Then,否则执行Else,保证同一事务中的键操作按条件原子选择。返回Succeeded表示比较条件满足,不等于RPC无错误就已执行业务更新;false且无网络错误可能只是读后发生竞争。调用方据业务结果决定重读、重试或报告。 深入机制与原文位置见条件事务表达有据修改。

STM把多个键的读取和写入放入apply回调,由实现管理读写集合、冲突检测及提交,减少手写修订比较的复杂度。课程接口实际是Get、Put、Rev、Del,正文Receive/Delete称呼有笔误。边界是etcd键值事务,不应推出能原子覆盖外部数据库、HTTP调用等副作用。 深入机制与原文位置见软件事务封装读写集合。

两个转账并发读取同一账户旧余额,各自计算再写回,可能用过期值覆盖另一笔结果,使扣减与入账不对应。课程手工事务示例正因读与写之间可能发生变化,才比较from、to的修订。问题在于跨账户状态更新缺乏共同一致性边界;这里不把一次RPC成功当作两边余额正确。 深入机制与原文位置见并发余额覆盖使转账失真。

手工转账先读两账户及ModRevision,检查余额,再用一个事务比较两键修订并同时写入扣减和增加。竞争使修订不匹配时Succeeded=false,不应认作已转账。课程代码有Kvs[1]、拼写和括号错误,只取其协议思路;实际还需校验缺失账户、金额范围及转换错误。 深入机制与原文位置见修订比较保护转账整体提交。

课程STM示例初始化五个账户各100,共500,十个worker各执行100轮,从随机账户向另一账户转出一半;同一apply内读取并写入两边,以事务共同提交。结束后校验总额,是此示例的不变量检查,不足以证明生产交易具备幂等、无溢出或每笔都符合授权。此处是方案演示,未在本次实际运行。 深入机制与原文位置见事务内转账维护总额守恒。

原书依据 · 5 处

S211 20-在分布式环境中,队列、栅栏和STM该如何实现? / 总结

把选举、锁或事务交给成熟协调服务,仍需要运维能力、可用性及性能评估。etcd、Redis、MySQL的名字不能证明具体锁协议具有相同故障语义,不能仅按熟悉程度就认定等价。课程的价值是明确基础服务依赖与风险归属,历史生态活跃度评价不当作当前事实。 深入机制与原文位置见协调服务也要有运行保障。

原书依据 · 1 处

S212 20-在分布式环境中,队列、栅栏和STM该如何实现? / 思考题

三节点队列性能测量和STM是否属于分布式事务是开放题。实际测试本次未执行;STM边界以本章多键存储事务为限,不外推为任意跨服务原子提交。

S213 结束语-再聊Go并发编程的价值和精进之路

课程用ASX组合交易软件故障说明并发错误可能造成严重损失,同时明确未看到Bug细节,只推测可能为并发问题。因此这段不能作为已证实竞态根因或某种资金竞态机制的案例。记录事故影响与归因时应保持证据层级,不用技术直觉补全缺失事实。 深入机制与原文位置见事故根因须区分推测与证据。

课程以火星探路者优先级反转故事说明,重载条件下低频出现的调度缺陷若被低估,可能在关键任务运行时产生高代价。频率与损害程度应分别评估,测试难复现不等于可以忽略。历史事件的具体过程以原文叙述为限,不把本次阅读冒充独立事故调查。 深入机制与原文位置见低频并发缺陷也有高后果。

知识导图适合回顾模块与关联,遇到不能解释的点再回到原文和实现;摘录后写自己的理解,才能检查学习是否能转化为输出。记得API名称不等于能解释使用边界。开放了解新技术与主动筛选注意力可以并行,投入深度仍需按目标选择。 深入机制与原文位置见学习要形成可输出的解释。

原书依据 · 3 处

跨章综合

“取得资格”“动作完成”和“业务成功”要分开:CAS成功只表明状态替换发生,Once完成不证明连接建立成功,WaitGroup归零依赖登记和Done协议,SingleFlight共享标记也不表示本次执行了函数。明确每个返回值的责任,可以减少把控制分支错认成业务结果。

“共享结构安全”也有边界。锁包装map只保护单次访问,Channel发送引用不会深复制数据,atomic.Value发布不保护可变成员,Pool安全取还不允许借出对象继续被多方改写。同步不变量必须覆盖真正共享的对象及完整操作。

等待与退出同样不能混淆:超时让调用者不再等,取消信号仍需工作响应;扇入扇出需要关闭责任,队列Close必须唤醒等待者,加权许可需要失败后完整归还。分布式环境再增加会话和网络失败,成熟协调服务能缩小实现范围,但不能把业务失败边界交给一个接口名。

发散与实践

读者延伸:已选择官方x/sync的加权许可取消交接,以及etcd STM的冲突重试作为两项实现深读。实践卡保存固定版本、实际读取首轮材料、书中机制映射和两层计划;尚未部署etcd、运行测试或完成后续完整实践,不把源码阅读当作实测通过。

生成进度与管理记录

Go并发编程实战 (汪明)

Skill版本:book-notes v23

执行模式:light

建档进度:done

身份核验:文件名与OPF署名汪明,但spine3、10正文讲师明确为晁岳攀(鸟窝),实际内容为其极客时间20讲课程。保留目录名追溯输入,结构化作者采用正文身份;冲突的ISBN、日期、版次均null。

评级:工程实践;互斥公平性、取消与完成分离具有迁移性,但内部状态布局、扩展库API和etcd路径依赖版本。已据全文收束;主形态为概念解析型,局部问题与API说明按其实际结构取材。

章节进度追踪表

章节号 章节标题 状态(pending/done) 卡片数
S004 简介 / 课程介绍 done 0
S005 简介 / 课程模块设计 done 0
S010 开篇词-想吃透Go并发编程,你得这样学! done 0
S011 开篇词-想吃透Go并发编程,你得这样学! / 并发编程,为什么选Go? done 0
S012 开篇词-想吃透Go并发编程,你得这样学! / 学习Go并发编程,有哪些困难? done 0
S013 开篇词-想吃透Go并发编程,你得这样学! / 怎么提升Go并发编程能力? done 1
S014 01-Mutex:如何解决资源并发访问问题? done 1
S015 01-Mutex:如何解决资源并发访问问题? / 互斥锁的实现机制 done 3
S016 01-Mutex:如何解决资源并发访问问题? / Mutex的基本使用方法 done 4
S017 01-Mutex:如何解决资源并发访问问题? / 总结 done 0
S018 01-Mutex:如何解决资源并发访问问题? / 思考题 done 0
S019 02-Mutex:庖丁解牛看实现 done 0
S020 02-Mutex:庖丁解牛看实现 / 初版的互斥锁 done 3
S021 02-Mutex:庖丁解牛看实现 / 给新人机会 done 1
S022 02-Mutex:庖丁解牛看实现 / 多给些机会 done 1
S023 02-Mutex:庖丁解牛看实现 / 解决饥饿 done 1
S024 02-Mutex:庖丁解牛看实现 / 饥饿模式和正常模式 done 2
S025 02-Mutex:庖丁解牛看实现 / 总结 done 1
S026 02-Mutex:庖丁解牛看实现 / 思考题 done 0
S027 03|Mutex:4种易错场景大盘点 done 0
S028 03|Mutex:4种易错场景大盘点 / 常见的4种错误场景 done 0
S029 03|Mutex:4种易错场景大盘点 / Lock/Unlock不是成对出现 done 1
S030 03|Mutex:4种易错场景大盘点 / Copy已使用的Mutex done 1
S031 03|Mutex:4种易错场景大盘点 / 重入 done 3
S032 03|Mutex:4种易错场景大盘点 / 死锁 done 2
S033 03|Mutex:4种易错场景大盘点 / 流行的Go开发项目踩坑记 done 2
S034 03|Mutex:4种易错场景大盘点 / Kubernetes done 1
S035 03|Mutex:4种易错场景大盘点 / gRPC done 1
S036 03|Mutex:4种易错场景大盘点 / etcd done 1
S037 03|Mutex:4种易错场景大盘点 / issue 10419 done 1
S038 03|Mutex:4种易错场景大盘点 / 总结 done 1
S039 03|Mutex:4种易错场景大盘点 / 思考题 done 0
S040 04|Mutex:骇客编程,如何拓展额外功能? done 0
S041 04|Mutex:骇客编程,如何拓展额外功能? / TryLock done 2
S042 04|Mutex:骇客编程,如何拓展额外功能? / 获取等待者的数量等指标 done 1
S043 04|Mutex:骇客编程,如何拓展额外功能? / 使用Mutex实现一个线程安全的队列 done 1
S044 04|Mutex:骇客编程,如何拓展额外功能? / 总结 done 0
S045 04|Mutex:骇客编程,如何拓展额外功能? / 思考题 done 0
S046 05|RWMutex:读写锁的实现原理及避坑指南 done 0
S047 05|RWMutex:读写锁的实现原理及避坑指南 / 什么是RWMutex? done 2
S048 05|RWMutex:读写锁的实现原理及避坑指南 / RWMutex的实现原理 done 1
S049 05|RWMutex:读写锁的实现原理及避坑指南 / RLock/RUnlock的实现 done 1
S050 05|RWMutex:读写锁的实现原理及避坑指南 / Lock done 1
S051 05|RWMutex:读写锁的实现原理及避坑指南 / Unlock done 0
S052 05|RWMutex:读写锁的实现原理及避坑指南 / RWMutex的3个踩坑点 done 1
S053 05|RWMutex:读写锁的实现原理及避坑指南 / 坑点2:重入导致死锁 done 2
S054 05|RWMutex:读写锁的实现原理及避坑指南 / 坑点3:释放未加锁的RWMutex done 1
S055 05|RWMutex:读写锁的实现原理及避坑指南 / 流行的Go开发项目中的坑 done 0
S056 05|RWMutex:读写锁的实现原理及避坑指南 / Docker done 1
S057 05|RWMutex:读写锁的实现原理及避坑指南 / Kubernetes done 1
S058 05|RWMutex:读写锁的实现原理及避坑指南 / 总结 done 0
S059 05|RWMutex:读写锁的实现原理及避坑指南 / 思考题 done 0
S060 06-WaitGroup:协同等待,任务编排利器 done 0
S061 06-WaitGroup:协同等待,任务编排利器 / WaitGroup的基本用法 done 1
S062 06-WaitGroup:协同等待,任务编排利器 / WaitGroup的实现 done 2
S063 06-WaitGroup:协同等待,任务编排利器 / 使用WaitGroup时的常见错误 done 3
S064 06-WaitGroup:协同等待,任务编排利器 / noCopy:辅助vet检查 done 1
S065 06-WaitGroup:协同等待,任务编排利器 / 流行的Go开发项目中的坑 done 1
S066 06-WaitGroup:协同等待,任务编排利器 / 总结 done 0
S067 06-WaitGroup:协同等待,任务编排利器 / 思考题 done 0
S068 07-Cond:条件变量的实现机制及避坑指南 done 0
S069 07-Cond:条件变量的实现机制及避坑指南 / Go标准库的Cond done 1
S070 07-Cond:条件变量的实现机制及避坑指南 / Cond的基本用法 done 1
S071 07-Cond:条件变量的实现机制及避坑指南 / Cond的实现原理 done 1
S072 07-Cond:条件变量的实现机制及避坑指南 / 使用Cond的2个常见错误 done 1
S073 07-Cond:条件变量的实现机制及避坑指南 / 知名项目中Cond的使用 done 2
S074 07-Cond:条件变量的实现机制及避坑指南 / 总结 done 0
S075 07-Cond:条件变量的实现机制及避坑指南 / 思考题 done 0
S076 08-Once:一个简约而不简单的并发原语 done 1
S077 08-Once:一个简约而不简单的并发原语 / Once的使用场景 done 1
S078 08-Once:一个简约而不简单的并发原语 / 如何实现一个Once? done 1
S079 08-Once:一个简约而不简单的并发原语 / 使用Once可能出现的2种错误 done 1
S080 08-Once:一个简约而不简单的并发原语 / 第二种错误:未初始化 done 3
S081 08-Once:一个简约而不简单的并发原语 / Once的踩坑案例 done 1
S082 08-Once:一个简约而不简单的并发原语 / 总结 done 1
S083 08-Once:一个简约而不简单的并发原语 / 思考题 done 0
S084 09-map:如何实现线程安全的map类型? done 1
S085 09-map:如何实现线程安全的map类型? / map的基本使用方法 done 3
S086 09-map:如何实现线程安全的map类型? / 使用map的2种常见错误 done 2
S087 09-map:如何实现线程安全的map类型? / 如何实现线程安全的map类型? done 2
S088 09-map:如何实现线程安全的map类型? / 应对特殊场景的sync.Map done 4
S089 09-map:如何实现线程安全的map类型? / 总结 done 0
S090 09-map:如何实现线程安全的map类型? / 思考题 done 0
S091 10-Pool:性能提升大杀器 done 0
S092 10-Pool:性能提升大杀器 / sync.Pool done 1
S093 10-Pool:性能提升大杀器 / sync.Pool的使用方法 done 1
S094 10-Pool:性能提升大杀器 / 实现原理 done 2
S095 10-Pool:性能提升大杀器 / sync.Pool的坑 done 2
S096 10-Pool:性能提升大杀器 / 第三方库 done 2
S097 10-Pool:性能提升大杀器 / 连接池 done 1
S098 10-Pool:性能提升大杀器 / 标准库中的http client池 done 1
S099 10-Pool:性能提升大杀器 / TCP连接池 done 1
S100 10-Pool:性能提升大杀器 / 数据库连接池 done 1
S101 10-Pool:性能提升大杀器 / Memcached Client连接池 done 1
S102 10-Pool:性能提升大杀器 / Worker Pool done 2
S103 10-Pool:性能提升大杀器 / 总结 done 0
S104 10-Pool:性能提升大杀器 / 思考题 done 0
S105 11-Context:信息穿透上下文 done 0
S106 11-Context:信息穿透上下文 / Context的来历 done 1
S107 11-Context:信息穿透上下文 / Context基本使用方法 done 2
S108 11-Context:信息穿透上下文 / 创建特殊用途Context的方法 done 0
S109 11-Context:信息穿透上下文 / WithValue done 1
S110 11-Context:信息穿透上下文 / WithCancel done 2
S111 11-Context:信息穿透上下文 / WithTimeout done 0
S112 11-Context:信息穿透上下文 / WithDeadline done 1
S113 11-Context:信息穿透上下文 / 总结 done 1
S114 11-Context:信息穿透上下文 / 思考题 done 0
S115 12-atomic:要保证原子操作,一定要使用这几种方法 done 0
S116 12-atomic:要保证原子操作,一定要使用这几种方法 / 原子操作的基础知识 done 1
S117 12-atomic:要保证原子操作,一定要使用这几种方法 / atomic原子操作的应用场景 done 1
S118 12-atomic:要保证原子操作,一定要使用这几种方法 / atomic提供的方法 done 0
S119 12-atomic:要保证原子操作,一定要使用这几种方法 / Add done 1
S120 12-atomic:要保证原子操作,一定要使用这几种方法 / CAS (CompareAndSwap) done 1
S121 12-atomic:要保证原子操作,一定要使用这几种方法 / Swap done 1
S122 12-atomic:要保证原子操作,一定要使用这几种方法 / Load done 0
S123 12-atomic:要保证原子操作,一定要使用这几种方法 / Store done 0
S124 12-atomic:要保证原子操作,一定要使用这几种方法 / Value类型 done 2
S125 12-atomic:要保证原子操作,一定要使用这几种方法 / 第三方库的扩展 done 1
S126 12-atomic:要保证原子操作,一定要使用这几种方法 / 使用atomic实现Lock-Free queue done 2
S127 12-atomic:要保证原子操作,一定要使用这几种方法 / 总结 done 1
S128 12-atomic:要保证原子操作,一定要使用这几种方法 / 思考题 done 0
S129 13-Channel:另辟蹊径,解决并发问题 done 0
S130 13-Channel:另辟蹊径,解决并发问题 / Channel的发展 done 1
S131 13-Channel:另辟蹊径,解决并发问题 / Channel的应用场景 done 1
S132 13-Channel:另辟蹊径,解决并发问题 / Channel基本用法 done 3
S133 13-Channel:另辟蹊径,解决并发问题 / Channel的实现原理 done 0
S134 13-Channel:另辟蹊径,解决并发问题 / chan数据结构 done 1
S135 13-Channel:另辟蹊径,解决并发问题 / 初始化 done 1
S136 13-Channel:另辟蹊径,解决并发问题 / send done 1
S137 13-Channel:另辟蹊径,解决并发问题 / recv done 1
S138 13-Channel:另辟蹊径,解决并发问题 / close done 1
S139 13-Channel:另辟蹊径,解决并发问题 / 使用Channel容易犯的错误 done 1
S140 13-Channel:另辟蹊径,解决并发问题 / 它们踩过的坑 done 2
S141 13-Channel:另辟蹊径,解决并发问题 / 总结 done 0
S142 13-Channel:另辟蹊径,解决并发问题 / 思考题 done 0
S143 14-Channel:透过代码看典型的应用模式 done 0
S144 14-Channel:透过代码看典型的应用模式 / 使用反射操作Channel done 1
S145 14-Channel:透过代码看典型的应用模式 / 典型的应用场景 done 0
S146 14-Channel:透过代码看典型的应用模式 / 消息交流 done 1
S147 14-Channel:透过代码看典型的应用模式 / 数据传递 done 1
S148 14-Channel:透过代码看典型的应用模式 / 信号通知 done 1
S149 14-Channel:透过代码看典型的应用模式 / 锁 done 1
S150 14-Channel:透过代码看典型的应用模式 / 任务编排 done 6
S151 14-Channel:透过代码看典型的应用模式 / 总结 done 0
S152 14-Channel:透过代码看典型的应用模式 / 思考题 done 0
S153 15-内存模型:Go如何保证并发读写的顺序? done 1
S154 15-内存模型:Go如何保证并发读写的顺序? / 重排和可见性的问题 done 1
S155 15-内存模型:Go如何保证并发读写的顺序? / happens-before done 1
S156 15-内存模型:Go如何保证并发读写的顺序? / Go语言中保证的happens-before关系 done 0
S157 15-内存模型:Go如何保证并发读写的顺序? / init函数 done 1
S158 15-内存模型:Go如何保证并发读写的顺序? / goroutine done 1
S159 15-内存模型:Go如何保证并发读写的顺序? / Channel done 2
S160 15-内存模型:Go如何保证并发读写的顺序? / Mutex/RWMutex done 1
S161 15-内存模型:Go如何保证并发读写的顺序? / WaitGroup done 1
S162 15-内存模型:Go如何保证并发读写的顺序? / Once done 1
S163 15-内存模型:Go如何保证并发读写的顺序? / atomic done 1
S164 15-内存模型:Go如何保证并发读写的顺序? / 总结 done 0
S165 15-内存模型:Go如何保证并发读写的顺序? / 思考题 done 0
S166 16-Semaphore:一篇文章搞懂信号量 done 0
S167 16-Semaphore:一篇文章搞懂信号量 / 信号量是什么?都有什么操作? done 1
S168 16-Semaphore:一篇文章搞懂信号量 / P/V操作 done 1
S169 16-Semaphore:一篇文章搞懂信号量 / Go官方扩展库的实现 done 3
S170 16-Semaphore:一篇文章搞懂信号量 / 使用信号量的常见错误 done 1
S171 16-Semaphore:一篇文章搞懂信号量 / 其它信号量的实现 done 1
S172 16-Semaphore:一篇文章搞懂信号量 / 总结 done 0
S173 16-Semaphore:一篇文章搞懂信号量 / 思考题 done 0
S174 17-SingleFlight和CyclicBarrier:请求合并和循环栅栏该怎么用? done 0
S175 17-SingleFlight和CyclicBarrier:请求合并和循环栅栏该怎么用? / 请求合并SingleFlight done 1
S176 17-SingleFlight和CyclicBarrier:请求合并和循环栅栏该怎么用? / 实现原理 done 1
S177 17-SingleFlight和CyclicBarrier:请求合并和循环栅栏该怎么用? / 应用场景 done 1
S178 17-SingleFlight和CyclicBarrier:请求合并和循环栅栏该怎么用? / 循环栅栏CyclicBarrier done 1
S179 17-SingleFlight和CyclicBarrier:请求合并和循环栅栏该怎么用? / 实现原理 done 1
S180 17-SingleFlight和CyclicBarrier:请求合并和循环栅栏该怎么用? / 并发趣题:一氧化二氢制造工厂 done 1
S181 17-SingleFlight和CyclicBarrier:请求合并和循环栅栏该怎么用? / 总结 done 1
S182 17-SingleFlight和CyclicBarrier:请求合并和循环栅栏该怎么用? / 思考题 done 0
S183 18-分组操作:处理一组子任务,该用什么并发原语? done 0
S184 18-分组操作:处理一组子任务,该用什么并发原语? / ErrGroup done 0
S185 18-分组操作:处理一组子任务,该用什么并发原语? / 基本用法 done 1
S186 18-分组操作:处理一组子任务,该用什么并发原语? / ErrGroup使用例子 done 2
S187 18-分组操作:处理一组子任务,该用什么并发原语? / 扩展库 done 2
S188 18-分组操作:处理一组子任务,该用什么并发原语? / 其它实用的Group并发原语 done 1
S189 18-分组操作:处理一组子任务,该用什么并发原语? / gollback done 3
S190 18-分组操作:处理一组子任务,该用什么并发原语? / Hunch done 2
S191 18-分组操作:处理一组子任务,该用什么并发原语? / schedgroup done 1
S192 18-分组操作:处理一组子任务,该用什么并发原语? / 总结 done 0
S193 18-分组操作:处理一组子任务,该用什么并发原语? / 思考题 done 0
S194 19-在分布式环境中,Leader选举、互斥锁和读写锁该如何实现? done 1
S195 19-在分布式环境中,Leader选举、互斥锁和读写锁该如何实现? / Leader选举 done 1
S196 19-在分布式环境中,Leader选举、互斥锁和读写锁该如何实现? / 选举 done 1
S197 19-在分布式环境中,Leader选举、互斥锁和读写锁该如何实现? / 查询 done 1
S198 19-在分布式环境中,Leader选举、互斥锁和读写锁该如何实现? / 监控 done 1
S199 19-在分布式环境中,Leader选举、互斥锁和读写锁该如何实现? / 互斥锁 done 0
S200 19-在分布式环境中,Leader选举、互斥锁和读写锁该如何实现? / Locker done 1
S201 19-在分布式环境中,Leader选举、互斥锁和读写锁该如何实现? / Mutex done 1
S202 19-在分布式环境中,Leader选举、互斥锁和读写锁该如何实现? / 读写锁 done 1
S203 19-在分布式环境中,Leader选举、互斥锁和读写锁该如何实现? / 总结 done 0
S204 19-在分布式环境中,Leader选举、互斥锁和读写锁该如何实现? / 思考题 done 0
S205 20-在分布式环境中,队列、栅栏和STM该如何实现? done 0
S206 20-在分布式环境中,队列、栅栏和STM该如何实现? / 分布式队列和优先级队列 done 2
S207 20-在分布式环境中,队列、栅栏和STM该如何实现? / 分布式栅栏 done 0
S208 20-在分布式环境中,队列、栅栏和STM该如何实现? / Barrier:分布式栅栏 done 1
S209 20-在分布式环境中,队列、栅栏和STM该如何实现? / DoubleBarrier:计数型栅栏 done 1
S210 20-在分布式环境中,队列、栅栏和STM该如何实现? / STM done 5
S211 20-在分布式环境中,队列、栅栏和STM该如何实现? / 总结 done 1
S212 20-在分布式环境中,队列、栅栏和STM该如何实现? / 思考题 done 0
S213 结束语-再聊Go并发编程的价值和精进之路 done 3

非正文排除

spine项 类型 排除理由
0 非正文 封面,无技术正文
1 非正文 纯目录
2 非正文 课程营销收益列表
3 非正文 讲师履历,保留身份核验但不生成技术卡
6 非正文 图形课程目录
7 非正文 读者先修条件
8 非正文 福利及活动广告
9 非正文 订阅与价格条款

待关联术语

术语名 出现章节 一句话语境
哲学家就餐问题 S032 作为死锁经典题的提名,未在此展开完整算法
TiDB S039 开放练习要求查找其锁问题,未给具体结论
Grafana S040 仅用作监控展示工具示例
GPM调度 S213 课程明确未展开,建议课外学习
缓存穿透 S177 与缓存击穿并列提名但没有展开机制
缓存雪崩 S177 仅列缓存问题名称
分布式Channel S151 作为组合可能性的提名,未给实现
事务幂等 S177 对能否合并写操作的开放方向,不补造方案

引用文献

标题 类型(书/论文/框架/源码项目) 出现章节 一句话语境
Understanding Real-World Concurrency Bugs in Go 论文 S015 并发缺陷背景研究
petermattis/goid 源码项目 S031 获取goroutine标识的扩展入口
go-deadlock 源码项目 S038 局部死锁诊断工具线索
go-tools 源码项目 S038 并发检查工具提名
timedmap 框架 S089 带过期的映射拓展阅读
treemap 框架 S089 键有序的映射拓展阅读
net/rpc 源码项目 S104 请求复用的开放源码练习
Context isn’t for cancellation 论文 S106 关于上下文职责的观点文章
Context should go away for Go 2 论文 S106 上下文接口争议文章
Lockless Programming Considerations for Xbox 360 and Microsoft Windows 论文 S117 无锁结构延伸阅读
Michael与Scott 1996队列论文 论文 S126 课程队列算法来源,未独立通读该论文
containerd/stargz-snapshotter 源码项目 S187 信号量限并发用法提名
go-waitgroup 源码项目 S192 同类原语拓展入口
Go语言原本:并发调度 书 S213 课程未覆盖调度时的拓展材料
Concurrency in Go 书 S213 并发基础和模式补充读物
Go Concurrency Patterns 论文 S213 官方技术分享补充入口
Advanced Go Concurrency Patterns 论文 S213 官方技术分享补充入口
panjf2000/ants 源码项目 S102 仅列为扩展阅读或使用者,没有在此讲解其内部机制
Jeffail/tunny 源码项目 S102 仅列为扩展阅读或使用者,没有在此讲解其内部机制
benmanns/goworker 源码项目 S102 仅列为扩展阅读或使用者,没有在此讲解其内部机制
go-playground/pool 源码项目 S102 仅列为扩展阅读或使用者,没有在此讲解其内部机制
Sherifabdlnaby/gpool 源码项目 S102 仅列为扩展阅读或使用者,没有在此讲解其内部机制
pond 源码项目 S102 仅列为扩展阅读或使用者,没有在此讲解其内部机制
CockroachDB 源码项目 S177 仅列为扩展阅读或使用者,没有在此讲解其内部机制
CoreDNS 源码项目 S177 仅列为扩展阅读或使用者,没有在此讲解其内部机制

资金安全问题案例

问题标题 问题卡 解决方案卡(如有) 出现章节 一句话说明
账户并发更新失真 [[账户并发更新缺少互斥会失真]] [[共同临界区互斥保护更新]] S014、S015 问题与进程内互斥通用方案成对;不声称完整支付事务
转账旧余额覆盖 [[并发余额覆盖使转账失真]] [[修订比较保护转账整体提交]] S210 问题与修订条件事务成对,另有STM守恒方案卡
STM多账户转账 — [[事务内转账维护总额守恒]] S210 原文仅提供事务方案与守恒验证,不虚构另一事故

整书笔记

阅读与生成:206项正文、8项有据排除;198张知识卡,全部逐卡primary与真实来源。89图OCR及22关键图视觉检查,不执行生成后复核。

生成时校准及出版信息边界

  • 已实际读取原始PR说明并核对课程截图:Kubernetes PR 62464修复重复RLock,课程正文“内部写锁”描述已校正。
  • Go atomic官方文档已定义顺序一致语义及Value新增API;sync官方文档列出Go1.18的TryLock;Context文档区分取消与等待完成。访问日期2026-10-26。
  • 结构化作者据正文讲师自述;OPF汪明、ISBN9787302560449、文件日期不作为该课程可靠出版身份。

实践卡进度

序号 实践标题 实践方式 状态(pending/done) 关联章节 产出
1 核对许可取消与资源归还 实现深读 done 16 ideas/idea-001-核对许可取消与资源归还.md;首轮源码、映射和两层计划已准备
2 读转账冲突与回调重试 实现深读 done 20 ideas/idea-002-读转账冲突与回调重试.md;首轮源码、映射和两层计划已准备

实践候选筛选:done

未采用原因:未另造锁、工作池或Channel完整实现;先以官方实现回答取消交接和事务重试。SingleFlight源码也作了首轮对照,但未单列第三张计划,避免扩大本轮实践范围。没有执行后续完整实践。

相关主题

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

暂无公开主题。