有个同事处理过一次机房掉电:业务代码写完日志、落完数据库、接口返回成功,用户那边显示「提交成功」。电一断,重启之后发现那条订单不见了,日志文件也只剩前面半截,后面是一堆乱码。他第一反应是数据库骗了他,第二反应是文件系统坏了。

其实这两件事都不冤。接口返回成功,只代表数据被写进了操作系统的页缓存,不代表已经落到硬盘或闪存的介质上。页缓存是内存,断电就没了。文件之所以半截,是因为写文件时先写数据再写元数据,中间断电,长度信息没更新,读出来就断在一个奇怪的位置。

这篇讲清楚写路径和 fsync:一次 write 到底写到了哪一层、fsync 承诺了什么、没承诺什么、rename 为什么能原子替换、数据库的 WAL 和 fsync 配置是怎么回事。最后给一个能跑的 Python 小实验,顺便说清它的局限——进程崩溃和整机断电不是一回事。

先说条件:本机是 Windows,Python 3.15,实验里的 fsync 走的是系统刷盘接口;关于文件系统日志模式、目录项持久化、FUA 这些行为,不同操作系统和硬件组合差别很大,文中按通用原理讲,具体组合需要自己验证。

一次 write 到底写到了哪儿

应用程序调 write,数据先进入应用的缓冲区,或者直接进入内核。进入内核后,数据落在页缓存里,也就是内存中的一份文件内容副本。这时候 write 已经返回,程序可以继续跑,但对面的硬盘可能一点动静都没有。

页缓存攒够一定量,或者过了几秒,内核的刷盘线程才把脏页交给块层,块层再发给硬盘。硬盘自己还有缓存,收到数据后可能先放在盘上的 DRAM 里,等空闲了再写进盘片或闪存。整条链上,每一层都在说「收到了」,但只有最后一层写进介质,才算真的落地。

一次写入经过的层
应用缓冲程序自己的数组或流缓冲,write 之前的数据
内核页缓存write 返回后数据在这里,断电即失
块层队列合并、排序、下发,可能还有写合并
盘缓存硬盘或固态的 DRAM,掉电即失,除非有掉电保护
介质盘片或闪存,真正持久的地方

这条链解释了为什么「写完立刻断电」会丢数据:数据大概率还停在页缓存里,连盘都没见到。也解释了为什么有些时候丢了、有些时候没丢:取决于断电那一刻,刷盘线程跑到哪一步,盘缓存里有没有积压。

内核通常每几秒会把脏页刷一次,攒得多了也会提前刷。所以「写完马上断电」丢的概率最高,「写完过了十几秒再断电」丢的概率就低很多。这不是可靠性设计,是概率;靠时间碰运气,不叫保证。

fsync 保证什么,不保证什么

fsync 的作用,是把指定文件的数据和元数据从页缓存推到存储设备,并等设备确认。fdatasync 类似,但不保证文件大小以外的元数据,比如修改时间。前者更保守,后者更快,代价是某些元数据可能没落盘。

它保证的是:调用返回之后,这份文件的内容已经交给了设备,设备也确认收到了。它不保证的是:设备收到之后一定写进了介质。很多消费级硬盘和固态收到刷盘命令后,会把数据放进自己的缓存就返回,真正的写入还在后面。要穿过这一层,需要设备支持并正确执行强制单元访问,也就是 FUA,或者设备本身有掉电保护电容。

fsync 也不保证目录项。你新建一个文件、写内容、fsync 文件本身,返回成功;但如果目录的元数据没落盘,断电后这个文件名可能根本不存在,或者 rename 的结果没生效。所以「写完文件再原子替换」这套流程,最后还要对目录做一次刷盘,在 Linux 上就是对目录文件描述符调 fsync。

网络文件系统是另一个坑。本地 fsync 走到设备就结束,NFS 或对象存储的 fsync 只能保证「服务器收到了」,服务器自己的缓存什么时候落盘是另一回事。有些实现会把刷盘转成对服务端的同步写请求,有些只做缓存确认。用共享存储时,要把这一层单独问清楚,别拿本地经验套。

文件内容和文件名是两笔账。内容靠文件的 fsync,名字和目录结构靠目录的 fsync。很多人只做了前一步,于是出现「数据还在,文件没了」或者「新文件没出现,旧文件还在」。

文件系统日志:一致性和数据是两回事

文件系统为了防止元数据被写坏,会先写日志再改结构,这叫 journaling。断电后重启,它重放日志,把没做完的操作回滚或补完。这样能保证文件系统本身是自洽的:不会出现指向不存在块的目录,也不会出现两个文件共用一个块。

但「文件系统一致」不等于「你的数据完整」。常见的几种日志模式里,ordered 模式会先落数据再提交元数据,崩溃后最多丢最后一段没写完的数据,文件不会出现「长度对但内容是旧的」;writeback 模式只保证元数据顺序,数据可能晚于元数据落盘,崩溃后可能出现文件长度正确、内容却是旧块的情况。

所以看到「文件系统检查通过」不要放心太早。它只能说明结构没坏,不能说明你刚写的那条记录还在。数据完整性要靠应用自己刷盘、自己校验,不能指望日志。

