铃阅
❌

阅读视图

公司裁掉两个高薪工程师,花2小时教我用AI顶上:“我年薪17万,一个人干三个人的活!”

原创 整理自 2026-11-16 07:15 广东

系统真的不会崩吗??!

最近,Reddit上一篇求助帖在技术圈炸了。截至发稿,这个帖子已经获得了上千赞,引起网友们的激烈讨论。

发帖人Nash是一位西班牙中级系统管理员。前段时间,公司裁掉了两名年薪50多万的资深工程师,再花2小时给年薪17万的他进行Claude Code培训,让他一人包揽三个岗位的活!

这件事听起来非常离谱,但确实在现实中发生了。一起来看看Nash到底经历了什么吧。

一、拿一个人的薪水,靠AI干三个人的活

Nash平时只是负责基础IT运维,公司裁掉一位云架构师和一位全栈开发工程师后,把两人的项目全扔给了他。Nash接触云计算相关工作仅一年,技术水平远不及两位被裁的资深员工。

面对这个他根本接不住的烂摊子,公司的解决方案竟如此简单粗暴:花2小时,教他使用Claude Code。

现在,他不仅要维护项目、写代码、管理云基础设施,还要以惊人的速度交付成果。更离谱的是,这套“赶鸭子上架”的模式,居然靠着Claude Code勉强跑通了。他整理业务资料,为AI搭建公司专属的知识库,借助它生成代码、处理任务。

这世界果然是个草台班子啊!同事们觉得他能力出众,管理层也看到了想要的产出。

从企业的角度看,这简直是AI时代降本增效的完美范本。

因为被裁掉的两名工程师,单人年薪都超过8万美元,而公司现在只需付给Nash 2.6万美元。

二、系统随时会崩,能力也在退化

但这笔省下十多万美元的“完美”账单,最终是由Nash一个人来买单的,他正承受着双重折磨。

第一重,是随时可能爆发的系统灾难。

只有他自己知道,这套系统能跑,几乎靠AI和运气。一旦发生严重故障,承担后果的他一个人。他表示:

“我时刻担心系统哪天突然出故障,到时候所有人会发现,我一直以来都是在靠AI生成的代码和一点运气,才勉强维持系统运转。”

第二重,是技术能力的退化。

AI帮Nash搞定了大量工作,交付效率肉眼可见地提升,但他是越来越烧心:“我确实把活干完了,但我真的学到东西了吗?”他甚至怀疑,如果脱离AI的辅助,自己能不能顺利通过一场初级技术面试?

AI填补了能力缺口,也模糊了成长的边界。他被工具推到了一个看似全能的位置上,但其实他并不清楚自己是否有成长。

现在,他进退两难:当地就业市场形势很差,主动辞职无异于自断生路;可一直留下来,又像是在慢慢消耗、废掉自己的技术能力。

在帖子的最后,他写道:

“如果你觉得这件事是编的,也没关系。我现在真的只是想得到一些建议,拜托了,告诉我到底该怎么办!”

三、Reddit网友的热议

帖子发布后,评论区从一开始就充满了对公司操作的不看好,甚至形成了接龙式吐槽:

“嗯。你在这家公司有点倒霉。”

“这岂止是有点?”

“在这家公司工作的人都完蛋了。”

“因为整个公司都完蛋了。”

不少人分析,这不是正常的降本增效,更像是资金短缺下的垂死挣扎。不懂技术的管理层根本不在乎代码质量和系统风险,只看眼前的人力成本省了多少。

也有人直接给Nash支了谈判的硬招:

“现在你发出最后通牒,要求加薪到8万美元,这是你争取这笔钱的黄金机会。如果他们拒绝,就直接说你要走人,去别的地方找份工程师的工作。他们肯定会醒悟过来,做出让步。”

这条建议下面立刻有人泼冷水,预判公司的下一步:

“接下来他们就会雇个实习生,只给2.5小时的Claude Code培训,用来替代你。”

而Nash后续更新表示,他向经理提出加薪被当场拒绝,没有任何协商余地。网友也劝他别再抱有幻想,并建议他:虽然现在的处境很坑,但他手里其实握着一份含金量极高的履历——一人扛起开发、架构、运维三职。不妨一边应付手头工作,一边投简历找下家。带着这段包揽三职的实战经验跳槽,薪资绝对比现在高得多。

在一片焦虑中,有资深从业者给出了实操建议:不要只做AI的“提示词输入器”。

“你可以利用 AI 真正学东西,去看懂它写的代码、理解架构设计的底层原因。速度慢一点没关系,但要把知识真正变成自己的。”

最后,你觉得Nash应该怎么办?欢迎在评论区讨论!

整理丨dbaplus社群

来源丨网址:https://www.reddit.com/r/ClaudeCode/comments/1xaanlz/my_company_fired_two_highly_paid_engineers_and/

*仅为提供参考和学习交流,不代表dbaplus社群立场!dbaplus社群欢迎广大技术人员投稿,投稿邮箱:editor@dbaplus.cn

跳转微信打开

  •  

直播预告丨全栈可观测实践:从网络到用户一层不落

dbaplus社群 2026-11-14 08:00 广东

系统一卡就各层甩锅?安全事件总是后知后觉?合规报表全靠人工拼凑耗时一周?如果这些状况也是你们的工作常态,是否有考虑过问题可能不在于工具不够多,而是没人把底层数据摆在同一张图上看过。

11月18日(周三)19:00,卓豪ITOM产品专家李芸芸、AD产品部工程师马媛媛将带来《全栈可观测实践:从网络到用户一层不落》主题分享。

两位嘉宾将围绕“从网络到用户的全链路观测”与“从日志到合规的安全运营”,结合真实踩坑案例与事故复盘经验,讲清如何打破多设备、多系统的数据割裂,构建“测-知-行-验”的运维闭环;以及如何穿透日志安全的五层盲区,用AI消除“告警疲劳”,把事后救火变为提前预判,助力运维效率提升,显著降低排障成本与业务中断风险。

届时,直播间还有互动抽奖福利,欢迎预约观看。

活动信息

  • 主题:全栈可观测实践:从网络到用户一层不落

  • 讲师:卓豪 ITOM产品专家 李芸芸

             卓豪 AD产品部工程师 马媛媛

  • 时间:11月18日(周三)19:00

  • 地点:dbaplus社群视频号

直播地址

>>>>

更多直播干货

添加助手加入直播群

跳转微信打开

  •  

一个被称为“失败”的操作系统,为何仍连续运行了33年

原创 huizhou92 2026-11-13 07:15 广东

Multics在工程上从未失败,而Unix的诞生也不是一场有预谋的颠覆。

前言:贝尔实验室放弃了Multics,Unix踩在它的肩膀上诞生。但很多人不知道,这套被放弃的系统其实一直在正常工作,默默运转了三十三年。

这个被大家称为故障的操作系统一直持续运行到2000年10月30日。

2000年10月30日,在加拿大新斯科舍省哈法利克斯的一处国防设施内,加拿大国防部的技术人员拉下了一台老旧大型机的总电闸。

这是地球上最后一台原生运行的Multics系统,就此彻底关机。

那一年,整个软件行业都在为“千年虫(Y2K)”危机而紧张,担心20世纪90年代建设的关键基础设施会在日期翻转时崩溃。而在那座加拿大海岸基地里,那个早在1964年就画下核心架构蓝图的操作系统,悄然完成了它最后一天的运行。

自1967年原型机问世以来,Multics已经在工业和军事计算的前线连续运行了三十三年。

但是,在计算机科学的主流叙事中,Multics几乎总是被当作一个反面教材:一个过度设计的庞然大物,一场失控的学术尝试。而轻巧优雅的Unix,则是踩在它的肩膀上诞生的。

这种“简单战胜复杂”的叙事很符合大众胃口,但它掩盖了两个事实:Multics在工程上从未失败,而Unix的诞生也不是一场有预谋的颠覆。

一、计算公用事业的愿景

Multics的研发项目始于1964年的马萨诸塞州剑桥市。

麻省理工学院的计算机先驱费尔南多·科尔巴托(Fernando Corbató)联合通用电气(GE)和贝尔实验室,共同启动了MAC项目。

当时,人类与计算机的交互还停留在“批处理”时代:程序员将穿孔卡片递进机房窗口,等上几个小时甚至过夜,才能拿到打印机输出的结果。一个逗号放错,一天的工作就白费了。

科尔巴托提出了一个彻底的范式转变:计算公用事业。

在他的愿景中,算力不应只是囤积在地下室的昂贵机器,而是应该像水电一样成为市政设施。中央机房在城市中心运行,线路延伸至各个办公室,工程师们通过终端随时接入算力。 

为了让数百名远程用户同时操作而不受干扰,MAC团队发明了至今仍支撑现代操作系统的架构基础:

  • 第一次将存储介质组织成层级树状目录,也就是今天我们熟知的父子文件夹结构;

  • 发明了Shell,将用户界面与内核内部机制分离;

  • 开创了基于内存映射文件的单级存储,程序员不再需要编写繁琐的磁盘缓冲程序,操作系统直接完成映射。

最激进的是,通用电气专门设计了GE-645大型机,在硬件层面强制引入了“保护环”机制。处理器包含8个特权环:微内核位于Ring 0,系统服务在中间层,用户程序在外围。用户程序一旦试图读取内核内存,CPU硬件会直接拦截并终止操作。

通用电气 GE-645 大型机,为 Multics 定制设计,并于 1967 年交付给麻省理工学院。

这是一个宏大的蓝图。但现实很快给项目泼了冷水。

那个时代的操作系统全靠手写汇编,团队却做了一个冒险的决定:用当时并不成熟的高级语言PL/I编写整个Multics内核。

问题是,当时根本没有生产级的PL/I编译器。麻省理工的学生们只能一边写内核,一边自己造编译器。编译后的代码体积不可控地膨胀,重新编译系统需耗费数小时的大型机机时。按当时的计费标准,每一次测试编译都要花费数百美元。

而GE-645仅有几十万字的物理内存,Multics在上面运行非常吃力。

二、贝尔实验室撤资,通用电气退出

1969年,五年过去了,系统却迟迟无法交付。

贝尔实验室的高管失去了耐心。作为需要对股东负责的工业研究机构,管理层看到的是一个持续烧钱的无底洞。预算超支、硬件交付延期,交付可用的系统似乎遥遥无期。

1969年4月,贝尔实验室宣布退出Multics项目。第二年,通用电气也撑不住了,将计算机业务整体卖给了霍尼韦尔(Honeywell)。

三大支柱倒下了两根,业界普遍认为Multics已经胎死腹中了。

三、废弃PDP-7上的游戏与Unix的诞生

贝尔实验室退出后,GE搬走了那台大型机。一群顶尖研究人员失去了交互式分时环境。

其中有一位30岁的程序员,名叫肯·汤普森(Ken Thompson)。

在参与Multics项目时,汤普森在GE-645上写过一个叫《星际旅行》(Space Travel)的游戏。机器搬走后,他试图在商用GE-635批处理机上跑这个游戏。但他发现,为了在迟钝的终端屏幕上模拟登月,计算中心每次运行要收他75美元。

为了继续玩游戏,汤普森在实验室走廊里找到了一台闲置且落满灰尘的DEC PDP-7小型机。

DEC PDP-7 小型机。 Ken Thompson 和 Dennis Ritchie 在一台废弃的 8K 字机器上引导了 Unix。

这台机器配置极低:内存仅8192个18位字,显示器是粗糙的矢量示波器,而且它连操作系统都没有。

1969年夏天,汤普森的妻子带孩子回加州探亲,给了他一个月在实验室安静敲代码的时间。

他拉来丹尼斯·里奇(Dennis Ritchie)和鲁迪·卡纳迪(Rudd Canaday)。他们没有官方项目授权,没有预算,唯一的目标是用汇编语言在这台废弃机器上写个微型内核,仅仅是为了让《星际旅行》能流畅运行。

他们精简了Multics的特性,保留了层级目录和Shell,扔掉了8层嵌套保护环、PL/I运行环境和虚拟内存映射。

Multics将每个实体视为复杂的结构化对象,而汤普森采取了一种极致的简化:所有资源、设备和文件,统统被视为无结构的字节流。

同事布莱恩·柯林汉(Brian Kernighan)看到这个简陋的单用户系统,开玩笑地将其命名为UNICS(Uniplexed Information and Computing Service),用来调侃Multics的复杂多路复用。后来,拼写演变成了UNIX。

1973 年,肯·汤普森(左)和丹尼斯·里奇在 PDP-11 前。

两者投入的资源天差地别:

  • Multics需要跨国联盟、数百万美元联邦拨款和定制硬件;

  • Unix只需要一台没人要的旧电脑,和一个想玩游戏的程序员。

主流叙事到这里就结束了,它把这个故事包装成了一次极简主义对企业官僚体制的绝对胜利。

但在工业界,故事还有另一面。

四、谁才是真正的失败者?

收购GE计算机业务后,霍尼韦尔并未放弃Multics。他们与麻省理工团队合作,将硬件升级为霍尼韦尔6180,把保护环机制固化到了高速硅片中。

1973年,商业版Multics推出。它的目标客户不是小型软件公司,一套完整的Multics中心标价高达数百万美元。

然而,五角大楼、美国空军、通用动力、福特汽车以及法国大型银行集团却纷纷买单。

在20世纪70和80年代,全球约有80个顶级计算设施运行Multics。它们支撑了西方联盟的关键神经系统:从核弹道模拟、战术空中指挥,到覆盖数万名员工的企业薪资系统。

为什么这些机构宁愿花几百万美元买Multics,也不花点工本费去拿一盘Unix系统的磁带呢?

核心原因只有两个字:安全。

早期的Unix系统经常崩溃,缺乏内部内存隔离,任何人只要猜到root密码就能接管整个系统。

而Multics提供了严格的结构性防御。

1974年,空军委托霍尼韦尔加固Multics内核,实现了强制访问控制(MAC)和正式的多级安全模型。

1985年,美国国家计算机安全中心发布了《可信计算机系统评估标准》(即业界熟知的“橙皮书”)。

根据该标准,绝大多数商业企业系统(包括20年后发布的Windows NT早期版本)只能达到C2级基础安全评级。

而在橙皮书金字塔顶端,一个直接源自Multics的专用系统(STOP 2.1 / SCOMP)拿到了最高评级:A1级(形式化数学验证)。

Multics 命令行登录横幅。从 1967 年到 2000 年,该操作系统一直处于活跃生产状态。

它的内核机制在数学上被证明可以防止权限提升。这种架构后来演化成了军用级XTS-400操作系统。

五、败给商业成本,而非技术架构

为什么Multics最终消失在大众视野中?

不是工程设计的失败,而是硬件商品化的必然结果:Multics被专有硬件绑死了。

运行 Multics,机构必须购买霍尼韦尔价值数百万美元的大型机。

相比之下,丹尼斯·里奇在1973年用C语言重写了Unix。1977年,Unix被移植到Interdata 7/32 上,成功将操作系统与特定CPU解绑。

C语言发挥了极强的跨平台适配作用。只要芯片厂商生产出廉价的微处理器,编译一下C代码,Unix就能直接运行。

当摩尔定律将工作站价格从几十万美元打到几千美元时,开放的廉价硬件彻底击垮了专有大型机。微型计算机的浪潮席卷而来,定制化的大型机最终变成了昂贵的博物馆展品。

