技术志 - Tony Bai

分类技术志下的文章

老板花重金买了台 128 核服务器，我的 Go 程序反而变慢了？

三月 12, 2026
0 条评论

本文永久链接 – https://tonybai.com/2026/03/12/go-concurrency-scalability-issues-on-128-core-cpu

大家好，我是Tony Bai。

设想一个极其真实的职场场景：

你负责的 Go 核心微服务最近流量暴涨，CPU 频频告警。为了解决这个问题，老板大笔一挥，批了几十万预算，采购了最新一代的 128 核 256 线程的怪兽级服务器（比如 AMD EPYC 或 Intel 至强）。

你满心欢喜地把程序部署上去，期待着 QPS 翻倍、延迟减半的奇迹。

结果盯着监控面板，你傻眼了：核心数翻了 4 倍，但程序的吞吐量根本没有线性增长，甚至 P99 延迟还比以前在 32 核机器上时变高了！

老板拍着你的肩膀问：“这服务器是不是买亏了？”你满头大汗，不知道问题出在哪。

别慌，这可能真不是你代码写得烂。在 2026 年的今天，随着芯片制程逐渐逼近物理极限（2nm），单核性能基本停滞，硬件厂商只能疯狂“堆核心”。这就导致了一个在过去只有超算中心才会关心的底层概念，如同幽灵般降临到了每一个普通开发者头上——NUMA（非一致性内存访问）架构。

今天，我们就来拆解一下：为什么 Go 语言引以为傲的并发模型，在超多核时代开始“水土不服”？而 Go 核心团队，又打算在今年如何打赢这场史诗级的性能翻身仗？

Go 调度器的“间歇性失忆症”

在小几十核（比如 32 核及以内）的普通机器上，Go 的 GMP 调度模型（Goroutine – Processor – Machine）堪称完美。调度器会尽量让一个 Goroutine (G) 在同一个 Processor (P) 和同一个系统线程 (M) 上运行，以保证 CPU 缓存（L1/L2 Cache）的高命中率。

但在 128 核/256线程(Go眼中 NumCPU()返回 256)的庞然大物上，这种亲和性（Affinity）被极其残酷地撕裂了。

一个值得怀疑的原因是 GC（垃圾回收）带来的 STW（Stop The World）。

每次 GC 开始和结束时，世界都会短暂停止，所有的 P 都会被冻结。当几毫秒后世界重新启动时，Go 的调度器会得一种“失忆症”：它会把“复活”的 P 分配给任意空闲的 M。

这就好比你原本在工位 A 办公，桌上摆满了你需要的资料（CPU Cache 中的热数据）。突然老板喊停，重新洗牌，把你随机分配到了工位 B。你需要重新跨过大半个办公室去搬资料（导致极其严重的 Cache Miss）。

此外，GC 标记工作在 STW 期间启动，并以高优先级调度，这使得它们很可能在之前运行 G 的 P 上运行，即使有空闲的 P。这会迫使 G 迁移到另一个 P 上。

如果你打开 Go 的 Execution Trace，你会看到一幅灾难般的景象：短短 10 毫秒内，你的 Goroutine 就像弹珠一样，在 128 个 CPU 核心之间来回横跳(下面是一个开发者在真实环境采集到的数据, G11到G19在多个P上切换)。微秒级的跳跃积累起来，就成了吞噬性能的黑洞。

NUMA 架构下的双倍“跨省流量”惩罚

如果说缓存失效是“切肤之痛”，那么NUMA 架构带来的内存惩罚，就是真正的“断骨之痛”。

在 128 核这种级别的 CPU 里，物理内存是被划分成多个“大区（NUMA Node，简称Node，每个Node通常有16到64个CPU核）”的。

CPU 访问自己大区的内存，极快。
CPU 跨大区去访问别人的内存（Remote Node），延迟会瞬间飙升 2 倍甚至更多！

但问题是，目前的 Go 语言是“非 NUMA 感知”的！

当你的代码执行 new(struct) 申请内存时，Go 的全局自由列表（Global Free List）完全可能把一块物理位置位于 Node 1 的内存，分配给正在 Node 0 上运行的 CPU。结果就是，你之后的每一次内存读写，都在交高昂的“跨省长途费”。

更要命的是 Go 引以为傲的“工作窃取（Work-Stealing）”算法。

当某个 CPU 核心闲下来时，它会去偷别的核心队列里的 Goroutine 来执行。这在以前是神来之笔，但在 NUMA 时代却成了毒药：

它把任务偷了过来，但任务对应的数据还留在原来的 NUMA 节点上！这就好比你抢了别人的砖头搬，但你每次都得跨越一整个城市去拿砖。