还有一种情况更容易误判:断电后文件系统自动修复,日志里显示「已回放」,用户就以为数据万无一失。实际上回放只把元数据补到一致,数据块里可能是上一次写的内容,甚至是全零。真正要确认,得靠应用层的校验和、版本号或者数据库的完整性检查。

原子替换:rename 为什么能救一命

直接覆盖一个配置文件,最危险的地方在于写到一半断电:旧内容已经没了,新内容只写了一半。稳妥的做法是写临时文件,写完刷盘,再 rename 覆盖目标。rename 在同一文件系统内是原子操作,要么指向旧文件,要么指向新文件,不会出现中间态。

但这套流程有三个容易漏的点。第一,临时文件写完要 fsync,不然 rename 之后内容还在缓存里。第二,rename 之后要刷目录,不然目录项可能没落盘。第三,临时文件和目标必须在同一个文件系统,跨文件系统的 rename 会退化成复制加删除,原子性就没了。

数据库的 WAL 思路类似:先顺序追加日志并刷盘,再改数据页。崩溃后用日志重放。区别在于数据库把「提交」定义成日志落盘,而不是数据页落盘。所以你看到的「提交成功」,实际承诺的是日志已经在介质上,数据页可以慢慢刷。

这也意味着数据库的性能调优里,同步提交级别是个关键开关。把它调低,提交变快,但断电可能丢掉最后若干条已提交事务;把它调到最高,每条提交都要等刷盘,吞吐掉一个档次。这个选择不是技术细节,是业务对丢失的容忍度。

跑一个小实验:进程崩了,数据丢不丢

下面这段 Python 做两件事。第一,子进程写 64KB 到文件,分别只 flush、flush 加 fsync,然后调用 os._exit(0) 直接退出,不跑正常的清理流程;父进程等它退出后读文件大小。第二,测量 200 次 4KB 写,带 fsync 和不带 fsync 的耗时差。

import os, subprocess, sys, time, tempfile

child_code = '''import os, sys
path, do_fsync = sys.argv[1], sys.argv[2] == "1"
f = open(path, "wb")
f.write(b"A" * 65536)
f.flush()
if do_fsync:
    os.fsync(f.fileno())
os._exit(0)          # 跳过正常退出流程
'''
with open("fs_child.py", "w", encoding="utf-8") as fh:
    fh.write(child_code)

path = os.path.join(tempfile.gettempdir(), "fsync_demo.bin")
for label, fsync in (("flush only", "0"), ("flush + fsync", "1")):
    if os.path.exists(path):
        os.remove(path)
    rc = subprocess.call([sys.executable, "fs_child.py", path, fsync])
    size = os.path.getsize(path) if os.path.exists(path) else -1
    print(f"{label:14s} child rc={rc}  size = {size} bytes")

N, payload = 200, b"B" * 4096
t0 = time.perf_counter()
f = open(path, "wb")
for i in range(N):
    f.write(payload)
f.close()
t1 = time.perf_counter()
print(f"buffered   {N} x 4KB: {(t1-t0)*1000:8.2f} ms")

t0 = time.perf_counter()
f = open(path, "wb")
for i in range(N):
    f.write(payload)
    f.flush()
    os.fsync(f.fileno())
f.close()
t1 = time.perf_counter()
print(f"fsync each {N} x 4KB: {(t1-t0)*1000:8.2f} ms")

本机实际输出(Windows 11,Python 3.15,写入系统盘,未做任何清理缓存的操作):

flush only     child rc=0  size = 65536 bytes
flush + fsync  child rc=0  size = 65536 bytes
buffered   200 x 4KB:     1.14 ms
fsync each 200 x 4KB:    56.56 ms

先看第一组:两种写法都保住了 64KB。这说明什么?说明进程崩溃不丢数据。数据一旦交给内核页缓存,进程死不死都不影响它,因为页缓存归操作系统管,不归进程管。真正会丢的是整机断电,或者操作系统崩溃,那时页缓存才一起没。

再看第二组:200 次 4KB 写,不刷盘 1.14 毫秒,每次刷盘 56.56 毫秒,差了五十倍。这个倍数不是固定值,取决于盘、文件系统、是否有写合并、系统忙不忙。但它说明一件事:fsync 的代价是实打实的,不能每条记录都刷一次。

这 56 毫秒里,大部分时间不是花在「传 4KB 数据」上,而是花在等设备确认。每次刷盘都要走一趟完整的命令往返,设备还要保证数据进了掉电安全的位置。数据量再小,这一趟的固定开销也省不掉,所以小记录频繁刷盘的效率极低。

这个实验不能证明 fsync 能让数据扛住断电。它只证明了进程退出和整机断电是两码事。真正的掉电测试需要能切断电源的夹具、能控制刷盘时机的工具,还要重复多次;本机没有这些条件,所以关于断电后数据是否还在的结论,全部按原理说明,未在本机实测。

每次都刷,还是攒一批再刷

每条都 fsync