2006年,法国计算机公司Bull SAS以自由软件许可发布了完整的Multics源代码。现代系统程序员在查阅这些历史悠久的PL/I代码时发现了一个惊人的事实:

内存分段、动态链接库(.so 和 .dll)、内存映射I/O、层级访问控制列表(ACL)、细粒度多级安全……这些现代计算的核心特征,早在几十年前就被 Multics 实现并部署在了生产环境中。

当年离开MAC项目的年轻人,建立了一个务实、普及的Unix世界;而科尔巴托和留下来的人,则守护着一套严谨的计算体系,直到2000年。

历史给Multics贴上了“失败”的标签;但在国防和科研的关键系统中,这台机器连续无故障运转了三十三年。

作者丨huizhou92      编译丨dbaplus社群

来源丨网址:https://medium.com/plain-golang-tutorial/the-operating-system-that-ran-until-2000-and-is-still-called-a-failure-05313a890a61

dbaplus社群欢迎广大技术人员投稿,投稿邮箱:editor@dbaplus.cn

跳转微信打开

  •  

Linux之父坚持用ECC:电脑稳定性不能只看CPU

漫谈君 2026-11-12 07:15 广东

以下文章来源于:运维漫谈

运维漫谈

运维漫谈,漫谈整个网络安全、云计算、大数据、数据库、开发等运维技术干货,旨在分享干货,帮您更快学习相关知识,解决问题。

可靠性比单纯追求极限性能,更加重要!

对于很多普通电脑用户来说,内存可能是整台电脑里最容易被忽略的硬件之一。买电脑时,人们通常会关注内存容量、频率和时序,却很少注意内存有没有ECC功能。

但在Linux内核开发者Linus Torvalds眼里,情况完全不同。近年来他多次公开表达对ECC内存的重视,甚至把“能不能信任自己的电脑”放到了硬件选择的重要位置。2021年,他曾公开批评消费级市场长期缺乏ECC支持,认为市场对ECC的定位和产品线切割影响了这项技术的普及。

到了2025年,Torvalds在参与打造自己的Linux PC时依然选择了ECC内存,并强调可靠性比单纯追求极限性能更加重要。这个选择也再次让ECC进入了普通PC用户的视野。

那么,ECC究竟是什么,它解决的又是什么问题?

一、ECC并不是让内存“更快”,而是让数据更可靠

ECC的全称是Error-Correcting Code,也就是错误校正码。它与普通内存最大的区别,并不在于容量或者频率,而在于它能够对存储在内存中的数据进行额外检查,并在一定范围内发现和修正错误。

普通内存保存一个数据后,CPU再次读取时,通常默认里面的内容就是正确的。如果某个存储单元中的一个比特从0变成了1,或者从1变成了0,系统并不会天然知道这个数据发生过变化。

ECC则会额外保存用于校验的数据。以常见的SEC-DED机制为例,内存控制器可以对单比特错误进行纠正,同时检测双比特错误。Linux内核的EDAC文档也明确将这类能力定义为“单比特纠正、双比特检测”。

从硬件结构来看,普通内存通常以64位数据宽度进行传输,而典型ECC内存会使用72位,其中额外的8位用于ECC数据。

因此,ECC并不是让RAM多出一块“备用容量”,而是用一部分额外的数据空间换取更强的数据完整性保障。

二、内存中的错误并不是理论上的事情

很多人第一次听到ECC时,会觉得内存出错属于非常罕见的极端情况。实际上,DRAM并不是一个绝对不会出问题的存储介质。

内存单元可能受到硬件老化、电气干扰、制造缺陷以及其他环境因素影响,导致某些比特发生变化。随着现代电脑的内存容量越来越大,系统长期运行时处理的数据量也越来越高,内存可靠性自然变得更加重要。

这也是为什么服务器、工作站以及高可靠性计算平台长期以来更重视ECC。Linux内核甚至专门提供EDAC,也就是Error Detection And Correction子系统,用来检测和报告计算机硬件中的错误。其中内存的可纠正错误和不可纠正错误就是重点监控对象。

对于普通办公电脑来说,一次偶发的内存错误可能只是造成一个程序异常退出;但对于服务器、数据库、虚拟化平台、编译环境或者科研计算机来说,情况可能完全不同。

一个错误的比特如果恰好出现在重要数据中,最终可能表现为程序崩溃、数据异常,甚至让使用者误以为是操作系统或者应用程序出现了Bug。

三、Linus为什么如此在意ECC

Torvalds对ECC的重视,并不是单纯来自理论上的可靠性讨论。他本人就遇到过非常典型的内存故障。

2022年,他曾在Linux内核开发过程中遇到桌面电脑随机内存损坏的问题。当时一些内核构建任务会莫名其妙地出现内部编译器错误,问题看起来非常像软件Bug。后来经过测试,他发现真正的原因是一根已经出现问题的DIMM。

这件事情很能说明ECC的价值。

软件开发者最怕遇到的并不一定是明确的报错,而是那种偶尔出现、难以复现、看起来毫无规律的错误。CPU、编译器、内核代码、驱动程序、文件系统都可能成为怀疑对象,而一个存在问题的内存条,却可能隐藏在整个排查链条的最底层。

对于每天需要编译Linux内核的人来说,机器可靠性显然比跑分成绩更加重要。

这也是Torvalds在后来选择个人电脑硬件时依然坚持ECC的重要原因。他关注的不是ECC能够让电脑跑得多快,而是希望电脑成为一个可以信任的工具。

四、为什么ECC没有成为消费级PC的标配

既然ECC能够提高内存可靠性,它为什么没有像SSD、USB或者多核CPU一样成为消费级电脑的普遍配置?

原因并不复杂。ECC需要处理器、内存控制器、主板以及内存模块形成完整的支持链路。Intel官方文档目前也明确指出,ECC支持需要处理器和芯片组共同支持,因此仅仅购买一根ECC内存条,并不能保证整台电脑真正运行在ECC模式下。

这就造成了一个很现实的问题。

如果CPU不支持,ECC内存没有意义;如果主板不支持,ECC同样无法正常发挥作用;即使CPU和主板具备能力,厂商没有进行完整验证,用户也很难获得和服务器平台相同的可靠性保障。

Torvalds在2021年的讨论中把矛头直接指向了Intel的市场划分策略。他认为长期以来消费级和服务器级产品之间过于严格的ECC功能区隔,削弱了消费市场对ECC内存的需求,最终又进一步导致ECC DIMM在普通PC市场难以普及。

当然,这属于Torvalds的观点,并不能简单理解成整个行业的唯一解释。成本、产品定位、主板验证、市场需求以及消费者对性能参数的偏好,都影响着ECC的普及。

对于厂商来说,如果消费者更愿意为更高频率、更大容量或者更强的游戏性能买单,而很少有人因为ECC功能购买电脑,那么ECC自然很难成为消费级产品的重点卖点。

五、AMD和Intel的情况也不能一概而论

ECC支持还有一个容易被忽视的问题,那就是不同平台的具体情况并不完全一样。

一些AMD桌面平台长期以来对ECC有相对宽松的支持,因此部分Ryzen处理器搭配合适的主板和ECC UDIMM可以实现ECC功能。不过,“处理器支持ECC”和“某块主板完整支持ECC”并不是同一个概念,实际购买时仍然需要查看主板厂商的规格和验证信息。

Intel平台同样不能简单地概括为“全部不支持ECC”。Intel目前提供了专门的产品规格查询方式,用户可以根据具体处理器确认ECC支持情况,同时还需要考虑芯片组和平台配置。

因此,如果准备自己组装ECC电脑,最重要的并不是看到“ECC RAM”几个字就直接购买,而是把CPU、主板、内存以及BIOS支持情况一起确认。

六、DDR5上的ECC,又是另一回事

近年来还有一个非常容易混淆的概念。

部分DDR5内存颗粒本身具备On-Die ECC,也就是芯片内部的纠错机制。它主要用于提高DRAM芯片自身的制造良率和可靠性,并不等同于传统意义上的系统级ECC内存。

简单来说,On-Die ECC主要发生在DRAM芯片内部,而传统ECC系统则涉及内存模块、内存控制器以及CPU之间的数据传输保护。

因此,“DDR5有ECC”并不意味着“这台电脑就是ECC系统”。

这一区别非常重要。很多消费者看到DDR5规格中出现ECC,就误以为自己购买的普通DDR5内存已经拥有服务器级ECC保护,实际上两者解决的问题并不完全相同。

七、Linux为什么特别重视硬件可靠性

Linux内核本身就提供了一套相当成熟的硬件错误检测体系。EDAC可以记录可纠正和不可纠正的内存错误,而现代Linux内核还在不断扩展RAS,也就是Reliability、Availability and Serviceability相关能力。

Linux内核官方文档显示,内存scrubbing可以周期性读取内存内容,在发现可纠正错误时进行修正并写回,从而降低错误进一步发展成不可纠正错误的概率。

这说明ECC并不是一个孤立的硬件功能,而是整个可靠性体系的一部分。

对于服务器管理员而言,这一点尤其重要。一台服务器出现一次可纠正ECC错误,并不一定意味着系统马上就会宕机,但持续增加的错误记录可能成为硬件正在老化或者即将出现故障的信号。Linux的RAS/EDAC机制能够帮助管理员发现这些问题,并提前进行维护。

八、普通用户有没有必要上ECC

ECC并不是所有电脑都必须使用的配置。

如果电脑主要用于网页浏览、影音娱乐、普通办公和游戏,那么普通内存通常已经能够满足需求。ECC带来的最大价值是可靠性,而不是明显的性能提升。为了ECC而额外增加预算,也未必适合所有消费者。

但如果电脑长期运行Linux服务器、虚拟机、NAS、数据库、编译环境,或者承担开发、科研、数据处理等任务,那么ECC的价值就会明显提高。

特别是那些需要长时间运行、数据准确性比极限性能更重要的系统,ECC实际上是在购买一种“出错之后还能被发现和处理”的能力。

这也是Linus Torvalds观点中最值得普通用户注意的地方。

ECC真正解决的不是“电脑会不会变快”,而是“电脑出错时有没有机会知道自己出错了”。

ECC并不能让电脑永远不会崩溃,也不能修复所有硬件故障,更不能替代备份。即使使用ECC,硬盘、CPU、主板、电源以及软件仍然可能出现问题。

但它确实解决了内存可靠性中的一个非常具体的问题。

Linux内核对EDAC、RAS、内存scrubbing以及硬件错误监控的持续支持,也说明内存可靠性从来不是一个伪需求。

过去很多人把ECC看成服务器专属功能,很大程度上是因为消费级PC长期没有形成足够成熟的产品生态。随着内存容量不断增加、电脑运行时间越来越长,以及开发、虚拟化和本地AI等工作负载不断增加,硬件可靠性的重要性正在重新被讨论。

Linus Torvalds对ECC的坚持,本质上也是一种非常典型的工程师思维:性能可以通过升级硬件获得,但数据一旦被错误地处理,很多时候很难知道问题究竟发生在哪里。

对于一台需要长期工作的电脑而言,“稳定运行”和“能够信任”本身就是非常重要的性能指标。

作者丨漫谈君

来源丨公众号:运维漫谈(ID:yunweimantan)

dbaplus社群欢迎广大技术人员投稿,投稿邮箱:editor@dbaplus.cn

跳转微信打开

  •  

从SQL到NoSQL:谷歌为何搞砸了数据库?

原创 Brendan Shea 2026-11-11 07:15 广东

系统只能在“数据正确”和“服务可用”之间做取舍,很难两全,而必须有人做出这个抉择。

在长达三十年的时间里,数据领域一直奉行一套核心思路:数据存放数据表,由数据库而非开发者来强制执行数据约束。谷歌的Bigtable主动舍弃了这些约束,因为基于这套规则构建的系统,根本无法承载整个互联网的海量数据。随后,掀起了名为NoSQL的技术浪潮,而这股浪潮后来又发生了部分反转。这场论战的核心,从来无关软件本身,而是一个根本问题:谁有资格为换取系统的扩容能力而牺牲数据正确性?

你使用的每一款应用,它的各类业务承诺:账户余额、成绩、消息记录,全都保存在数据库里。

当数据一致性保障遇上业务规模瓶颈会发生什么?

系统只能在“数据正确”和“服务可用”之间做取舍,很难两全,而必须有人做出这个抉择。

一、事件回顾

1970年,当时业界最前沿的数据库系统乱象丛生,Edgar F. Codd可以证明这一点。

Codd是IBM圣何塞实验室的一名数学家。二战期间,他曾在英国皇家空军服役,为一些最早的计算机编写过程序,后来则研究企业如何存储记录。后来,他发现了一个现象,并为此非常担忧。

当时领先的系统,包括IBM自家的IMS,它最初是为了追踪阿波罗登月计划里数百万个零件构建的,都是把数据存成一堆互相缠绕的记录,乱成一团。程序员要想找点东西,都得先把这团乱麻背得滚瓜烂熟。更糟的是,这团乱麻并不是背后的实现细节,就是数据本身。只要动一下数据的存储方式,所有读它的程序就全完了。

Codd给出的答案,是一篇标题干巴巴的论文:《大型共享数据库的关系数据模型》。它的想法朴素到了极点,也正因如此,才格外大胆:把所有东西都存进简单的行列表格;让程序去问数据“是什么”,而永远不问它“在哪儿”;把规则的维护从程序里拿出来,交给数据库自己去管。

IBM却没有采纳。IMS就是台赚钱机器,而Codd的模型则是动了它的奶酪。这个理念在IBM内部举步维艰,但在外部却迅速传播开来。

当时还是年轻创业者的Larry Ellison,读到IBM公开发表的论文,立刻嗅到商机,抢先把商用关系数据库做了出来。他干脆用产品给公司命名:Oracle。整个80到90年代,关系数据库和它的语言SQL几乎横扫整个行业,以至于“数据库”和“关系数据库”都快成了同一个词。

1981年,Codd获得图灵奖。2003年他去世时,讣告里称他的思想是现代世界的基石之一。

然而,现代业务规模的增长,这套体系逐渐不堪重负,而谷歌是第一个遇到这个困境的公司。2004年,谷歌要存储整个互联网的副本:数十亿网页、PB级海量数据,数据持续更新,每秒要处理成千上万次查询。按照关系型数据库的传统思路,解决方案就是采购性能更强、可靠性更高的服务器。但无论花多少钱,都不存在一台足够大的服务器可以扛住这样的负载。

谷歌应对硬件难题的思路截然相反:把计算任务拆分,分散到成千上万台廉价机器上,并且坦然接受机器会频繁故障的现实。在这样的硬件环境下,Codd提出的数据一致性保障机制会带来极高的性能开销。当多张数据表存放于同一台服务器时,表连接操作很快,但如果数据行散落在分布于三个数据中心的上千台机器上,同样的表连接就会产生海量网络流量,只要任意一台机器出现卡顿,整个查询就会陷入停滞。

于是,谷歌的工程师团队——Fay Chang、Jeff Dean、Sanjay Ghemawat以及其他同事,刻意打破了这套原有数据库的设计约定,开发出了Bigtable。它没有SQL接口,不支持表连接,也无法实现跨行事务。

本质上,它就是一张庞大有序的键值对列表,被切分成多段,分散存储在多台机器之上。只要通过主键查询某一行数据,无论表里是一百万行还是上千亿行,Bigtable都可以快速返回结果。可一旦提出更复杂的查询需求,就只能交给应用开发者自己处理。