面对 2 倍以上的内存访问物理延迟，你写再多牛逼的设计模式，也无济于事。

针对上述问题，Go 1.25 和 1.26 已带来部分改进（容器感知的 GOMAXPROCS、Green Tea GC），NUMA 感知的内存分配等更深层优化仍在 Go 1.27以及后续版本的规划中。

2026 年，Go 团队的破局之战

面对这台越来越难以驾驭的硬件巨兽，Go 核心团队当然没有坐以待毙。在 Go 的官方 issue（#65694, #78044）中，核心成员 Michael Pratt 已经明确表态：解决超高核数和 NUMA 下的性能瓶颈，是今年 Go 团队的头等任务之一。

我们即将看到 Go 团队打出的几记重拳：

修复“失忆症”（强化亲和性锁链）

就在去年10月份，Go 团队合并了一个关键的底层补丁（CL 714801）。现在，STW 结束后，runtime 会拼命尝试将 P 重新分配给它在 STW 之前绑定的那个 M。把你牢牢按在原来的工位上，死死护住你的 CPU Cache。

驯服 GC 抢占（减少驱逐）

新的调度逻辑将尽量避免 GC worker “鸠占鹊巢”，强行驱逐正在运行业务逻辑的 Goroutine，保证业务代码执行环境的连贯性。

探索 NUMA 感知的内存分配（软性偏好）

这是目前最艰难但也最激动人心的探索。未来的 Go 有望实现：优先在本地 NUMA 节点分配内存；工作窃取时，优先偷取同一个 NUMA 节点内的任务。彻底斩断无意义的“跨省流量”。

小结：云原生开发者的自我修养

在摩尔定律彻底失效的今天，硬件发展的路线图已经极其明确：单核停滞，核心数将向 256 核、512 核无限狂飙。

这给我们所有 Go 开发者敲响了警钟：

在极致的性能调优面前，我们不能再仅仅满足于写出“业务正确”的代码，更要理解你的代码在真实硬件和操作系统上的物理足迹。

在 Go 1.27 或 Go 1.28 带来这些“性能怪兽级优化”落地之前，如果你发现你的高并发服务在顶级服务器上性能退化，请记住今天这篇文章：

不要急着改代码，先用 top 和 numastat 查一下你的 NUMA 命中率。
极端延迟敏感的场景下，可以临时考虑使用 runtime.LockOSThread() 或利用 cgroups 将进程绑定在特定的 NUMA 节点上运行。

打破对“加机器就能解决一切”的迷信，这是从初级码农走向资深架构师的必经之路。

参考资料

https://github.com/golang/go/issues/65694
https://github.com/golang/go/issues/78044

今日互动探讨：

你在生产环境中，遇到过哪些“加了机器/加了配置，性能反而变差”的诡异玄学事件？后来是怎么排查破解的？

欢迎在评论区分享你的血泪排查史！

还在为“复制粘贴喂AI”而烦恼？我的新专栏 《AI原生开发工作流实战》 将带你：

告别低效，重塑开发范式
驾驭AI Agent(Claude Code)，实现工作流自动化
从“AI使用者”进化为规范驱动开发的“工作流指挥家”

扫描下方二维码，开启你的AI原生开发之旅。

你的Go技能，是否也卡在了“熟练”到“精通”的瓶颈期？

想写出更地道、更健壮的Go代码，却总在细节上踩坑？
渴望提升软件设计能力，驾驭复杂Go项目却缺乏章法？
想打造生产级的Go服务，却在工程化实践中屡屡受挫？

继《Go语言第一课》后，我的《Go语言进阶课》终于在极客时间与大家见面了！

我的全新极客时间专栏《Tony Bai·Go语言进阶课》就是为这样的你量身打造！30+讲硬核内容，带你夯实语法认知，提升设计思维，锻造工程实践能力，更有实战项目串讲。

目标只有一个：助你完成从“Go熟练工”到“Go专家”的蜕变！现在就加入，让你的Go技能再上一个新台阶！

原「Gopher部落」已重装升级为「Go & AI 精进营」知识星球，快来加入星球，开启你的技术跃迁之旅吧！

我们致力于打造一个高品质的 Go 语言深度学习 与 AI 应用探索 平台。在这里，你将获得：

体系化 Go 核心进阶内容: 深入「Go原理课」、「Go进阶课」、「Go避坑课」等独家深度专栏，夯实你的 Go 内功。
前沿 Go+AI 实战赋能: 紧跟时代步伐，学习「Go+AI应用实战」、「Agent开发实战课」、「Agentic软件工程课」、「Claude Code开发工作流实战课」、「OpenClaw实战分享」等，掌握 AI 时代新技能。
星主 Tony Bai 亲自答疑: 遇到难题？星主第一时间为你深度解析，扫清学习障碍。
高活跃 Gopher 交流圈: 与众多优秀 Gopher 分享心得、讨论技术，碰撞思想火花。
独家资源与内容首发: 技术文章、课程更新、精选资源，第一时间触达。