数据最安全,掉电最多丢正在写的这一条。代价是每次写都要等设备确认,吞吐被延迟锁死,写入密集的服务会被拖垮。

批量提交

攒一批再统一刷盘,吞吐高,代价是掉电会丢一批还没提交的数据。适合能接受少量丢失、或者有重放来源的场景。

选哪种不看喜好,看业务能接受丢多少。转账、订单这类,丢一条都不行,就得每条刷,或者用数据库已经做好的 WAL;日志、监控、埋点,丢几秒可以接受,就可以批量。中间还有一层:定期刷盘加校验,崩溃后能发现丢了哪些、能补多少。

实际工程里更常见的是分组提交:把同一批请求合成一个事务,只刷一次盘,然后一起返回成功。这样吞吐接近批量,语义上又只承诺整批,比「一条条刷」和「攒着不刷」都更可控。

现象对照:先查什么

掉电类问题的排查,最怕「重启之后一切正常,就当没发生」。下面这些现象,基本都能对应到写路径上的某一层。

现象真实原因第一步查什么
接口返回成功,断电后记录没了数据只进了页缓存或盘缓存,没到介质确认写路径上是否有 fsync 或等效的刷盘动作
文件只剩半截,后面是乱码数据块写了,长度等元数据没更新,或写到一半断电查文件系统日志模式和写入方式,改用临时文件加 rename
rename 之后新文件不见了目录项没有持久化,只刷了文件本身确认 rename 后是否对父目录做了刷盘
数据库说提交了,记录却查不到WAL 刷盘配置不完整,或者同步级别被调低查数据库的同步提交配置和 WAL 刷盘策略
盘说刷盘完成,断电还是丢盘缓存没有真正落盘,设备不支持或没启用 FUA查设备是否企业级、有无掉电保护,以及是否启用写穿透
虚拟机里数据丢了,宿主机看起来正常虚拟化层有缓存,宿主机刷盘不等于客户机刷盘查虚拟磁盘的缓存模式和宿主机存储的写策略
断电后文件系统要求修复元数据写到一半,日志回放只能保证结构一致看修复日志和损坏范围,再评估数据是否需要从备份恢复

边界与代价

第一,fsync 很慢。上面测出来五十倍的差距,不是个例。每次刷盘都要等设备完成一次真正的写,机械盘还要等旋转和寻道,固态也要等闪存编程。高频写入的服务如果每条都刷,吞吐会被延迟压死。

第二,不是所有盘都诚实上报缓存。消费盘的缓存默认开着,收到刷盘命令可能只把数据挪进自己的 DRAM 就返回;企业盘通常有掉电保护电容,能在断电后把缓存里的数据写完,但价格差一截。你无法只靠软件判断一块盘是否诚实,只能查规格、看是否支持 FUA、或者用掉电测试验证。

第三,文件系统和硬件组合差异大。同样的 fsync 调用,在 ext4 的 ordered 模式、writeback 模式、不同的块设备队列、不同的虚拟化层上,行为都不一样。跨平台、跨云环境的结论不能照搬。

第四,真正的掉电测试需要夹具。要能精确控制断电时刻、要能重复、要能区分「进程崩」「系统崩」「整机断电」三种情况。本文的实验只覆盖了第一种,后两种未在本机实测。

第五,fsync 防不了介质损坏。它保证数据到了设备,不保证设备以后不出坏块。备份、校验、冗余是另一套事情,不能拿 fsync 代替。

第六,UPS 只能争取时间,不能替代刷盘。市电断了,UPS 撑住的那几分钟是让你有序关机、把该刷的刷完;如果程序本身没有刷盘,UPS 也救不回没落地的数据。把 UPS 当成数据安全方案,是把两件事混成一件。

今天就能验证的五个练习

  1. 用 Python 写一个「临时文件加 rename」的配置更新函数,写完刷盘、rename、再刷目录,然后断电模拟前先确认每一步的返回值。
  2. 查自己系统的挂载选项:Linux 用 mount 看 data=ordered 还是 writeback;Windows 没有对应选项,可查文件系统类型和写入缓存策略。
  3. 跑上面的计时实验,对比 fsync 和不 fsync 的耗时,再换成 1MB 一块试一次,看差距怎么变。
  4. 打开项目里数据库的配置文件,找到同步提交或刷盘相关的项,确认它现在是哪个级别、为什么是这个级别。
  5. 给一个真实服务写掉电测试清单:要测哪几种断电时机、怎么判断数据是否完整、恢复后怎么校验、谁来执行。

收束:承诺要写到介质为止

一次 write 只到页缓存,fsync 把它推到设备,设备缓存和介质之间还有一层。文件内容和文件名是两笔账,rename 的原子性要靠目录刷盘兜底,文件系统日志只管结构一致、不管你的数据完整。这些都是写路径上的常识,但每一条都能在事故里找到对应的现场。

到这里,存储介质本身的账已经算完了。最后一篇换个角度:同样是闪存,为什么手机上的 UFS 比老平板的 eMMC 快几倍,为什么 NVMe 固态插到 SATA 口上点不亮。接口和协议决定了上限,下一篇把它们摆开讲。