这套系统效果显著。Bigtable支撑了谷歌网页搜索、地图与分析业务。2006年,谷歌做出一个不同寻常的举动:公开发表论文,对外披露Bigtable的整套设计。

一年之后,亚马逊发布了Dynamo,这同样是一套打破传统规则的存储系统。它的设计目标是保证购物车服务永远不会拒绝用户访问,哪怕这意味着购物车会同时存在多份版本,后续再做数据合并。

这些论文发表时,正值行业变革的风口浪尖。短短数月间,HBase、Cassandra、MongoDB等开源实现相继问世。到2009年,这股浪潮有了一个名字:NoSQL,并且风靡一时。Schema被视为累赘,JOIN更是老旧时代的产物。不少初创公司实际流量还不及谷歌的千分之一,就匆匆弃用关系型数据库,只为去适配一套自己永远都未必会达到的业务规模。

并非所有人都看好这股风潮。Michael Stonebraker,早在20世纪70年代就参与打造了最早一批关系型数据库,算得上是Codd思想最重要的继承者。他看着这场行业热潮,十分不解。他认为,整个行业在70年代付出惨痛代价,才真正理解数据库规则存在的意义,如今却主动将这些经验抛之脑后。

那场争论的结果本身并不重要,重要的是背后的问题:谷歌是真的遇到了现实的性能瓶颈,才审慎地做出取舍。但其它成千上万的企业,在并没有面临同类困境的情况下,也照搬了同样的妥协方案。Codd定下的这套数据保障准则,究竟是否可以舍弃?如果可以,又该由谁来决定舍弃它?

二、工作原理

Codd的模型与Bigtable的模型逻辑都很直观,易于理解。二者的核心差异,在于计算负担落在了哪里。