衷心希望「Go & AI 精进营」能成为你学习、进步、交流的港湾。让我们在此相聚，享受技术精进的快乐！欢迎你的加入！

img{512x368}

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。如有需求，请扫描下方公众号二维码，与我私信联系。

你每天敲下的 go func()，藏着这位 92 岁老人的毕生心血

三月 11, 2026
0 条评论

本文永久链接 – https://tonybai.com/2026/03/11/in-memory-of-tony-hoare

大家好，我是Tony Bai。

在这个由代码构建的现代世界里，有些名字如同星辰般指引着航向。但遗憾的是，2026 年 3 月 5 日，其中一颗最明亮的星辰熄灭了。

图灵奖得主、快速排序（Quicksort）发明者、CSP（通信顺序进程）理论之父 Tony Hoare（托尼·霍尔）与世长辞，享年 92 岁。

也许你并不熟悉这个名字。但只要你是一个程序员，你就一定在面试时手写过他发明的快速排序；如果你是一个 Go 开发者，那你每天在键盘上敲下的每一个 go func() 和 make(chan int)，都在调用着他留给这个世界的伟大的遗产。

今天，让我们暂时放下手头的 CRUD，跨越半个世纪的时间洪流，去看看这位非典型天才，是如何用他那近乎神迹的洞察力，赐予了 Go 语言制霸云原生时代的“并发灵魂”。

被“共享内存”支配的黑暗时代

在讲 Tony Hoare 有多伟大之前，我们必须先回忆一下，在他提出那套神级理论之前，程序员们在并发编程的泥潭里经历了怎样暗无天日的挣扎。

随着多核时代的到来，程序需要同时执行多个任务。传统的思路极其简单粗暴：共享内存（Shared Memory）。

一堆线程就像一群饿狼，死死盯着同一块内存区域。为了防止数据被写乱，程序员们被迫发明了互斥锁（Mutex）、信号量（Semaphore）。你必须极其小心地、以上帝视角去加锁、读写、释放锁。

只要你稍有不慎，忘记解锁，或者加锁顺序反了，死锁（Deadlock）和竞态条件（Race Condition） 就会像幽灵一样找上门来。程序在本地跑得好好的，一上生产环境就离奇崩溃，且极难复现、极难调试。

那是一个属于并发编程的“黑暗时代”。天下程序员苦“共享内存与锁”久矣，却找不到破局之法。

从古典哲学到“六便士的赌注”

就在整个计算机科学界在锁的泥潭里打滚时，Tony Hoare 站了出来。

有趣的是，Tony 并非科班出身。他在大学修读的竟然是古典学与哲学，后来又在皇家海军服役期间接受了高强度的俄语训练。这种看似“不务正业”的跨学科背景，赋予了他极其严密的逻辑思辨能力和哲学视角的解构能力。

他年轻时有个极其经典的轶事：在一家公司打工时，老板让他实现 Shellsort（希尔排序）。Tony 完成任务后，怯生生地对老板说：“我知道一种比这快得多的算法。” 老板不屑一顾：“我跟你赌六便士（大约几毛钱），你肯定不知道！”

于是，Tony 写出了那个后来被印在全世界每一本数据结构教材里的算法——快速排序（Quicksort）。他不仅赢走了那六便士，还顺手改变了世界。

而在面对并发编程的“绝症”时，Tony 再次展现了他哲学般的降维打击能力。

惊世骇俗的 CSP 理论

1978 年，Tony Hoare 发表了一篇名为《通信顺序进程》（Communicating Sequential Processes, 简称 CSP）的学术论文。

宛如一道闪电，这篇论文劈开了并发编程的混沌。

Tony 的哲学思维告诉他：既然共享内存那么容易出错，那我们干脆就不要共享内存了！

在 CSP 理论中，系统被划分为多个独立的、顺序执行的黑盒（进程）。它们之间没有任何共享状态。当它们需要协作时，唯一的交互方式是通过一条极其明确的管道（Channel）来“发送和接收消息”。

这就像是现实生活中的流水线工人：每个人只管自己手头的活（顺序执行），做完了就通过传送带（Channel）递给下一个人。没人去抢同一个零件，自然就不需要打架（加锁）。

这种高度抽象的数学模型，完美地将复杂的并发控制，降维成了简单的数据流动。

Go 语言与云原生的基石

理论是伟大的，但在 1978 年，CSP 受限于当时的硬件架构，很难大规模工程化普及。它在学术界的象牙塔里，静静等待着一个能将它发扬光大的使者。

30 年后，谷歌的一间办公室里，Rob Pike、Ken Thompson 等几位大神正被 C++ 的并发折磨得痛不欲生。他们决定创造一门新的语言。

由于 Rob Pike 早年深受 CSP 理论启发，他将 Tony Hoare 的毕生心血，直接刻进了这门新语言的基因里。这门语言，就是 Go。

Tony Hoare 论文里的晦涩数学模型，在 Go 语言里被具象化为了两个极其优雅的关键字：

顺序进程，演化成了轻量级的 Goroutine (go func())。
通信管道，演化成了强类型的 Channel (make(chan int))。

Rob Pike 更是将 CSP 的核心思想，提炼成了那句在 Go 圈子里无人不知的至理名言：

“Do not communicate by sharing memory; instead, share memory by communicating.”
（不要通过共享内存来通信，而应该通过通信来共享内存。）

让我们看一眼这被 CSP 灵魂洗礼过的代码，没有任何 sync.Mutex，没有复杂的死锁恐惧，数据的控制权随着流水的管道优雅地传递：

func main() {
    ch := make(chan int) // 创造一条 Tony Hoare 定义的通信管道

    go func() {          // 启动一个 Tony Hoare 定义的顺序进程
        ch <- 42         // 通过通信转移数据
    }()

    fmt.Println(<-ch)    // 完美接收，无需任何锁
}

Tony Hoare 也许没有预料到，他在半个世纪前写下的论文，会在今天成为支撑全球互联网的基石之一。

当我们谈论云原生时代的 Docker、Kubernetes、Prometheus 时，我们谈论的其实是 Go 语言；而当我们惊叹于 Go 语言能轻松扛起千万级的高并发调度时，我们真正应该感谢的，是底层那个名叫 CSP 的幽灵。

我们每一次扩容容器，底层的字节流都在以 Tony Hoare 所描绘的方式，有条不紊地穿梭于硅片与光纤之间。

致敬宗师：最好的纪念，是传承他的思想

Jim Miles 在追忆 Tony 的文章中提到，这位伟大的图灵奖得主极其谦逊。他曾笑着对别人说：“真正的天才不是一蹴而就的，而是在无数个日夜的深度思考中，为了一个单一问题苦苦挣扎的凡人。”

作为普通的开发者，我们无缘与这位伟人共饮下午茶，或听他亲口讲述那六便士的赌注。但作为工程师，我们对宗师最好的纪念，就是停止写那些糟糕的、充满死锁风险的并发代码，去真正理解并传承他的设计哲学。

今天，当你再次在 IDE 中敲下那个简短却充满魔力的 go func() 时，请在心底默默向这位智者致敬。

再见了，一代巨匠 Tony Hoare。

您的代码和算法已是不朽。您赐予计算世界的并发灵魂，将伴随着一代又一代的程序员，在无尽的服务器网络中，永不停止地运行下去。

参考资料

https://en.wikipedia.org/wiki/Communicating_sequential_processes
https://blog.computationalcomplexity.org/2026/03/tony-hoare-1934-2026.html

今日互动：

你在平时的 Go 开发中，是更喜欢用 Channel（CSP 模型）还是更习惯用 Mutex 锁（共享内存模型）？在并发编程中踩过哪些大坑？

欢迎在评论区分享你的心得！

认知跃迁：真正驾驭 Go 的并发灵魂

Tony Hoare 将复杂的并发问题，抽象成了极其优雅的 CSP 理论。但很多 Go 开发者，由于没有看透这层底层哲学，依然在用写 Java/C++（共享内存）的思维来写 Go，最终把 Channel 滥用得一塌糊涂，甚至引发严重的 Goroutine 泄漏。

想要真正吃透 Go 语言的并发灵魂，靠死背语法是绝对不够的。 你必须深入理解底层调度器（G-M-P 模型）是如何运作的，必须明白何时该用 Channel，何时该退回到 Mutex。

如果你渴望突破并发编程的认知瓶颈，不再只做一个“会调关键字”的熟练工，而是想成为能设计出高可用、极高并发架构的 Go 资深专家——

我的极客时间专栏 Go语言进阶课正是为你量身定制。在这 30+ 讲硬核内容中，我将带你剥开语法糖，直击 Go 并发模型的底层骨架，重塑你的系统级架构审美。

扫描下方二维码，加入专栏。让我们用最扎实的工程实践，去向半个世纪前的伟大思想致敬！