Bigtable这类存储系统,本质上是一张巨大的有序映射表:每行对应一个查询键,行内包含多个带名称的值。下面这15行Python代码就模拟出了它的基本形态:

    store = {}   # a wide-column store in miniature: row key -> labeled values
    def put(row_key, column, value):
        store.setdefault(row_key, {})[column] = value
    def get(row_key):
        return store.get(row_key, {})
    put("com.example/pageA", "contents", "<html>A cooking blog...</html>")
    put("com.example/pageA", "links_to", "com.recipes/pageB")
    put("com.recipes/pageB", "contents", "<html>A recipe...</html>")
    put("com.recipes/pageB", "language", "en")
    print(get("com.example/pageA"))

    留意两点:

    • 第一,get查询只需一步。无论存储里是4行还是400亿行,按主键读取一行数据的开销基本不变。并且由于键是有序保存的,真实系统可以把键区间拆分到上千台机器上,还能立刻定位某一行归属哪台机器。正是这一特性,让Bigtable能够承载全网数据。

    • 第二,注意这些行并不要求结构一致:pageA有links_to字段,pageB有language字段。不会有模式校验报错,因为根本不存在预定义schema。

    现在向存储发起一个更复杂的查询:哪些页面链接到pageB?关系型数据库只需要一行join语句就能完成,数据库会帮你完成关联查找。但Bigtable做不到。它只能按行主键检索数据,而“pageB”只是埋藏在其它行的值里面。如果想要快速得到这个结果,你必须额外构建并维护一份反向索引数据,使用反向键:

      backlinks = {}   # a second index — yours to build, and yours to keep correct


      def put_link(from_page, to_page):
          put(from_page, "links_to", to_page)
          backlinks.setdefault(to_page, []).append(from_page)

      这第二个函数,用四行代码就道出了整套取舍逻辑。查询速度很快,但代价是两套数据结构必须始终保持一致,而数据库不会帮你校验。如果两次更新中间发生宕机,两份数据就会悄悄出现不一致。Codd的模型不会出现这种情况,数据库会把关联变更作为单个事务执行。而在Bigtable里,这件事得由开发者自己处理。计算开销并没有消失,只是从数据库内部转移到了每一个调用它的应用程序中。

      完整的权衡关系如下:

      对关系型数据库和Bigtable式NoSQL数据库在最重要的问题上进行了比较。

      对比项关系型(Codd)Bigtable风格(NoSQL)

      数据形态

      固定列,由系统强制约束

      每行可存放任意结构数据

      规则由谁强制执行

      始终由数据库负责

      靠业务代码实现,取决于开发者是否记得处理

      扩容方式

      更换性能更强、价格更高的服务器

      增加大量廉价服务器横向扩展

      跨表查询

      一条 join 语句,数据库自动完成计算

      需要自行构建二级索引

      网络故障时

      可能拒绝响应(保证数据正确)

      持续提供查询(数据可能过期)

      最后这一点值得单独拎出来讲。Dynamo这类系统提供的是最终一致性:一次更新完成后,不同机器上的数据短时间内可能不一致,系统会在后续自动完成数据调和。亚马逊的判断是:购物车偶尔显示已删除商品,要好过购物车直接打不开。对于购物车场景,大多数人认可这个取舍;但换到银行余额场景,几乎没人能接受。

      争论的根源就在这里。

      三、Bigtable引发的争论

      各方观点环环相扣,后一种观点都在回应前一种观点。

      1、Stonebraker的警告:这些教训我们早已经吸取过

      Stonebraker并不是说谷歌在自身业务场景下的做法是错的。他的观点是,整个行业把一个特殊场景下的解决方案当成了一场技术革命。20世纪60年代的数据库就缺少强制的数据规则,而关系型模型正是为了解决那段时期暴露出的种种问题才被创造出来的。

      保障优先派观点

      • 数据的生命周期会长于创建它的应用程序。如果校验规则仅在应用程序代码里实现,那么规则会随着程序的淘汰而失效。不同开发团队会以不同方式实现这些规则,有的实现残缺不全,有的甚至完全不做实现。

      • NoSQL系统把规则校验逻辑从数据库转移到应用代码中,又回到了关系型模型原本要解决的那种混乱局面。

      • 几乎没有企业会遇到谷歌所面临的业务困境,却全都照搬了谷歌的做法。

      因此,对绝大多数企业而言,放弃关系型模型算不上技术创新,而是在重蹈过去的覆辙,最终要由数据受损的用户来承担代价。

      这一论点最有力的佐证就是真实发生过的事故。当时最流行的NoSQL数据库MongoDB,其早期版本的默认配置不会等待确认写入操作真正落盘完成。虽然基准测试里速度飞快,但在生产环境下会悄无声息地丢失数据。很多团队是通过客户的投诉工单,才切身体会到 “最终一致性” 带来的问题:订单重复扣款,账户余额结果随查询服务器不同而发生变化。

      整套论述的核心立足点是第三条前提:你并不是谷歌。而对立观点正是针对这条前提发起反驳,认为该前提无关紧要。

      2、规模优先派的反驳:旧模型的时代前提已经不复存在

      Bigtable和Dynamo的设计者们并不认为自己在摒弃70年代的技术经验。在他们看来,70年代的技术建立在一个前提假设之上:单台可靠服务器,但互联网时代已经证明这个假设不再成立。他们的观点是:这种取舍是客观数学规律带来的必然结果,如果刻意回避这一点,才是真正的工程失职。

      规模优先派的反驳论点

      • 在大规模场景下,网络分区和机器故障是必然会发生的现象。因此CAP定理迫使系统必须在可用性和一致性之间做出抉择;回避抉择,就等同于选择系统停机。

      • 服务停机和响应缓慢同样会造成实际损害,损害体现在用户无法使用服务、业务工作中断,而不只是单纯的数据丢失。

      • 关系型模型的各项数据保障机制,是针对单台可靠计算机设计的,其性能成本也基于该前提。但这个前提已经不再适用于当下人们实际需要的系统。

      • 放宽数据保障条件并非鲁莽之举,而是贴合现实环境的务实工程实践。这些放宽约束的系统,只是把旧系统暗含的前提,直白地摆在了台面上。

      最有力的回应恰恰在于它的谦逊。谷歌实际测试过自身的性能边界,亚马逊也针对“购物车数据过期”这一故障模式做过主动权衡,该场景下数据过期的代价很低。

      但这套逻辑只能证明那些完成过实测的工程师做得合理,却无法解释成千上万直接照搬结论、没有做过任何评估的团队。如果一项取舍只是跟风赶潮流,那就不再是理性权衡,而是拿用户的数据来赌运气。

      3、跟风炒作的批判观点

      由此引出第三种立场:真正的问题并不出自某一种数据库模型,而是整个行业选用技术工具的方式。

      挑选数据库就像挑选运动鞋,大家只看大厂在用什么。技术大会分享、求职简历、“互联网大规模架构” 这类噱头主导了选型,而非业务实际需求。

      按照这种视角,数据库选型是一件关乎伦理的事,因为背后承载着他人的重要记录:处方、存款、证据、学业成绩。如果一个团队在用药记录系统上采用最终一致性,无论团队内部有没有明确讨论过,都相当于替患者做出了风险抉择。

      该批判对前面两种观点同时提出质疑:各方都在争论哪一种取舍方案更正确,但真正值得警惕的是人们对待取舍的草率态度——当数据悄无声息丢失时,没人说得清当初是谁允许承担这份风险。

      四、现状:SQL的逆袭

      剧情最后发生反转。2012年,正是当初打破传统数据库范式的谷歌,发布了Spanner。这个数据库在大规模分布式场景下重新带回了SQL、数据表模式和事务机制。与此同时,谷歌也发表了一篇论文:《Spanner: Google’s Globally-Distributed Database》。

      这篇论文里有一段令人深省的表述:

      与其总是要在代码层面弥补事务能力缺失带来的各种问题,不如让程序员在遇到性能问题时,再去处理性能开销。

      多年来,谷歌眼睁睁地看着自己的工程师们,笨拙地手动构建Bigtable放弃的那些功能,每个团队都得单独为Codd买单。

      整个行业都从两个方向逐步走向融合。MongoDB增加了事务与schema校验,以间接方式补上了这些约束能力。传统关系型数据库则吸收了对手最拿手的特性:PostgreSQL新增了灵活的JSON字段,允许结构不规则的数据,存放在具备强约束保障的系统里。现在,给初创公司的主流选型建议已经回归保守:先用Postgres,直到你能证明它满足不了业务需求。

      这就引出了一个更加尖锐的问题:Codd的规则,先是被做过严谨评估的团队舍弃。等到大家为这个舍弃的决定付出代价之后,又重新捡起来。而中间这些年产生的损失,大多由用户承担,他们甚至不知道有人做过这样的取舍。

      如果软件行业就是这样摸索边界:打破规则、上线交付、统计损失、再把规则加回来。这算得上是扎实的工程经验积累吗?还是一场拿公众做对象的实验?如果属于后者,谁签署了这份知情同意书?

      >>>>

      参考资料

      • Chang, Fay, Jeffrey Dean, Sanjay Ghemawat 等. 2006. “Bigtable:用于结构化数据的分布式存储系统。” 第七届 USENIX 操作系统设计与实现研讨会 (OSDI '06) 会议论文集。

        https ://research.google/pubs/pub27898/

      • Codd, Edgar F. 1970. “大型共享数据库的关系模型。” ACM 通讯13 (6): 377–87。Corbett, James C.、Jeffrey Dean、Michael Epstein 等人, 2012 年。“Spanner:谷歌的全球分布式数据库。” 第十届 USENIX 操作系统设计与实现研讨会 (OSDI '12) 会议录。

        https ://research.google/pubs/pub39966/

      • DeCandia, Giuseppe, Deniz Hastorun, Madan Jampani 等. 2007. “Dynamo:亚马逊的高可用键值存储。” 第 21 届 ACM 操作系统原理研讨会 (SOSP '07) 会议录。

        https : //www.allthingsdistributed.com/files/amazon-dynamo-sosp2007.pdf

      • Gilbert, Seth 和 Nancy Lynch. 2002. “Brewer 猜想与一致、可用、容错 Web 服务的可行性。” ACM SIGACT 新闻33 (2): 51–59。Markoff, John. 2003. Edgar f. Codd, 79岁逝世;数据库关键理论家。《纽约时报》,2003年4月23日。

        https : //www.nytimes.com/2003/04/23/business/edgar-f-codd-79-dies-key-theorist-of-databases.html

      • Stonebraker, Michael. 2010. SQL数据库与NoSQL数据库。ACM 通讯,53(4),10–11。

        https ://cacm.acm.org/opinion/sql-databases-v-nosql-databases/

      作者丨Brendan Shea      编译丨dbaplus社群

      来源丨网址:https://brendanpshea.github.io/computing_concepts_python/v2/cases/cs09_sql_nosql.html

      dbaplus社群欢迎广大技术人员投稿,投稿邮箱:editor@dbaplus.cn

      跳转微信打开

      •  

      企业级MultiAgent的记忆系统:短期上下文与四层记忆架构实现

      偶啦 2026-11-10 07:15 广东

      以下文章来源于:得物技术

      得物技术

      技术知识分享交流平台,与你一同走向技术的云端。

      当前方案覆盖Redis/MySQL回退、MemOS语义检索等内容。

      目录

      一、背景及整体架构概览

      二、记忆架构概览

      三、短期记忆加载详情

      四、短期记忆写入详情

      五、长期记忆加载实现详解

      六、长期记忆写入实现详解

      七、核心设计与运行观测

      八、总结与后续工作

      一、背景及整体架构概览

      在 MultiAgent 平台中,Agent 一次请求可能同时经过模型、MCP/A2A 工具、RAG、Workflow 和 Sandbox,还要在多轮对话和跨会话协作中记住用户偏好、任务进展与协作约定。因此记忆模块不是独立外挂,而是 Agent 执行链路的一部分。

      在本项目中,记忆不是把全部历史简单拼到 Prompt,而是分别承接会话上下文、跨会话信息和上下文关联:

      • 会话延续:短期历史无法支持指代消解和任务延续。

      • 跨会话复用:跨会话无法复用用户偏好和稳定事实。

      • 上下文关联:新增消息无法与已有上下文建立关联。

      选型 MemOS:在 1540 个问题、10 个测试用户的评测中,综合得分 74.33%,单跳与多跳表现均达标(评测仅作选型参考,不代表生产 SLA)。

      整体架构:后端基于 Spring Boot 3 和 Java 17,Agent 编排采用 AgentScope。新建 Agent 默认将 longMemoryProvider 设为 MEMOS,但 openLongMemory 默认关闭;开启后,请求开始时短期会话历史和长期记忆并行加载,会话结束后由 onSessionEndAsync 异步完成筛选、去重和长期沉淀。短期记忆以 MySQL 为持久化底座、Redis 为热点缓存,长期记忆以 MemOS 为主路径,同时保留 MySQL/Mem0 路由作为兼容路径。

      本文只展开记忆模块的实现:包括四层记忆模型、短期历史的读取与写入、MemOS 的按 scope 检索,以及会话结束后的异步沉淀。

      二、记忆架构概览

      Agent 四层记忆模型

      四层分别对应不同的生命周期:Working Memory 只服务当前一步推理;Session Memory 保存会话内的消息历史;User Memory 记录跨 Agent 共享的偏好和稳定事实,对应 MemOS 的 user_profile;Agent Memory 保存某个 Agent 的任务经验和协作约定,对应 agent_{agentId}。会话结束后,新增消息经过判断和去重,再从 Session 层沉淀到 User 或 Agent 层。

      Agent 四层记忆模型:Working、Session、User 与 Agent Memory 的读取、作用域和异步沉淀链路。

      1、记忆类型

      四层模型与 MemOS 类型是两套分类维度:四层模型描述信息的生命周期和作用域;MemOS 的 text_mem、pref_mem、skill_mem、tool_mem 描述记忆内容形态,不能直接与四层一一对应。

      当前路由行为:longMemoryProvider 未配置、Agent 不存在或读取配置异常时,MemoryRpcServiceImpl 选择 MySQL;明确配置为 MEMOS 或 Mem0 时才进入对应 Provider。MemOS 查询异常由 Provider 自身记录日志并返回空结果,当前不会自动切换到 MySQL。

      2、记忆加载流程

      一次请求的记忆路径可以概括为:AgentExecutor#execute 解析上下文参数后,在 memoryLoadExecutor 中并行启动短期记忆和长期记忆 Future。短期链路读取 ConversationMemory;长期链路调用 queryMemory,由 MemoryRpcServiceImpl 按 Agent 配置选择 MEMOS、Mem0 或 MySQL。

      • 长期记忆检索返回后,平台按 user_profile 与 agent 分组,过滤敏感或低相关内容,并限制每个 scope 的条数。

      • 随后以固定 tokens 为默认预算,优先满足用户画像,再把剩余预算分配给 Agent 专属记忆。

      • 最终结果写入 AgentContext,与短期消息一起参与后续模型调用;会话结束后再异步触发长期记忆沉淀和上下文摘要。 

      实现边界:平台的 ConversationMemory 负责会话历史读取和窗口裁剪;AgentScope Harness 的 state store 负责会话状态持久化,有 Sandbox 时使用共享工作区文件存储,没有 Sandbox 时回退到内存存储。当前 ModelInvoker 主链路构造 Harness 消息时,以本轮 userMsg 为入口,因此不能简单理解为 Redis/MySQL 历史会被无条件直接拼进每一次 AgentScope Prompt。

      3、短期记忆 vs 长期记忆

      4、关键组件及方法

      三、短期记忆加载详情

      短期记忆(Session Memory)保存当前会话中按时间排列的对话历史,是指代消解和多轮推理的直接上下文。实现重点是读取时延、Redis/MySQL 回退以及 Token 窗口控制。

      加载流程图

      调用链说明:

      • AgentExecutor 从 AgentContext 获取 AgentConfig → ModelBindConfigDto → contextRounds。

      • AgentExecutor 调用 chatMemory.get(conversationId, contextRounds * 3)。

      • chatMemory 是 ConversationMemory 接口,由 ConversationApplicationServiceImpl 实现。

      • 实现类优先从 Redis 读取,失败则从 MySQL 回退。

      1、关键实现

      完整实现还包括消息类型转换、system 消息拆分及工具调用信息处理。下面只保留“读取 → 交替校验 → Token 窗口判断”的主路径,便于理解短期记忆如何形成模型上下文。

        // DTO 已转换为 Message,system/tool 消息已拆分
        trimAlternationFromEnd(chatMsgs);
        int windowSize = MAX_TOKEN_WINDOW_SIZE - SUMMARY_TOKEN_BUDGET;
        int totalTokens = 0, recentTokens = 0;
        boolean overLimit = false;
        List<Message> recentWindow = new ArrayList<>();
        for (int i = chatMsgs.size() - 1; i >= 0; i--) {
            Message message = chatMsgs.get(i);
            int tokens = TikTokensUtil.tikTokensCount(message.getText());
            totalTokens += tokens;
            if (!overLimit && recentTokens + tokens <= windowSize) {
                recentWindow.add(0, message);
                recentTokens += tokens;
            } else {
                overLimit = true;
            }
        }
        if (totalTokens <= MAX_TOKEN_WINDOW_SIZE) {
            removeLeadingAssistant(chatMsgs);
            return mergeSystemAndChat(systemMsgs, chatMsgs);
        }
        removeLeadingAssistant(recentWindow);
        String summaryMd = iMemoryRpcService.getConversationSummaryMd(Long.parseLong(cid));
        if (StringUtils.isNotBlank(summaryMd)) {
            recentWindow.add(0, new SystemMessage(summaryMd));
        }
        return recentWindow;

        Redis 优先读取,类说明:ConversationApplicationServiceImpl#getMessagesFromCache 先读取 Redis List,命中后把 JSON 转为 ChatMessageDto,并翻转为 oldest-first;未命中或读取异常则查询 MySQL,再按倒序 leftPush 回写,设置 CACHE_TTL_SECONDS,并用 rightPop 按 MAX_CACHED_MESSAGES 淘汰最旧消息。逐条解析和异常日志属于防御性代码,这里不展开。

        2、Redis 存储结构实现细节

        使用 leftPush 写入,最新消息在 index 0;当前实现使用 range(0, Long.MAX_VALUE) 读取 Redis 列表,再在应用层做窗口裁剪;使用 rightPop 移除最旧消息 需要注意,ConversationMemory#get(String, int) 的 lastN 参数当前未参与 Redis 的 range 边界计算;实际读取范围由 Redis 列表内容和后续 Token 窗口共同决定。Redis 只承担热点缓存,MySQL 仍是冷启动回源和持久化兜底。

        3、Token 窗口控制策略

        四、短期记忆写入详情

        写入时序图

        双写的意义——MySQL :持久化兜底防止数据丢失。Redis: 高性能读取支撑实时对话。回退机制: Redis 失败时仍可从 MySQL 回退读取。

          messages.forEach(message -> {
              String conversationId0 = conversationId;
              if (conversationId0.startsWith("agent:")) {
                  // 子 Agent 的非 ChatMessage 不写入主会话,避免虚拟会话污染主链路。
                  if (message instanceof ChatMessageDto) {
                      conversationId0 = conversationId.replace("agent:", "");
                  } else {
                      return;
                  }
              }
              ChatMessageDto chatMessage = ...; // 类型转换、清洗文本并补齐租户字段
              ConversationMessage conversationMessage = ...;
              // 先落 MySQL,Redis 只作为可失效的热点缓存。
              Long messageId = TenantFunctions.callWithTenantId(chatMessage.getTenantId(),
                  () -> conversationDomainService.addConversationMessage(conversationMessage));
              chatMessage.setIndex(messageId);
              try {
                  String key = generateConversationKey(conversationId0);
                  redisUtil.leftPush(key, JSON.toJSONString(chatMessage));
                  redisUtil.expire(key, CACHE_TTL_SECONDS);
                  long size = redisUtil.size(key);
                  // 最新消息在表头,超出 200 条时从尾部淘汰最旧消息。
                  if (size > MAX_CACHED_MESSAGES) {
                      redisUtil.rightPop(key);
                  }
              } catch (Exception e) {
                  // 缓存失败不回滚已完成的 MySQL 写入,读取时会回源数据库。
                  log.warn("Failed to cache message to Redis, conversationId={}", conversationId0, e);
              }
          });

          短期消息写入后,onSessionEndAsync 还会检查会话摘要:当未被摘要覆盖的消息达到 20 条才触发摘要生成,摘要注入预算约 2000 tokens,并在 Redis 缓存 1 小时。这样做把高频对话写入与低频摘要合并拆开,避免每轮都调用摘要模型。

          五、长期记忆加载实现详解

          加载时序图

          1、并行加载设计

          在 Agent 执行入口 AgentExecutor#execute 中,我们采用 CompletableFuture 实现短期记忆和长期记忆的并行加载:

            final int finalContextRounds = contextRounds;
            CompletableFuture<List<Message>> contextMessagesFuture = CompletableFuture.supplyAsync(() -> {
                // contextRounds=0 是合法配置,直接跳过短期历史读取。
                if (finalContextRounds <= 0) {
                    return new ArrayList<Message>();
                }
                return new ArrayList<>(
                    chatMemory.get(agentContext.getConversationId(), finalContextRounds * 3));
            }, memoryLoadExecutor);
            CompletableFuture<Map<String, String>> longMemoryFuture = CompletableFuture.supplyAsync(() -> {
                if (agentContext.getAgentConfig().getOpenLongMemory() != AgentConfig.OpenStatus.Open) {
                    return Collections.emptyMap();
                }
                try {
                    AgentComponentConfigDto modelComponentConfig =
                        agentContext.getAgentConfig().getModelComponentConfig();
                    // queryMemory 需要绑定模型的 targetId,未绑定时不发起长期检索。
                    if (modelComponentConfig == null || modelComponentConfig.getTargetId() == null) {
                        return Collections.emptyMap();

                    }
                    boolean justKeywordMatch = resolveJustKeywordMatch(agentContext);
                    // originalMessage 是主查询词;此处 context 为空,短期历史不会反向增强本次 query。
                    return conversationApplicationService.queryMemory(
                        agentContext.getUser().getTenantId(), agentContext.getUser().getId(),
                        agentContext.getAgentConfig().getId(), modelComponentConfig.getTargetId(),
                        agentContext.getOriginalMessage(), "", justKeywordMatch,
                        agentContext.isFilterSensitive());
                } catch (Exception e) {
                    // 长期记忆是增强能力,查询失败时让主对话继续。
                    log.warn("查询长期记忆失败", e);
                    return Collections.emptyMap();
                }
            }, memoryLoadExecutor);


            // 这里才是并行结果的汇合点,主流程等待两条记忆链路都完成。
            agentContext.setContextMessages(contextMessagesFuture.join());
            Map<String, String> longMemoryMap = longMemoryFuture.join();

            设计要点:使用专用线程池 memoryLoadExecutor,避免 ForkJoinPool.commonPool 争抢;长期记忆不阻塞短期记忆,用空 context 先行查询。

            边界与降级:关闭 openLongMemory 时长期 Future 直接返回空 Map;Agent 未绑定模型时跳过长期检索;查询异常也会记录 warning 并返回空结果,主对话继续执行。当前长期查询以 originalMessage 作为主检索词,和短期记忆的读取互不等待,因此并行带来的是执行重叠,不是"短期历史已注入后再增强查询"。

            2、语义检索实现

            MemOS Search 请求保留以下参数;context 非空时,平台只取前 200 个字符拼到 userMessage 后作为 query。调用链虽然携带 justKeywordSearch,但当前 MemosMemoryApplicationService 未据此切换检索模式,仍固定调用 MemOS Search。

              List<String> readableCubeIds = new ArrayList<>();
              readableCubeIds.add("user_profile");
              if (agentId != null) {
                  readableCubeIds.add("agent_" + agentId);
              }
              MemOSClient.SearchRequest searchRequest = new MemOSClient.SearchRequest();
              // 一次 Search 同时覆盖用户画像和当前 Agent 的记忆 cube。
              searchRequest.setQuery(buildSearchQuery(userMessage, context));
              searchRequest.setUserId(memOSUserId);
              searchRequest.setTopK(DEFAULT_TOP_K);
              searchRequest.setMode("fast");
              searchRequest.setRelativity(0.45);
              searchRequest.setDedup("mmr");
              searchRequest.setReadableCubeIds(readableCubeIds);
              searchRequest.setIncludePreference(true);
              searchRequest.setPrefTopK(6);
              List<MemOSMemory> searchResults =
                  memOSClient.searchMemory(searchRequest).getMemories();
              // 转换阶段会过滤低分结果、截断单条内容,再按 score 降序返回。
              result.addAll(convertToMemoryUnitDTOs(searchResults, tenantId, userId, agentId));
              result.sort((a, b) -> {
                  if (a.getScore() == null && b.getScore() == null) return 0;
                  if (a.getScore() == null) return 1;
                  if (b.getScore() == null) return -1;
                  return Double.compare(b.getScore(), a.getScore());
              });

              搜索参数说明:

              readableCubeIds 当前包含 user_profile 和 agent_{agentId};同时开启 preference 检索,prefTopK=6 用于补充用户偏好。检索结果随后还会经过 score < 0.3 过滤和单条 1000 字符截断,避免低相关或过长内容挤占上下文。

              3、Token Budget 分配策略

              以下片段承接 5.2 的检索结果,userProfileRaw 与 agentMemoryRaw 分别是按 scope 汇总后的文本。为防止记忆撑爆 Agent 上下文,我们设计了 Token Budget 分配机制。

                int budget = DEFAULT_LONG_MEMORY_TOKEN_BUDGET; // 4000 tokens
                int userProfileRawTokens =
                    TikTokensUtil.tikTokensCount(userProfileRaw != null ? userProfileRaw : "");
                // user_profile 最多占 60%;实际未用满时,剩余预算让给 Agent 记忆。
                if (userProfileRawTokens <= budget * 0.6) {
                    userProfile = userProfileRaw;
                    agentMemory = truncateLongMemory(agentMemoryRaw, budget - userProfileRawTokens);
                } else {
                    userProfile = truncateLongMemory(userProfileRaw, (int) (budget * 0.6));
                    // 重新计算截断后的 token 数,避免把截断前的估算带入剩余预算。
                    int userProfileTokens =
                        TikTokensUtil.tikTokensCount(userProfile != null ? userProfile : "");
                    agentMemory = truncateLongMemory(agentMemoryRaw, budget - userProfileTokens);
                }

                截断算法采用按行截断,保留完整语义:

                  String[] lines = longMemory.split("\n", -1);
                  for (String line : lines) {
                      // 按行累计 token,尽量保留一条记忆的完整内容。
                      int lineTokens = TikTokensUtil.tikTokensCount(line + "\n");
                      if (currentTokens + lineTokens > budget) {
                          break;
                      }
                      truncated.append(line);
                      currentTokens += lineTokens;
                  }

                  user_profile 最多占 60% 预算;如果实际占用更少,剩余空间分给 Agent 记忆。两类内容都按行累加 token,达到预算后停止追加,避免拆散单条记忆。

                  六、长期记忆写入实现详解

                  写入时序图

                  1、写入入口与去重

                  会话结束时,系统触发记忆写入流程,首先使用 Redis Set 记录已处理消息的 hash 并做去重。

                  类说明:MemoryRpcServiceImpl 负责会话结束后的写入编排,onSessionEndAsync 先获取会话级 Redis 锁,再由 processSessionEnd 按消息 hash 过滤本次新增内容并提前记录已处理 hash,随后根据 Agent 配置选择 provider:MemOS 路径先进行 LLM 记忆判断,再交给 MemoryPersistenceServiceImpl 持久化;MySQL、Mem0 路径则组装完整上下文和最新 user 输入后调用 createMemory。记忆处理完成后,同一异步线程继续检查是否需要生成上下文摘要。

                  设计要点:

                  • 分布式锁防止并发处理同一会话。

                  • MD5(role:content) 生成消息唯一标识。

                  • TTL 7 天自动清理过期记录。

                  onSessionEndAsync 使用 10 分钟的会话锁,已处理消息 hash 的 TTL 为 7 天。hash 会在 LLM 判断和 MemOS 持久化之前写入,用来挡住重复结束事件。但这一层属于 best-effort:Redis 读取失败时,当前实现会把整段会话作为新增内容继续处理;hash 写入失败也只记录日志。外部服务失败后没有自动回放,因此运行侧需要同时关注重复写入和处理未完成两类异常。

                  2、LLM 智能判断

                  完整 Prompt 定义了记忆类别、scope、importance 和 JSON 输出约束,下面只保留新增消息标记与模型调用主线。judge 会先调用 LLM;调用异常或返回为空时,降级到仅基于新增消息的规则判断。LLM 返回不为空时,还会统一补齐缺省字段、过滤空内容,并将单条记忆截断到 200 字符。

                    private MemoryJudgeResult judgeByLLM(Long tenantId, Long modelId,
                            List<MemoryMessage> fullContext, List<MemoryMessage> newMessages) {
                        Set<String> newMessageKeys = newMessages.stream()
                            .map(m -> (m.getRole() != null ? m.getRole() : "user")
                                + ":" + (m.getContent() != null ? m.getContent() : ""))
                            .collect(Collectors.toSet());
                        StringBuilder content = new StringBuilder("## 完整对话上下文\n\n");
                    for (MemoryMessage message : fullContext) {
                            String role = message.getRole() != null ? message.getRole() : "user";
                            String text = message.getContent() != null ? message.getContent() : "";
                            content.append(newMessageKeys.contains(role + ":" + text)
                                    ? "[[NEW] " : "[")
                                .append(role).append("]: ").append(text).append("\n");
                        }
                        MemoryJudgeResult result = iModelRpcService.call(
                            tenantId, modelId, JUDGE_SYSTEM_PROMPT, content.toString(),
                    new ParameterizedTypeReference<MemoryJudgeResult>() {});
                    return result == null ? null : validateAndFixResult(result);
                    }

                    判断要点:

                    • 按 role:content 生成消息 key 并标记重点内容,相同内容的历史消息也可能一并命中。

                    • 按 5 类信息定义 importance 区间(1-10)。

                    • 明确 scope 归属规则。

                    3、去重与冲突处理

                    在持久化前进行本地相似度去重,减少不必要的写入:类说明:MemoryPersistenceServiceImpl#calculateSimilarity 按 exact、contains、字符级 Jaccard(阈值 0.7)和短文本 Levenshtein(阈值 0.8)依次判断,相似即标记为重复;空值或未达到阈值则返回 none。它只负责同批次的本地预去重,跨历史记忆的冲突仍交给后续冲突服务处理。

                      batchPersist 完成本地去重后,先按 memCubeId 分组,再调用 batchDetectConflict 获取每条候选记忆的冲突结果。下面只保留逐条决定"写入新记忆、跳过,或记录待失效旧记忆"的核心循环:
                      for (int i = 0; i < memoryList.size(); i++) {
                          MemoryToSave memory = memoryList.get(i);
                          MemoryConflictResult conflict = i < conflictResults.size()
                              ? conflictResults.get(i) : MemoryConflictResult.noConflict();

                          if (!conflict.isHasConflict()) {
                              messagesToStore.add(createMessage(memory.getContent()));
                              continue;
                          }

                          ConflictResolutionResult resolution =
                              memoryConflictService.resolveConflict(
                                  tenantId, memOSUserId, memCubeId,
                                  memory.getContent(), conflict, modelId);
                          if (resolution.isShouldStoreNew()) {
                              messagesToStore.add(createMessage(memory.getContent()));
                              if (CollectionUtils.isNotEmpty(resolution.getMemoryIdsToExpire())) {
                                  memoryIdsToDelete.addAll(resolution.getMemoryIdsToExpire());
                              }
                          }
                      }

                      这里的“批量”主要指按 memCubeId 分组、复用一批待写入内容;冲突服务的批量方法在实现内部仍逐条调用检测接口,再逐条决定保留新记忆、跳过或标记旧记忆。因此它减少了分组和编排开销,但不能等同于一次网络请求完成全部冲突判断。

                      4、先写后删策略

                      为避免数据丢失,采用"先写新记忆,后删旧记忆"策略。

                      类说明:MemoryPersistenceServiceImpl#batchPersist 按 memCubeId 组装 MemOS 的 AddMemoryRequest,写入 userId、writableCubeIds 和 messages,并以 async、fine 模式调用 addMemory。只有返回结果中包含新增记忆时,才把冲突旧记忆 ID 交给 deleteMemories;删除异常只记录 warning,已经写入的新记忆继续保留。

                      这是一种"写入优先"的风险控制,而不是事务级一致性:MemOS 是外部 HTTP 服务,平台无法用本地事务同时包住新增和删除。当前删除失败只记录 warning,属于 best-effort;旧记忆可能暂时保留,后续检索或下一次冲突处理再进行清理。

                      七、核心设计与运行观测

                      这套实现把记忆处理拆成两条独立链路:请求前并行加载短期历史和长期记忆,会话结束后异步完成筛选、去重和持久化。核心策略集中在四点:

                      • 并行加载:短期记忆和长期记忆提交到同一个专用线程池,主流程在 join 处汇合。

                      • 新增消息标记:使用 [[NEW]] 标记本次新增消息,让 LLM 借助完整上下文提取新信息。

                      • 预算控制:短期历史采用滑动窗口并预留摘要空间,长期记忆按 scope 分组后分配固定 tokens。

                      • 可靠写入:Redis 锁和 hash 负责幂等,MemOS 侧先写新记忆、再尽力删除冲突旧记忆。

                      运行观测能力:系统提供运行概览、记忆类型分布、时间趋势、Top Agents 和 Cube 明细等查询能力,可用于了解记忆数据的规模、分类、来源及变化趋势,并支持按时间范围查看长期记忆搜索趋势,适合日常巡检、数据分布分析和异常定位。

                      八、总结与后续工作

                      短期记忆负责把当前会话带入下一轮,长期记忆负责把经过筛选的用户事实和 Agent 经验带到后续会话。两条链路在请求前并行读取,在会话结束后通过异步任务衔接;长期记忆再按 scope 和 Token Budget 控制注入内容。

                      当前方案已覆盖 Redis/MySQL 回退、MemOS 语义检索、LLM 判断、本地去重、冲突处理和先写后删。仍需补齐生产流量下的延迟与失败率观测,以及外部记忆服务失败后的补偿机制。

                      作者丨偶啦

                      来源丨公众号:得物技术(ID:gh_13ba5621e65c)

                      dbaplus社群欢迎广大技术人员投稿,投稿邮箱:editor@dbaplus.cn

                      跳转微信打开

                      •  

                      9.2级漏洞、七成网站依赖、48小时全网恐慌:拯救互联网的,竟是一个“无名之辈”

                      原创 整理自 2026-11-09 07:15 广东

                      “如果这个人出了什么意外,那就全完了,所有人都得跟着倒霉。”

                      维护全球无数网站的安全,听起来本该是一个庞大团队的工作。但过去二十多年,Ondřej Surý一直在业余时间默默完成这项任务。

                      他自愿维护两个流行的Linux发行版Debian和Ubuntu的PHP软件包,把官方源码打包成网站运营者能轻松安装的版本。没有多少报酬,也很少有人知道他的名字。

                      而前段时间,这位无名之辈安静的日常被打破了。

                      10月21日,PHP被曝出两个CVSS评分9.2的高危安全漏洞。作为约70%的网站都在使用的编程语言,它的安全问题足以牵动大半个互联网。

                      这两个漏洞由网络安全研究人员借助OpenAI的前沿大模型发现。一旦遭到利用,攻击者不仅能完全接管服务器、窃取或拷贝内部数据,甚至能直接让网站瘫痪。

                      负责维护PHP的官方团队(PHP基金会)虽然提前收到了漏洞信息,但补丁还没正式放出,漏洞细节就泄露到论坛。一场多方竞速的危机就此上演:基金会需要紧急开发并发布补丁;全球各地的开发者需要尽快完成部署;而攻击者则抓紧这个空窗期发起攻击。

                      Cloudflare首席执行官Matthew Prince后来回忆,漏洞公开前的10小时,他们监测到了数千次攻击尝试;而在公开后的短短45分钟内,攻击量飙升至数万次;两小时内突破数十万次,之后更是达到了数百万次。

                      在漫天告警、所有人四处寻找救命补丁的焦灼里,一个人的名字被反复提起。

                      这个人,正是Ondřej Surý。

                      Surý住在捷克,并不是PHP基金会的员工,目前担任Internet Systems Consortium的DNS工程总监。10月21日补丁发布后,多亏了他和极少数几位志愿者的努力,大量网站才能迅速完成修复。

                      “世界上竟然有这么一个人,他几乎包揽了全球大部分PHP的分发工作。”一位名叫Ian Landsman的开发者发推写道,“如果这个人出了什么意外,那就全完了,所有人都得跟着倒霉。”

                      有网友直接感慨:“他拯救了互联网。”

                      按理说,帮大半个互联网挡下危机的他,应该度过了一个惊心动魄的不眠之夜。但在《大西洋月刊》专访中,Surý给出的回答却完全出乎意料:他并没有太手忙脚乱。尽管事态紧急,但凭借自己的经验和事先准备,他有信心应对。

                      为什么Surý能如此从容?这场危机背后还有哪些细节?以下是《大西洋月刊》记者Charlie Warzel与Surý的对话实录。

                      《大西洋月刊》专访

                      Q:请尽量用通俗易懂的语言,告诉我过去72小时里发生了什么。

                      Surý:那周早些时候,PHP项目团队通知我,代码中存在一个严重的安全漏洞。周二,有人泄露了即将发布的漏洞信息。所以,PHP项目内部决定,把原本定在周四的发布计划提前到周三。这个时候,局面开始有些失控了,因为我们突然少了一整天的准备时间。

                      Q:我想换个更直观的角度来梳理一下:是大约有70%的网站在使用PHP语言吗?

                      Surý:我听说过这个数据。

                      Q:平时安全人员挖掘漏洞,往往是为了防御,而不一定是为了发起攻击。但这次真正的问题在于,漏洞被披露的范围太广了,而且留给大家打补丁的时间太短,对吧?

                      Surý:让我澄清一下,关键在于漏洞的严重级别,这次的严重性非常罕见。远程代码执行(RCE)是危害最大的漏洞类型,因为攻击者可以直接在跑PHP的服务器上执行任意代码。这也是为什么整个互联网会陷入恐慌。正如你所说,全球约70%的网站都在用PHP,一旦攻击者真的能在这上面执行代码,后果不堪设想。

                      Q:你刚才说,尽管网上炸开了锅,但对你而言,过去48小时并没有太手忙脚乱。从外界的视角来看,这挺让人意外的。我不断看到网友说:“负责修复这一切的其实就一个人,而且他还在靠Patreon(众筹打赏)维持生计。”网友的话可能有些夸张,但确实道出了部分真相:你几乎凭一己之力,帮到了数以百万计的人。对你来说,这怎么可能不算是疯狂的时刻呢?

                      Surý:原因有两点。第一,这项维护工作我已经做了20多年,大部分流程都已经自动化了。但真正让我没觉得手忙脚乱的原因是:我自己的服务器上并没有运行 PHP。我确实觉得自己要对互联网用户负责,但不会说很慌乱。如果我当时正好在亚得里亚海的船上度假,连不上网,那对我来说才会是真正的麻烦。好在,我有充足的时间来打包这些程序。

                      Q:这确实挺让人意外的。

                      Surý:即使没有我,大家也能从其它渠道拿到PHP源码并自行编译。只不过那样一来,对所有人来说都会麻烦得多。而且还有不少用户没有能力立刻升级PHP。PHP项目组只负责发布源码,我的工作是把源码打包成服务器上可以直接安装的软件包。

                      这种方式很方便,速度快,还能自动化部署,你能直接在成百上千台服务器上批量安装,不用自己编译源码。如果我不在,大家就得花更多时间,有些人甚至根本无法完成。所以,其实应该归功于PHP项目组,是他们把我拉进了提前获知漏洞的保密小组。

                      Q:收到通知的时候,你有没有立刻意识到事情很严重,心里很紧张?

                      Surý:我的第一反应是,这是个很严重的漏洞,必须马上修复。但我没有很紧张,至少对我个人而言是这样。当然,这确实让很多人慌了神。但对我来说,更像是:出了问题,要解决,那我们按部就班处理掉就行。而且我有充足的时间提前做好准备。如果留给我的准备时间很短,压力肯定会很大。但这次没有,毕竟我只是一名志愿者。

                      Q:我每次写网络安全、开源相关报道时,都会碰到很多像你这样的维护者:完全出于热爱来做这份工作,大部人都默默无闻。假如发生意外,比如你出事了,会有人立刻接上你的工作吗?

                      Surý:我其实一直在思考应急预案。我正在和Freexian的Raphaël Hertzog对接。我的优势是经验充足,清楚怎么把这套流程跑通。Freexian团队本身实力很强,如果真有突发状况,他们有能力接手这项工作。从昨天开始,不断有人给我捐款,金额大小都有,非常感谢大家。

                      Q:如果这次没有这么快打上补丁,会发生什么?

                      Surý:后果会很严重。最基础的情况是网页被篡改、网站被迫下线,这类事件在互联网上本就时有发生。更危险的是,攻击者拿到权限后,会把服务器纳入僵尸网络。现在做这类攻击的大多是有组织的犯罪团伙,已经不是早年那些在地下室里自娱自乐的黑客。这背后有一条很长的利益链,他们可以出售僵尸网络的访问权,或是拿这些服务器挖加密货币。风险到现在依然存在,还有不少站点没有完成PHP补丁升级。

                      Q:我在X上看到一条帖子说,并非所有PHP版本都放出了补丁,现在有三分之一的互联网处于长期受损或高危的状态。这说法准确吗?

                      Surý:这个传言不准确。旧版本同样可以打补丁。

                      Q:也就是说,并不是三分之一的互联网都陷入危险了。

                      Surý:对,这个说法并不准确。只要愿意投入精力,旧版PHP都可以完成修复。

                      Q:当下网络安全局势确实不容乐观。我看到有人把这次漏洞连同其它由AI智能体发起的攻击,称为 “黑色十月”。不少人担心,不管是攻击侧还是防御侧的Agent,都有能力挖掘这类漏洞。安全圈子里一直有一种焦虑:害怕未来漏洞的发现、利用速度会突破人类的处理上限,而现在,这份担忧正在变成现实。也有一部分人认为这其中存在一种平衡:既然有专攻漏洞挖掘、漏洞利用的Agent,自然也会有专注防御的Agent与之抗衡。

                      Surý:我们能看到的事实是,漏洞相关的攻防节奏确实在加速,这点毋庸置疑。防御方同样可以使用大模型来找漏洞。但我认为,归根结底还是在于:IT基础设施往往被视作理所当然、被人忽视的底座。

                      各行各业对基础设施维护的重视程度和资金投入都严重不足。不光是企业系统,大量老旧消费设备也会沦为攻击目标。我承认现在变化太快,压得防御人员疲于奔命。但换个角度看,这或许会成为一个转折点,倒逼大家真正重视基础设施安全。

                      Q:你觉得大家真的会重视起来吗?

                      Surý:也许我太乐观了,但我认为大家最终会意识到,我们不能再这样下去了。这个问题积压了很久,迟早会酿成重大事故。这次事件只是敲响一次警钟,未来可能还会有类似的危机。

                      Q:互联网一部分基础设施,居然高度依赖一两个人,这点让我很震惊。这种脆弱性让人感到不安,你希望看到怎样的改变?

                      Surý: 我刚做开源的时候,只觉得这件事很有意思,到现在我依然这么认为。但大环境已经不一样了,如今的开源,有时更像一种变相的剥削。我期待出现新的模式:开源维护者可以从最大的受益方那里,拿到和投入时间相匹配的回报。我希望企业能认清这一点,看清这就是剥削。剥削本身无法长久。如果现状持续下去,后果会很难看。开源维护者早晚都会失去继续坚持的动力。

                      Q:听起来,你并没有把功劳都揽到自己身上。但事实上,你做了大量的工作,并且帮助了很多人。经历了这一切,那晚睡觉前,想到自己发挥的关键作用,你感觉如何?

                      Surý:我妻子常说我是个“情感绝缘体”,但其实并不是。看到社交平台上满屏的感谢,还有一封封致谢邮件,心里确实挺温暖的。它让我感受到这份工作的意义,真切体会到自己做的事情是有价值的。

                      Q: 整个互联网都感谢你的付出。借着这个机会,对于普通用户在日常网络安全方面,你有什么建议?

                      Surý:我的建议是相信专业人士。遇到危机时我们都该如此:听专家的建议,相信他们。依靠负责维护这些系统的人,他们知道该怎么处理。

                      >>>>

                      参考链接

                      整理丨dbaplus社群

                      *仅为提供参考和学习交流,不代表dbaplus社群立场!dbaplus社群欢迎广大技术人员投稿,投稿邮箱:editor@dbaplus.cn

                      跳转微信打开

                      •  

                      从怒斥到真香定律,Linus现用Claude Code改内核 :性能暴涨23倍,结果被维护者发现Bug……

                      原创 整理自 2026-11-06 07:15 广东

                      人对代码质量的把控,始终是最后一道防线。

                      Linux 创始人、长期担任首席维护者的 Linus Torvalds 借助 Anthropic 的 Claude Code 改内核。

                      10 月 13 日,他提交了一组 10 个补丁的合集。在他的 Ryzen Threadripper 上运行的合成基准测试中,这组补丁将吞吐量提升了 23 倍。但补丁还没正式合入主线,社区维护者就揪出了一个连 Linus 和 AI 都没发现的 Bug。

                      大神都有兜不住的Bug?这要从一个困扰了开发者们两年多的性能问题说起。

                      一、一个两年无解的内核瓶颈

                      2024 年,Oracle 工程师、资深 Linux 内核内存管理开发者 Matthew Wilcox 在处理客户工作负载时,发现了页缓存的 folio 引用计数争用问题,并标记下来。

                      根据 Hardware Busters 的测试数据,在 Linus 的 Core i7-8565U 笔记本上的 8 线程测试中,folio 引用计数争用占到了跨核 HITM 开销的 99.92%。

                      之前,为了解决页缓存引用计数的性能瓶颈,Linus 自己写过一版修复方案,断断续续用了 18 个月,但这个版本一直存在缺陷。其他开发者也尝试过不同的优化思路,同样没能彻底解决问题。

                      二、Linus 亲自承认用 AI 写内核代码

                      针对这个久攻未决的瓶颈,Linus 拿出了新的优化方案。令人震惊的是,该方案竟然是 Linus 借助 AI 完成的。

                      10 月 11日,Phoronix 的 Michael Larabel 发现,Linus 的内核代码树中出现了一个名为 noref-filemap-read-with-llm 的新分支。 熟悉 Linus 开发习惯的人都知道,他的代码树极少收录主线开发分支之外的内容。

                      noref-filemap-read-with-llm Git 分支

                      这个包含 8 个补丁的版本基于 Linux 7.3-rc6 开发,提交记录里清晰说明了 Claude Code 的具体分工。

                      在补丁信息中,Linus 确认了 AI 的参与:

                      “上述代码、测试程序、审查工作以及本文初稿都是在我的指导下,由一位 LLM 编码助理(Claude Code)完成的。基准测试都是在我的机器上运行的。”

                      这与 Linus 此前的公开立场形成了鲜明对比。他曾将 AI 描述为“90% 是营销”,也曾批评开发者“用 AI 写了 99% 的代码”。而现在,他不仅在内核之外用 Google 的 Antigravity 进行了一些虚拟编程, 还用 AI 辅助内核调试。

                      三、性能提升23倍,但也有代价

                      让业内意外的不只是 Linus 用上了 AI,更是他提交的这组补丁走了一条更大胆的技术路线。

                      早前有人尝试过的思路是:读取拷贝时不持有 folio 引用,读完再校验数据有效性,但该方案在内存回收、页替换场景下存在竞态条件。

                      而 13 日 Linus 推出的 10 补丁 rcu-free-v3 系列,是新增 PG_rcu_free 标志位,采用 RCU 延迟回收机制,只要用户态数据拷贝过程不触发缺页异常,就能在整个读取周期内安全访问 folio 结构。

                      根据 Threadripper 基准测试结果,两个版本的性能提升非常显著:

                      最初的 8 补丁版本在 Linus 的笔记本上就已经翻了近三倍的吞吐量:8 线程场景下,每秒读取次数从 1000 万提升至 3300 万,单次读取消耗的内核周期数从约 2950 降至 725。

                      而优化后的 10 补丁版本,在 64 线程 Threadripper 的高并发争用场景下提升更夸张:吞吐量从每秒 1330 万次读取跃升至 3.04 亿次,单次读取的内核周期数从近 2 万降至 735,也就是 23 倍的性能提升。

                      但 Linus 也明确提醒,在实际工作负载中,基准测试的性能涨幅会小很多。这是极端合成基准的结果,不代表 Linux 整体性能提升。

                      而性能提升也并非没有代价。

                      据 Hardware Busters 报道,在 8 补丁最初实现版本中,只要单个 CPU 的待回收页面队列超过 1024 个,延迟回收机制就会触发强制快速宽限期,加急完成页面回收。

                      此外,针对未映射的用户页读取操作,在回退到原有流程前会额外触发一次缺页异常,导致单线程下 16 字节读取的周期数从约 4150 攀升至 6550。

                      目前这一性能回退问题在 rcu-free-v3 版本中是否已修复,还没有明确结论。

                      四、维护者质疑,大神也有没兜住的Bug?

                      针对 Linus 的方案,最早发现该内核瓶颈的Matthew Wilcox 对新增的 PG_rcu_free 标志位提出异议,建议改用页面类型标识,同时配合在 RCU 宽限期后回收非活跃链表中的 folio。

                      Linus 否决了这两种思路。他认为,该标志位必须在 folio 仍可被映射到用户空间时就完成设置,而非活跃链表回收机制无法覆盖文件截断(truncate)和打洞(hole-punch)两类操作场景。

                      此前针对该瓶颈提交过优化方案的内核开发者 Kiryl Shutsemau 也参与了讨论。他提议将该标志位的使用限定在 64 位系统上,这一方案得到了 ARM 工程师、Linux 内存管理子系统维护者 David Hildenbrand 的支持。

                      真正关键的是,Shutsemau 还在 filemap_read_rcu_batch() 函数中发现了一处竞态条件:folio 替换完成后再扩展文件大小(i_size),可能会暴露从未实际写入的数据。Linus 建议提前读取文件大小,并合并 folio 校验逻辑,Shutsemau 已将该方案整合进了修订版补丁。

                      随后,Linus 将后续开发工作移交给了 Shutsemau。

                      10 月 19 日,Shutsemau 发布了一组补丁集。这套补丁基于之前 Linus 的代码思路改造实现,核心是修改 Linux 内核内存管理逻辑,做到不需要持有 folio 引用就可以完成页缓存读取。

                      他在补丁说明中解释了背后的原理:

                      “当多个 CPU 对同一个文件执行小块读取时,每个 CPU 都要对同一个 folio 做一次引用获取、一次引用释放,导致引用计数在多个 CPU 之间来回颠簸。该补丁集让 filemap_read() 函数以及共享内存(shmem)场景,都可以跳过引用获取步骤,直接从页缓存拷贝数据。这是对 Linus 原 RFC 方案的重构:读取进程正在拷贝的 folio 页,只会在 RCU 宽限期结束后才会被释放。”

                      他还在 EXT4、TMPFS、XFS 三种文件系统以及原始块设备上验证了这套优化的效果。测试基于 AMD Ryzen Threadripper 处理器,采用 64 线程并发,分别在开启和关闭默认 CPU 安全缓解机制的场景下完成。

                      测试结果相当亮眼:

                      提升效果相当惊艳。这组补丁目前还处在 RFC 征求意见阶段,仍有部分设计细节没有最终落地,但这些问题预计很快就能解决,距离合入内核主线已经不远了。

                      五、结语

                      Linus 曾批评“AI 写了 99% 代码”的浮夸论调,而这次 AI 辅助开发、人类审查兜底的实践,恰恰给出了最明确的答案:AI 是提升开发效率的利器,但工具终究只是工具,人对代码质量的把控,始终是最后一道防线。

                      >>>>

                      参考链接

                      整理丨dbaplus社群

                      *仅为提供参考和学习交流,不代表dbaplus社群立场!dbaplus社群欢迎广大技术人员投稿,投稿邮箱:editor@dbaplus.cn

                      跳转微信打开

                      •  

                      还好大促前刷到了!一种基于分布式缓存的强一致性热点库存扣减方案

                      聆枫 2026-11-05 07:15 广东

                      以下文章来源于:千问AI平台

                      千问AI平台

                      千问AI平台,为AI Agent 而生

                      如何在保证扣减强一致性的同时,提升库存热点扣减TPS和扣减稳定性?

                      前言

                      本文主要介绍了针对热点深库存下单抢购场景,库存团队设计并实现的一种基于Redis分桶扣减计数和合并提交扣减DB的方案;该方案基于分布式缓存实现,但也能做到不超卖不少卖,在保证扣减强一致性的同时,也提升了库存热点扣减TPS和扣减稳定性。

                      一、背景介绍

                      自库存团队成立以来,随着业务的不断发展,库存扣减性能优化一直是库存团队不断面临的挑战;近几年,库存和数据库团队一起,从数据库内核优化、到应用层优化、再到扣减架构升级,持续的提升库存DB扣减的性能。在前述优化的基础上,库存数据库的整体性能得到了很好的提升。

                      然而随着直播业务的发展,热点扣减的场景越来越频繁,对于深库存热点扣减的场景,日常我们只能通过限流的方式来保护DB,库存合并扣减就是在这样的背景下提出的,我们希望继续优化热点扣减的性能,使库存扣减不成为热点下单链路的瓶颈所在。

                      二、方案调研

                      传统的提高热点扣减的方案都是通过分布式缓存实现,该类方案通过将库存从 MySQL 划分到多个Redis分桶,扣减的时候直接走Redis进行扣减,分析此类方案,我们会发现:

                      1)该类基于缓存的扣减方案确实能够大幅提升扣减的性能;

                      2)但是这个库存扣减方案在实际应用中也会存在一些问题:

                      • 无法避免库存少卖:针对Redis失败(如超时)的场景,应用层实际并不知道Redis库存是操作成功还是操作失败。为了避免库存超卖,对于扣减超时的场景,应用层只能默认当做失败处理;对于库存回补的场景,应用层只能默认当做成功处理。此时整体是业务有损的,所以Redis分桶扣减方案一般是用在卖家限购、权益这类非实物类库存扣减的场景,这类场景业务接受少卖。

                      • 对于稍微复杂的库存扣减模型无法支持:Redis库存扣减方案中使用incr和decr实现库存的加减,利用lowBound防止库存减到负数,value即是剩余的库存数量;这个方案只支持库存记录仅包含一个数值的库存模式, 对于sq- 同时wq+ 这种模式无法支持。

                      • 库存扣减完全依赖Redis:当前扣减方案需要强保障Redis的稳定性,如果Redis异常则整个扣减链路异常。

                      我们想利用Redis提升扣减性能,但是我们的库存扣减模型相对更加复杂、同时我们的业务场景对于库存数据准确性要求更高,绝对不允许超卖少卖;传统的基于redis分桶扣减的方案并不完全适合我们的业务场景。

                      三、合并扣减方案

                      介绍合并扣减详细方案之前,先简单说明下库存域的几个基本概念,方便大家更好理解后续的内容。

                      1) 库存核心字段:

                      • 可售库存:sq,实际可售的库存数量;

                      • 预扣库存:wq,用户下单后,库存sq转向wq;

                      • 占用库存:oq,货品仓库存模式,付款之后,库存从wq转向oq。

                      2)库存扣减明细(也叫单据):是库存扣减的快照,明细是不可或缺的。明细的作用:

                      • 记录扣减信息:下单是交易会告诉我们扣多少库存,后续付款或者订单取消时,上游不用关心库存的回补数量,库存内部从明细恢复;

                      • 用于分布式系统交互过程中的幂等实现:同一个单据调了两次扣减;单据回补超时,重试可幂等;

                      • 负责库存扣减生命周期状态流转。

                      1、整体思路

                      我们既想利用分布式缓存(Redis)提升扣减性能,但同时又不能直接依赖Redis作为库存存储介质;因此我们的方案里面,Redis只用来做扣减计数以防止超卖,实际扣减是否成功以库存扣减明细为准。 整体思路如下:

                      1)DB行的库存提前预留(锁)一部分,锁的这个库存还在DB行上,同时也初始化到redis里面用于扣减计数;

                      2)合并扣减下单过程中,先扣减redis库存,redis库存够扣的情况下,再往DB插入扣减明细,明细插入成功最终才算扣减成功;

                      3)应用层的合并扣减管理模块,热点下单延迟1s后,通过扫描扣减明细,计算实际应该扣减的数量,一次提交库存变更到DB。

                      接下来介绍各个分模块的设计。

                      2、锁库存模块

                      1)锁库存模块将DB行库存从sq字段(可售)锁到lq字段(预锁库存),同时锁库存单据;

                      2)锁库存核心实现,不是通过将sq减去然后加到lq,而是sq不动,锁库存直接加到lq;DB扣减时通过 where sq-lq>0 控制最终sq的数量不能小于lq。这个设计使得锁库存之后,库存展示链路完全不受影响,查询可售库存时也完全不需要关心锁的库存值,大大的降低整个链路上的复杂性,这是一个非常重要的设计。

                      3)每次锁定的lq数量,初始化到Redis里进行扣减计数。

                      多个redis分桶通过redis分桶缓存进行索引:

                      3、下单扣减模块

                      先扣redis分桶库存,成功则继续插入DB明细;失败则兼容走老的DB扣减流程:

                      4、合并提交模块

                      1)先失效合并提交对应的redis分桶,防止后续继续有交易流量扣减此redis分桶;

                      2)根据分桶key扫描此分桶关联的所有扣减明细,计算库存扣减数量,合并扣减DB。

                      • 实际Redis分桶扣减的库存数量,以合并下单明细为准,通过扫描明细上的扣减库存总和得到;

                      • 这里我们针对数据库明细表,设计了覆盖索引(invId,lockOrderId,quantity),通过sum(quantity) 走索引就能直接得到每个Redis分桶实际扣减的库存;压测和线上效果都表明,此扫描单据的SQL对DB热点扣减的性能影响非常小。

                      5、库存回收模块

                      1)库存回收指将预锁定的库存释放回收到可售卖的状态,以下几种场景需要回收库存:

                      • 商家编辑场景,直接走的DB扣减,redis有剩余库存,而商家编辑时将总库存编辑成0,此时我们需要先释放预锁库存;

                      • 临界场景:Redis分桶只有1件库存,DB两件库存,下单两件库存库存,此时将Redis的库存回收到DB后继续扣减。

                      2)库存回收在实现上可以直接通过调用分桶合并提交来完成。

                      6、防超卖少卖设计

                      1)前面锁库存模块也已经提到过,DB可售sq锁到lq,扣减SQL层直接通过 set sq = sq -δq where sq-lq - δq> 0 的方式保证DB不超卖。

                      2)而Redis扣减,分桶的剩余库存值不能小于0,保证不超卖;同时如果Redis数据丢了,实际这个Redis分桶库存扣减了多少,以DB合并下单明细为准,也不会少卖。

                      3)高并发场景下,下单扣减和合并提交单据扫描并发的情况下,可能会出现少扫描了单据,如果少扫描单据了,则会超卖;我们通过Redis扣减屏障防止此并发场景下的超卖;具体链路如下:

                      7、自动锁库存模块

                      通过热点识别能力,感知交易相关系统的热点品库存查询,提前将满足条件的商品库存进行自动锁库存;只要一开始提前锁了任意数量的库存,后续下单扣减过程中,则会继续自动触发锁库存。

                      8、性能优化效果

                      接下来我们看下合并扣减的效果:

                      1)压测效果

                      从压测效果上看,单行热点扣减场景下,非合并扣减tps峰值约1.4w,合并扣减峰值3.2w;整体提升1倍以上扣减性能(实际线上场景,由于入口做了限流,所以线上达不到压测的流量峰值)。

                      2)线上效果

                      线上由于入口开了限流,库存扣减峰值tps都在7k+,差异体现在扣减成功率和耗时上:

                      走到合并扣减的热点品,库存扣减成功率在100%,接口扣减耗时7ms+;未走到合并扣减的热点品,库存扣减成功率在80%上下,接口扣减耗时15ms+。

                      结语

                      以上则是基于分布式缓存的强一致库存扣减方案的全部内容,欢迎大家一起交流。

                      作者丨聆枫

                      来源丨公众号:阿里云开发者(ID:ali_tech)

                      dbaplus社群欢迎广大技术人员投稿,投稿邮箱:editor@dbaplus.cn

                      跳转微信打开

                      •  

                      入职第一天,被前同事写的SQL查询语句,吓到当场离职……

                      原创 Rohan Dutt 2026-11-04 07:15 广东

                      写得乱七八糟的SQL,根本不叫技术,纯粹是给别人挖坑!

                      把SQL查询写好,让意图、假设和计算逻辑自己就能解释清楚,不需要额外说明。

                      上个月,我打开了一个SQL文件。当时我就想,这都是什么鬼?!

                      1400行嵌套混乱的代码:没有注释,没有结构,完全不知所云。

                      到处都是 tbl_a、final_temp_v3 这种别名。

                      我花了一天半才把它理顺。

                      最离谱的是,查询居然成功了。

                      可等到财务部门问为什么营收数据对不上时,所有人都哑口无言。

                      写得乱七八糟的 SQL 根本不叫技术,纯粹是给别人挖坑。

                      我曾经亲眼目睹一位同事凌晨两点重写了一整段查询语句。为什么?因为一个 WHERE 条件被藏在了六个子查询的深处,根本找不到。

                      团队每年都要浪费好几周去修这种“自以为聪明”的代码。如果你的 SQL 语句需要翻译(解释)才能看懂,那你不是在写代码,而是给未来制造麻烦。

                      一、架构原则

                      不想让别人反复追问你的代码逻辑,必须一开始就注重代码的可读性。以下是我遵循的架构原则,确保每条查询都清晰易懂,而不是暗藏玄机。

                      1、清晰的架构

                      1)利用 CTE 摆脱子查询的噩梦

                      嵌套子查询就像剥洋葱,只会让人越看越头疼。

                      公共表表达式 (CTE) 可以让你自上而下梳理逻辑,让数据流向变得线性清晰。

                      2)“人类可读性”规则

                      • 规范别名:将t1or替换a为active_customersor monthly_recurring_revenue;

                      • 布尔标记字段:与其写 status_id IN (1, 4, 7),不如新增一个名为 is_eligible_for_discount(是否符合折扣资格)的判断字段;

                      • 线性逻辑:把 SQL 当作菜谱来写。准备好食材( CTE 定义),混合它们(表连接),最后摆盘(最终查询)。

                      2、“自带说明”改造

                      假设我们正在计算客户留存率。在“改造前”的写法中,你会看到层层嵌套的括号。而改造之后的逻辑一目了然。

                      1)改造前(混乱版)

                        SELECT t1.id, t1.rev, t2.last_login 
                        FROM ( SELECT  *  FROM sales WHERE amt >  100 ) t1 
                        JOIN ( SELECT user_id, MAX (dt) as last_login FROM logs GROUP  BY  1 ) t2 
                        ON t1.id = t2.user_id 
                        WHERE t2.last_login <  '2025-01-01' ;

                        2)“改造后”(自带说明版)

                          WITH high_value_sales AS ( 
                              -- 筛选超过 100 美元的交易以隔离关键客户
                              SELECT 
                                   customer_id, 
                                  amount AS revenue 
                              FROM sales 
                              WHERE amount >  100
                           ), 


                          customer_activity_tracking AS ( 
                              -- 识别每个用户最近的交互
                              SELECT 
                                   user_id, 
                                  MAX (login_date) AS last_active_date 
                              FROM user_logs 
                              GROUP  BY user_id 
                          ) 
                          SELECT 
                               hvs.customer_id, 
                              hvs.revenue, 
                              cat.last_active_date 
                          FROM high_value_sales hvs 
                          JOIN customer_activity_tracking cat ON hvs.customer_id = cat.user_id 
                          WHERE cat.last_active_date <  '2025-01-01' ;

                          这样写的优势:

                          • 逻辑隔离:如果“收入”逻辑发生变化,你能知道改哪个 CTE ,不用改动连接逻辑;

                          • 可审计性:当财务部门询问该项收入时,你可以直接指向 high_value_sales 代码块,从命名就能一目了然;

                          • 10 秒测试:一名初级开发能否在 10 秒内看懂这段代码的用途?如果不能,就需要重构。

                          这一套方法给我们团队带来的改变简直惊人,再也不用为了解释数据看板的逻辑而开“紧急会议”了。

                          小建议:写 SQL 的时候,哪怕明年凌晨三点困得睁不开眼,你也能看懂自己写的代码。

                          二、让 SQL 更易于理解的 4 个架构优化 

                          你有没有盯着半年前自己写的 SQL,感觉像是在看外星古文?

                          我曾经花了一整个下午,才看懂自己当年 “自以为很巧妙” 的查询语句。

                          现在才明白,所谓的“巧妙”,到头来只是“坑未来的自己”。这真是个大教训。想要从根源上避免别人(包括未来的自己)追问你的代码逻辑,你就得写出自带解释、一看就懂的查询。

                          说明:每种优化的完整实操流程我都会详细展开,这里先讲清楚重要性和方法。

                          1、 CTE 堪称救星

                          这种 WHERE EXISTS (SELECT… FROM (SELECT…)) 套来套去的写法趁早别用了!子查询嵌套简直是人脑的递归噩梦。

                          改用 CTE ,将逻辑拆成线性、连贯的流程。

                          上个月我用这种方法重构了一个长达 200 行的复杂代码。我同事的反应是:“等等……这居然能看懂了?” 

                          2、字段命名语义化(请不要使用缩写)

                          字段命名至关重要。revenue_after_refunds这样写并不算长,反而更友好。

                          用 a、b、t1 这种别名,就像你把厨房里所有罐子都贴上 “食物” 标签一样敷衍。

                          当你凌晨两点还在调试代码时,未来的你一定会由衷庆幸:至少知道每个字段到底代表什么。

                          3、缩进 = 氧气(给查询一点呼吸空间)

                          缩进是留白,让你的逻辑能呼吸,更易读。

                          我曾遇到过一个 bug,JOIN 语句藏得像海盗宝藏似的。这种问题本该 5 分钟定位,结果硬生生花了两小时。

                          从那以后,我格式化代码格外认真:JOIN、AND 条件、CASE 语句全部对齐排版,整齐规范。

                          4、把假设打上标签(你没听错)

                          不要只写代码做了什么,SQL 本身已经能看出来。

                          关键是写下为什么这么做:# Ignores test accounts,处理耗时约2秒。

                          三个月后你只会抓狂:“我当初为什么要把 user_id > 1000 排除掉?!” 你记不住,但注释可以。

                          经得起追问的 SQL 优化示例

                          下面是一组专业级的进阶优化对比。场景为计算净营收,同时过滤内部测试数据、处理复杂退款逻辑。

                          逻辑噩梦(优化之前):

                            SELECT t1.id, SUM (t1.amt - t2.ref_amt) as net 
                            FROM orders t1 
                            LEFT  JOIN ( SELECT ord_id, SUM (amount) as ref_amt FROM refunds GROUP  BY  1 ) t2 ON t1.id = t2.ord_id 
                            WHERE t1.status_id NOT  IN ( 4 , 9 ) AND t1.u_id >  1000 
                            GROUP  BY  1 ;

                            自带说明的杰作(优化之后):

                              WITH refund_aggregates AS ( 
                                  -- 对每个订单的退款金额求和,以避免多对一连接膨胀
                                  SELECT 
                                       order_id, 
                                      SUM (refund_amount) AS total_refunded_amount 
                                  FROM order_refunds 
                                  GROUP  BY order_id 
                              ), 


                              filtered_active_orders AS ( 
                                  -- 排除已取消 (4) 和欺诈 (9) 的订单
                                  -- 排除内部测试帐户(ID > 1000 为生产用户)
                                  SELECT 
                                       order_id, 
                                      customer_id, 
                                      gross_transaction_amount 
                                  FROM transaction_ledger 
                                  WHERE status_id NOT  IN ( 4 , 9 ) 
                                    AND user_id >  1000
                               ) 
                              SELECT 
                                   orders.order_id, 
                                  (orders.gross_transaction_amount -  COALESCE (refunds.total_refunded_amount, 0 )) AS net_realized_revenue 
                              FROM filtered_active_orders AS orders 
                              LEFT  JOIN refund_aggregates AS refunds 
                                  ON orders.order_id =退款订单号;

                              真相:这不是为了写出完美代码,而是为了以后不恨自己,这是为了热爱你的工作……

                              现在多花五分钟,将来能省下五小时的暴躁调试。

                              当业务方或资深架构师质疑你的逻辑时,你完全不必慌。

                              • 你的同事:交口称赞

                              • 你的精神状态:安稳平和

                              • 未来的你:轻松起飞

                              三、提升可读性的进阶写法

                              同时我也很快意识到,有时候修复不光是加几条注释的事。

                              那是结构性问题。

                              我开始用 CTE 把一堵密密麻麻的代码墙,梳理成按时间顺序展开的逻辑叙事。

                              你不用像考古学家那样一层层深挖子查询,而是像读一本书一样,从上到下看懂就完事。

                              1、“嵌套地狱”与“叙事式 CTE”

                              核心原则:如果你的逻辑需要超过 5 秒才能看懂,那它就是不合格的,必须重构。清晰易懂不是锦上添花,而是代码的生命线。

                              重构后的标准写法:

                                /* 目的:计算 2025 财年的年度客户流失率。
                                   理由:根据领导层 2025 年 11 月 12 日的指示,不包括试用账户。*/ 
                                */ 
                                WITH valid_subscriptions AS ( 
                                    -- 过滤掉内部测试帐户和过期试用帐户
                                    SELECT 
                                         user_id, 
                                        subscription_start_date, 
                                        total_recurring_revenue 
                                    FROM production_schema.subscriptions 
                                    WHERE is_internal_account =  FALSE  
                                      AND subscription_status !=  'trial_expired'
                                 ), 
                                annual_revenue_calculation AS ( 
                                    -- 按用户汇总收入以处理多计划帐户
                                    SELECT 
                                         user_id, 
                                        SUM (total_recurring_revenue) AS total_user_revenue 
                                    FROM valid_subscriptions 
                                    WHERE subscription_start_date >=  '2025-01-01' 
                                    GROUP  BY  1
                                 ) 
                                SELECT  
                                    COUNT (user_id) AS total_active_customers, 
                                    SUM (total_user_revenue) AS total_fiscal_revenue 
                                FROM annual_revenue_calculation;

                                2、严苛型架构师的三大守则

                                说明:这相当于把文档工作开到地狱难度……(不感兴趣可以忽略)

                                • 元数据层规范:我开始对每张表、每个字段都使用 COMMENT ON 命令添加注释。现在,字段与表的说明直接固化在数据库结构中。团队成员不再反复问基础问题,因为答案就写在元数据里。只要开发人员查看表结构,文档说明就直接呈现在眼前。

                                • 强制代码检查规则:我在开发环境中集成了一个SQL 代码检查工具,并配置规则直接禁止 rev_tot、t1 这类敷衍命名,同时强制规范缩进与语义化命名。现在,在提交合并请求之前,工具就会提前标出不规范写法。

                                • 上下文动机注释:我不只注释代码做了什么(代码本身已经能体现),还注释为什么这样做:- 仅保留2023年数据,避免历史冗余数据干扰(业务方要求)。这样就不会再出现团队群里紧急追问的情况。我的查询语句,本身就能解释自己存在的意义。

                                四、逻辑自查:建立专业可信度

                                打开你最近写的一段 SQL 脚本。

                                试着重构其中一个 CTE 或子查询,给它起一个清晰到不是技术岗产品经理都能看懂的名字。

                                把 mau_temp 改成 monthly_active_users(月活跃用户)。把 t1 改成 filtered_transaction_logs(已过滤交易日志)。

                                你会发现,当你大声读出这段逻辑时,不用任何额外说明,思路瞬间就通了。

                                这就是命名的力量。它能把一段晦涩的代码谜题,变成一段通顺易懂的逻辑叙事。

                                编写自解释 SQL 查询的详细步骤:

                                步骤1:用命名 CTE 替代子查询

                                实操流程:

                                1)定位到实现某条具体业务规则的嵌套子查询;

                                2)将其抽离至 WITH 子句中,并使用语义清晰、面向结果的命名;

                                3)在主逻辑块中直接引用这个命名好的 CTE。

                                例子:

                                  -- 修改前(逻辑隐藏较深,需要进行思维导图)
                                  SELECT order_id 
                                  FROM orders 
                                  WHERE customer_id IN ( SELECT id FROM customers WHERE status =  'active' ); 


                                  -- 修改后(逻辑线性且自描述)
                                  WITH active_customers AS ( 
                                      SELECT id 
                                      FROM customers 
                                      WHERE status =  'active'
                                   ) 
                                  SELECT order_id 
                                  FROM orders 
                                  WHERE customer_id IN ( SELECT id FROM active_customers);

                                  结果:查询语句读起来就像一组指令,未来的你(或是同事)不用一层层去找括号,就能立刻看清逻辑依赖关系。

                                  步骤2:使用能完整说明含义的字段别名

                                  实操流程:

                                  1)遍历查询语句,找出 SELECT 子句或复杂计算中含义模糊的字段名称;

                                  2)将其替换为能体现设计意图的别名,明确说明数据的状态与用途;

                                  3)应用到 JOIN 关联条件中,让表与表之间的关联关系一目了然。

                                  例子:

                                    -- 修改前(计算不明确)
                                    SELECT
                                         (price * quantity) - discount AS final_amount 
                                    FROM orders; 


                                    -- After ( Explicit business logic) 
                                    SELECT
                                         (price * quantity) - discount AS total_revenue_net_of_discounts 
                                    FROM orders;

                                    结果:业务分析师不用对照数据字典就能直接理解你的查询结果。由于字段名称本身就定义了数据含义,排查问题也变得一目了然。

                                    步骤3:有策略地使用留白和缩进

                                    实操流程:

                                    1)将主要子句(SELECT、FROM、WHERE、GROUP BY)各放一行;

                                    2)缩进JOIN条件和子逻辑,体现层级关系;

                                    3)用空行分隔数据准备阶段(CTE)和最终聚合阶段。

                                    例子:

                                      -- 修改前(数据密集,解析困难)
                                      SELECT o.id, c.name, SUM (p.amount) AS revenue FROM orders o JOIN customers c ON o.customer_id = c.id JOIN payments p ON o.id = p.order_id WHERE o.status =  'completed'  AND c.is_active =  TRUE  GROUP  BY o.id, c.name; 


                                      -- 修改后(结构化且易于扫描)
                                      SELECT
                                           o.id, 
                                          c.name, 
                                          SUM (p.amount) AS lifetime_settled_revenue 
                                      FROM orders o 
                                      JOIN customers c 
                                          ON o.customer_id = c.id 
                                      JOIN payments p 
                                          ON o.id = p.order_id 
                                      WHERE
                                           o.status =  'completed' 
                                          AND c.is_active =  TRUE 
                                      GROUP  BY
                                           o.id, 
                                          c.name;

                                      结果:你的查询看起来像一份专业的技术规范书,向同事传递一个信号:逻辑严谨、值得信赖。

                                      步骤4:将业务前提直接嵌入查询语句

                                      实操流程:

                                      1)找出代码中隐含的业务逻辑(例如 “仅适用于美国用户”“排除内部测试账号” 等);

                                      2)添加行内注释,使用统一标识前缀(如 -- #),将业务规则与普通代码说明区分开;

                                      3)把注释直接写在对应逻辑的位置,而不是只放在文件头部。

                                      例子:

                                        WITH regional_customer_base AS ( 
                                            SELECT 
                                                 user_id, 
                                                signup_date 
                                            FROM customers 
                                            WHERE country_code =  'US' 
                                            -- # 业务规则:根据 2025 年税务合规更新,排除地区(波多黎各、关岛、美属维尔京群岛)
                                            AND state_code NOT  IN ( 'PR' , 'GU' , 'VI' ) 
                                        )

                                        结果:你的查询将具备可审计性。当业务方质疑数据为什么发生变化时,理由已经在代码记录的版本历史中写好了,不用临时回忆或反复沟通。

                                        你编写的代码不只是给数据库执行,更是给未来需要维护数据库的人看的。

                                        作者丨Rohan Dutt     编译丨dbaplus社群

                                        来源丨网址:https://medium.com/@Rohan_Dutt/how-to-write-sql-queries-that-are-self-documenting-before-your-logic-starts-getting-interrogated-6c1ba8915e0d

                                        dbaplus社群欢迎广大技术人员投稿,投稿邮箱:editor@dbaplus.cn

                                        跳转微信打开

                                        •  

                                        16岁高中生凌晨敲下admin,竟闯入微软17.3万亿行核心库!全网看傻眼……

                                        尚未抵达notyet 2026-11-03 07:15 广东

                                        以下文章来源于:尚未抵达notyet

                                        尚未抵达notyet

                                        尚未抵达notyet面向需要判断 AI 机会与风险的读者,长期关注黑箱机制、模型幻觉、平台规则与不可见的算法舞台。

                                        市值数万亿美元的科技帝国,防线怎么会脆弱得像一层窗户纸?

                                        凌晨两点,万籁俱寂。

                                        16岁的高中生 Faav 坐在卧室电脑前。父母正在隔壁房间熟睡,他刚刚写完周五的学校作业,顺手点开了一条卡了整整十天的代码线索。

                                        他在键盘上敲下了五个字母:admin。

                                        回车,屏幕瞬间弹回一个孤零零的数字:1。

                                        紧接着,一串长得让人眼晕的数字跳了出来:17333335124315。

                                        17.3万亿行记录。

                                        那一刻,这个16岁的少年死死盯着屏幕,激动得差点叫出声来。

                                        但他硬生生捂住了嘴,他怕吵醒熟睡的父母,只能一遍又一遍地核对算术。

                                        手里既无微软员工账号与内部密码,更缺少合法的加密签名,这个还没成年的高中生,仅凭一张自己手搓的“空白假证”和一个最老套的默认用户名,就以最高管理员的身份,大摇大摆地走进了微软内部分析平台 Titan 的心脏。

                                        ▲ 漏洞公开后,16岁研究者 Faav 在 X 上感叹:“依然不敢相信,凌晨两点敲下‘admin’,就让我进了微软17万亿行记录。”

                                        消息一出,整个国际安全圈彻底炸锅。

                                        所有人都在追问同一个问题:市值数万亿美元的科技帝国,防线怎么会脆弱得像一层窗户纸?

                                        顺着少年公开的调查笔记往回追查,一条环环相扣、堪比好莱坞谍战片的“数字侦察链”浮出了水面。

                                        一、第一重异常:锁死的正门,与敞开的“说明书”

                                        故事的起点,要倒回2026年8月25日。

                                        Faav 虽然只有16岁,但已经是漏洞赏金圈的“老手”。早在15岁时,他就挖出过微软访客签到系统的漏洞。

                                        为了在课余时间抓虫,他自己写了一个名叫 Antares 的个人 AI 辅助狩猎工具,专门在后台自动扫描大厂的子域名、反复试错。

                                        8月25日这天,AI 助手把微软的内部数据分析平台 Titan 标记为了一条可疑线索。

                                        从表面上看,Titan 固若金汤。任何外部访客点开它的网页前端,都会被一堵冷冰冰的提示墙挡回来:“需要 VPN(VPN Required)”。在普通人眼里,这就是一扇锁死的铁门。

                                        但 Antares 顺着网络解析往下摸,发现了一个极其反常的现象:网页正门确实锁了,但负责干活的后端 API 接口,竟然挂在另一台公开可达的 Azure 云服务主机上。

                                        荒唐的场面还在后头。

                                        在这台公网主机的根路径下,微软工程师竟然把一整套 Swagger/OpenAPI 交互式文档原封不动地忘在了公网上。

                                        什么是 Swagger 文档?

                                        打个比方,黑客平时搞渗透,就像蒙着眼睛在黑屋子里摸索开关,得花几个星期去猜接口叫什么名字、参数怎么填。

                                        而暴露在公网的 Swagger 文档,相当于银行金库的设计师直接把《金库内部结构与开锁说明书》贴在了后门玻璃上。

                                        说明书上清清楚楚地列着四条核心通道。其中第三条名叫 /v2/Query,文档里甚至贴心地注明:这个接口不仅能查数据,还直接接受原始 SQL 语句(Raw SQL)。

                                        正门挂着“闲人免进”,后窗却大敞四开,窗台上还摆着操作指南。

                                        在国际权威的 OWASP API 安全标准(API9:2023) 中,这种脱离了统一网关监管、在公网裸奔的接口,有一个专门的称呼,“影子 API(Shadow API)”。

                                        二、第二重追查:乘着“时光机”,唤醒三年前的僵尸

                                        拿到说明书后,Faav 立即对着 /v2/Query 发送了一条最基础的测试指令:SELECT 1。

                                        服务器拒绝了他,返回 401 未授权错误。同时,接口还需要一个正确的“路由键(Routing Value)”,也就是告诉系统你要查哪个具体的数据集。

                                        去哪找微软内部的路由键?暴力盲猜不仅慢,还会触发警报。

                                        这位16岁少年展现出了惊人的老辣。

                                        他没有硬撞服务器,而是打开了被称为“互联网时光机”的互联网档案馆(Wayback Machine),把时间拨回了 2023年。

                                        在三年前保存下来的 Titan 历史登录页与隐私页快照里,他翻出了一套早就撤下的旧版 Apache Superset 前端配置文件。

                                        这些沉睡在历史缓存里的 JavaScript 代码,像化石一样完整保留了平台当年的家底:里面清清楚楚写着 56个后端数据表路由定义,其中就包括一个名叫 TestData 的测试路由。

                                        Faav 把这56个三年前的“老古董”放进2026年的线上接口里挨个测试。

                                        结果令人瞠目结舌,其中整整30个路由,在三年后的今天依然完全存活(Live)!

                                        ▲ 安全博主制作的案件图解:前端挂着 VPN 门禁,背后却是暴露的 Swagger 文档、互联网档案馆里的旧配置,以及不验签的令牌。

                                        这就是大厂微服务架构里最要命的顽疾,“僵尸 API(Zombie API)”。

                                        很多人以为,只要把网页上的旧按钮删掉,旧功能就下线了。但在庞大的企业云端,工程师往往害怕“删掉旧接口会搞崩某个不知名的老业务”,于是只拆前端、不关后端。

                                        三年前的网页快照,就这样穿过时间裂缝,成了撬开今天微软大门的铁撬棍。

                                        三、致命一击:AI 卡壳十天,人类一秒破局

                                        路由打通了,只剩最后一道关卡:身份认证。

                                        Titan 系统要求访问者出示一枚 JWT(JSON 网络令牌)。

                                        为了方便理解,你可以把 JWT 想象成一张电子工作证。这张工作证由三部分组成:头部(写着防伪算法)、载荷(印着你的姓名、部门、权限),以及决定真伪的第三部分,加密签名(相当于防伪钢印)。

                                        正常情况下,保安(服务器)拿到工作证,第一步必须先拿验钞机照一下防伪钢印。钢印是真的,再去读上面印着的名字

                                        在接下来的十天里,AI 助手 Antares 对着这个接口不断变换参数试错。在成百上千次报错中,Faav 敏锐地捕捉到了一个诡异的细节:无论怎么涂改工作证上的部门和名字,哪怕不更换后面的防伪钢印,系统居然都照单全收!

                                        一个大胆的念头冒了出来:难道这个保安根本不看防伪钢印?

                                        Faav 立即动手伪造了一张假证。他在头部声明里写上 "alg":"none"(无加密算法),把第三段的签名直接留空。结果,这张连防伪章都没有的白条,一路绿灯通过了租户、受众和应用 ID 的全部检查!

                                        然而,就在距离终点只有一步之遥的地方,AI 卡住了。

                                        无论 AI 怎么尝试,系统始终冷冰冰地报错:User not found(用户未找到)。因为令牌里代表用户名的字段叫 upn(用户主体名称),在微软体系里,这通常是一串邮箱地址。AI 助手死守着这个逻辑,夜以继日地猜了无数个微软员工风格的邮箱,全都吃了闭门羹。

                                        线索僵持了整整十天,直到9月5日那个周五的凌晨一点,做完功课的 Faav 重新坐回电脑前,看着满屏的报错,人类的直觉突然跳出了 AI 的思维定式:既然这个系统底层用的是开源的 Apache Superset,万一后端程序员偷懒,根本没把 upn 当成微软邮箱,而是直接拿去查本地数据库的用户名呢?

                                        本地数据库最默认的管理员叫什么?

                                        他删掉邮箱,随手敲进了 admin。屏幕跳出数字 1,admin 被直接映射为本地1号用户,系统最高管理员。

                                        AI 用十天的枯燥穷举把人送到了门前,而人类用凌晨一点的灵光一闪,拧开了门锁。正如安全大V vx-underground 看完报告后的黑色幽默短评:“这蠢得太离谱了,但我喜欢。”

                                        四、17.3万亿行背后,与5000美元的“耳光”

                                        门推开后,里面的景象让这个16岁少年屏住了呼吸。

                                        他先用 SHOW DATABASES 看了一眼平台元数据库。光是与 Titan 相关的内部目录与配置里,就躺着约2.5万条账号记录、17,990条微软员工邮箱、1.5万条员工组织记录,以及355个数据库配置和2.1万条 SQL 定义。

                                        接着,他看到了独立的必应(Bing)搜索分析数据源。为了证明漏洞的真实性,同时严守白帽黑客的法律与道德边界,他格外谨慎地只做了“有界采样”,仅提取了两行必应样本(只包含国家或州级的粗略反向 IP 位置,不涉及具体个人身份),绝不多碰一条客户隐私。

                                        最后,他做了一次全局摸底。那30个存活的历史路由,背后连通着 17个 ClickHouse 分析数据库、9,863张独立数据表。他调取系统元数据进行汇总核对,算出了那个震惊全网的存储规模数字:17,333,335,124,315 行。

                                        这里必须严谨地划清一条界限:“能够触及”不等于“已经泄露”。17.3万亿行是包含历史、重复和派生数据在内的平台总存储规模估算,Faav 从未搬走这17万亿行数据,整起事件里也没有任何客户隐私(PII)遭到窃取。

                                        发现问题的当晚(9月5日),Faav 就把报告交给了微软安全响应中心(MSRC)。微软四天后(9月9日)锁死了该接口。

                                        然而,当9月17日微软公布赏金数额时,全网替这位少年打抱不平,仅仅 5,000 美元(约合人民币3.5万元)。

                                        不仅如此,在文章公开发表前,微软还对他的博客行使了编辑审查权,删减了部分章节与图表,并重新修饰了关于漏洞影响范围的表述。

                                        ▲ 突发新闻账号 International Cyber Digest 汇总了“未签名令牌、5000美元赏金与微软修改描述”等细节,阅读量迅速突破百万。

                                        “5000美元简直像一记耳光!”X 平台上的安全从业者们炸开了锅。有人直言,这种直接捅穿内部分析底座、连着17个核心库的漏洞,赏金至少该是五位数甚至六位数。

                                        Faav 本人倒是显得很平静。他在评论区坦言,开会时他确实礼貌地问过微软能不能提高赏金或给点额外奖金,但对方以“公司政策不允许”为由拒绝了。

                                        他之所以依然愿意给微软挖漏洞,很大程度上是因为微软允许他在修补后公开写出这些精彩的技术故事。

                                        五、最昂贵的围墙,防不住最朴素的偷懒

                                        复盘整起事件,全程既不涉及高深莫测的零日漏洞,也无需算力恐怖的超级计算机破解。

                                        一个16岁的高中生之所以能单枪匹马走入微软的数据腹地,靠的是对手接连犯下的四个低级错误:

                                        • 以偏概全的防线:以为前端网页挂个 VPN 提示,后面的 API 就安全了;

                                        • 随手乱丢的图纸:把生产环境的 Swagger 接口文档直接敞开在公网上;

                                        • 死而不僵的旧账:三年前的测试路由从未物理下线,留给互联网档案馆当了跳板;

                                        • 形同虚设的验票:校验证件上的每一行字,唯独跳过了最核心的密码学签名验证。

                                        在 AI 编程与自动化工具狂飙突进的今天,这起深夜奇袭给所有科技巨头敲响了一记警钟:当微服务膨胀到成千上万个时,冲垮安全防线的往往是内部失控的“影子资产”与某一行偷懒省掉的验签代码,而非外部最顶尖的攻击长矛。

                                        毕竟,如果你在每扇防盗门上都装了最先进的读卡器,却允许任何人拿一张手写的白纸刷开门锁,那么门后的金库修得再大,也不过是一座不设防的沙堡。

                                        作者丨林予

                                        来源丨公众号:尚未抵达notyet(ID:not-yethere)

                                        dbaplus社群欢迎广大技术人员投稿,投稿邮箱:editor@dbaplus.cn

                                        跳转微信打开

                                        •  
                                        ❌