Python 文件锁:锁住了却没锁住的地方
两个定时任务写同一个状态文件,一天下来计数少了 101 次。没有异常栈,没有告警,两个进程的退出码都是 0,日志里每一行都写着「已写入」。
我第一次遇到这个问题时,以为是文件系统缓存。后来在两边都加了 threading.Lock,数字只从 299 变成 300 —— 少了 100 次,一点没改善。真正的原因很朴素:threading.Lock 是进程里的一个对象,而我要挡的是另一个进程。这跟 import 拿错文件、Decimal 舍入不一致是同一类问题:代码执行了、没有报错、结果不是你想要的。
下面五组实验都是我在本机跑的,环境是 Windows 11(10.0.26300)加 CPython 3.13.14(MSC v.1944 64 位),实测时间 2026-11-16。全程只用标准库,没有装任何第三方包。每组输出都是原样粘贴。文中不含任何联盟推广链接,也不含佣金链接。
先说结论:三种锁里只有一种能挡住另一个进程
threading.Lock 挡的是线程,fcntl.flock 在 Linux 上挡进程但只是建议性的,Windows 上能挡进程的是 msvcrt.locking 的字节区锁。三者名字都叫 lock,能挡的东西完全不是一回事。
TL;DR:两个进程各做 200 次「读-改-写」,期望 400,无锁得 299、加 threading.Lock 得 300、加 msvcrt.locking 得 400,三次退出码全是 0。另外四条容易踩的:msvcrt.locking 的锁从当前文件指针开始算(以 ab 打开就锁到了文件尾)、锁是字节区不是整个文件、别人读被锁区会直接拿到 PermissionError、目标文件被任何句柄打开时 os.replace 抛 WinError 5。
| 锁 | 作用域 | 另一个进程能不能绕过 | 本机实测结果 | |
|---|---|---|---|---|
threading.Lock | 当前进程 | 能,完全不生效 | 400 次里丢掉 100 次 | |
msvcrt.locking | 字节区,跨进程 | 不能,读写都被挡 | 400 次一次不丢 | |
open(..., 'w') 独占打开 | 无,Windows 上不独占 | 能 | 两个句柄同时写,后者覆盖 | |
| `O_CREAT \ | O_EXCL` 锁文件 | 路径,跨进程 | 不能,但崩溃后残留 | 崩溃后下一进程永久被挡 |
os.replace 原子替换 | 无锁语义 | 不适用 | 目标被打开时直接失败 |
实验一:丢掉的 101 次写
计数器就是一个 8 字节的定长数字。每个进程重复 200 次:读出来、sleep 0.5 ms、写回去。两个进程并行跑。
mode=nolock workers=2 iterations_each=200 expected=400 actual=299 lost=101 exit_codes=[0, 0] wall=1.70s
mode=tlock workers=2 iterations_each=200 expected=400 actual=300 lost=100 exit_codes=[0, 0] wall=1.71s
mode=flock workers=2 iterations_each=200 expected=400 actual=400 lost=0 exit_codes=[0, 0] wall=2.35s
tlock 那一行值得盯着看:我实际测试时在 with guard: 里包了整个读-改-写,这个 guard 只在本进程内排队。两个进程各有一把自己的锁,谁也不看谁的,所以丢的量和完全不加锁几乎一样(100 对 101,差的那 1 次是时序抖动,不是锁的功劳)。
换成字节区锁之后,400 次一次不丢,代价是墙钟从 1.70 秒涨到 2.35 秒 —— 多出来的 0.65 秒就是真实的跨进程排队。
这里有一条容易忽略的判据:三种模式的退出码都是 0。丢更新不会让任何一层变红,它只会让一个数字慢慢偏掉。
实验二:锁的起点是当前文件指针,不是文件开头
官方文档的原话是「The locked region of the file extends from the current file position for nbytes bytes, and may continue beyond the end of the file」。前半句是「从当前文件位置开始」,不是从第 0 字节开始。
我把文件写到 64 字节,让另一个进程先锁住 0 到 7。然后本进程用 ab 模式打开同一个文件再调 msvcrt.locking:
另一进程占着 0..7 · 本进程以 'ab' 打开后加锁 nbytes=8
结果: 成功。锁落在 64..71,与冲突区完全无关
ab 打开之后指针在文件末尾,所以 locking 锁的是 64 到 71 这一段。两个进程都以为自己拿到了锁,谁都没报错。这就是「锁住了却没锁住」最典型的形态,而且它连一行日志都不会留。
正确的写法是加锁前先 f.seek(offset),并且加锁和解锁都要 seek 到同一个位置,因为解锁同样以当前指针为基准。
实验三:范围是字节级,不是文件级
锁住 0 到 7 之后,其他进程读 8 到 15 是正常的:
0..7 被锁时读 8..15: b'xxxxxxxx'
同一段区间被部分重叠地再锁一次,直接失败:
holder 占 0..7 · 本进程 seek(4) 后锁 8 字节 → 覆盖 4..11
PermissionError: [Errno 13] Permission denied
文档对这两点写得很明确:「Multiple regions in a file may be locked at the same time, but may not overlap. Adjacent regions are not merged; they must be unlocked individually.」相邻区间不会被合并,必须逐段解锁 —— 这意味着「加锁时锁 8 字节、解锁时解 10 字节」不会解锁 8 字节,而是直接报错。
我自己第一版实验脚本就栽在这里:
锁 8 字节,然后 seek(0) 解锁 16 字节
PermissionError: [Errno 13] Permission denied
失败的那一次,8 字节的锁仍然被持有,因为语句抛异常后 f.close() 被跳过。接下来同一个进程里的四个用例全部连锁失败,我一度以为是「锁超过文件长度会报错」。实际原因是上一把锁没放:「锁范围超过文件长度」单独跑的时候,16 字节的文件加锁 4096 字节是成功的 —— 文档也写了可以锁到文件末尾之外。
实验四:Windows 的字节锁是强制的,别人连读都读不到
这一点和 Linux 差别最大。另一个进程持有 0 到 7 的锁时,我用最普通的读法去读:
open(path, 'rb').read(8)
PermissionError: [Errno 13] Permission denied
不是「读到旧值」,是直接读不到。对照 flock(2) 的手册页,原文是「flock() places advisory locks only; given suitable permissions on a file, a process is free to ignore the use of flock() and perform I/O on the file」—— Linux 上是建议锁,你只要不去查,读写照常。Windows 的 LockFile 是另一套语义,微软文档的说法是「Locking a region of a file gives the threads of the locking process exclusive access to the specified region using this file handle」。
有意思的是,SMB 上两种情况会合流。同一份手册页在 CIFS 一节写着「the locks are not advisory anymore: any IO on a locked file will always fail with EACCES when done from a separate file descriptor」。也就是说,一段在本地磁盘上靠建议锁跑通的代码,挂到网络盘上会突然变成强制锁,报的还是同一种错。
同一进程开第二个句柄也不行,这一点文档和实测一致:
同进程 f1 锁住 0..7,f2 = open(path, 'r+b') 读 8 字节
PermissionError: [Errno 13] Permission denied
微软文档原话:「If the locking process opens the file a second time, it cannot access the specified region through this second handle until it unlocks the region.」所以别指望「反正锁是我自己加的,我自己读肯定没问题」。
实验五:崩溃之后,字节锁自动放开,锁文件不会
两种方案在同一台机器上的差别极大。
字节锁:持锁进程直接 os._exit(9) 跳过所有清理,另一个进程立刻能拿到锁,实测耗时 0.000 秒。
持锁进程 os._exit(9) 后另一进程加锁成功,用时 0.000s
微软文档解释了原因:「If a process terminates with a portion of a file locked or closes a file that has outstanding locks, the locks are unlocked by the operating system.」同时它还有一句提醒:解锁的时间取决于系统资源,所以进程退出时仍然应该显式解锁。
锁文件方案没这个兜底。O_CREAT | O_EXCL 建锁文件,第二个进程会被挡住,这是期望行为:
第二个进程 os.open(lock, O_CREAT|O_EXCL|O_RDWR)
FileExistsError: [Errno 17] File exists
问题是崩溃之后:
持锁进程 os._exit(9) 之后,锁文件是否还在: True
下一个进程仍被挡住: FileExistsError [Errno 17] File exists
文件不会因为创建它的进程死了就消失,于是这个任务从此再也起不来,直到有人手工删掉那个文件。这也是为什么锁文件方案一定要在文件里写 PID 和启动时间,并在启动阶段处理残留 —— 但别只凭 PID 判断进程是否存活,PID 会被复用。
实验六:原子替换和锁在 Windows 上互相打架
临时文件 + os.replace 是写配置的标准手法,它在 Windows 上有一个前置条件:目标文件不能被任何句柄打开。
目标被一个普通 'rb' 句柄打开着,另起临时文件后 os.replace
PermissionError: [WinError 5] 拒绝访问。: 'lab3.tmp' -> 'lab3.dat'
原因在共享模式。微软 CreateFile 文档写的是「FILE_SHARE_DELETE: Enables subsequent open operations on a file or device to request delete access ... Note: Delete access allows both delete and rename operations.」句柄打开时没带这个标志,后续任何需要删除或改名的操作都会被挡住;而替换的目标是「删掉旧文件再把新文件改名过去」。
更麻烦的是另一种组合:另一个进程持有目标文件的字节锁时,替换同样失败,报的还是 WinError 5。我实测了两种情形,只有「无锁且无句柄」那一次成功:
字节锁持有中: os.replace 失败 -> PermissionError [WinError 5]
无锁无句柄: os.replace 成功
顺带一个纯语法层的差异:os.rename 在目标已存在时根本不走到加锁这一步,直接 FileExistsError: [WinError 183] 当文件已存在时,无法创建该文件。要覆盖就用 os.replace,要保留旧文件就先自己判断。
由此得到一条顺序上的结论:在 Windows 上,先锁文件再原子替换是矛盾的。锁本身就会让替换失败。可行的做法是「锁一个独立的小锁文件 + 替换数据文件」,或者干脆放弃替换、改成在锁内原地写。
实验七:追加写是原子的,前提是写得够小
两进程各用 buffering=0 的 ab 写 500 行,每行 5 字节:
两进程各写 500 行 · 实际 1000 行 · 撕裂行 0
这一条有边界,别推广:我测的是每次 write 一个 5 字节的完整记录,中间没有拆包。行变长、或者一次写几兆,行为和内存缓冲、CRT 缓冲都可能变。要写大块数据,还是走临时文件加替换。
六个真实报错与处理
下面六条都是本机原样抓下来的,按出现频率排。
报错一:PermissionError: [Errno 13] Permission denied(来自 msvcrt.locking)
三种成因:没 seek 导致锁到了别的区间、与已有锁部分重叠、解锁范围与加锁不一致。处理方式是加锁前 f.seek(offset)、解锁前再 seek 一次,并把区间长度写成常量,加锁解锁共用同一个变量。
报错二:OSError: [Errno 36] Resource deadlock avoided(来自 LK_LOCK)
这是阻塞式的 LK_LOCK,文档说「If the bytes cannot be locked, the program immediately tries again after 1 second. If, after 10 attempts, the bytes cannot be locked, OSError is raised」。实测等了 9.07 秒之后抛出。注意它的措辞不是「超时」而是「避免死锁」,所以别在日志里写「等待超时」,否则排障的人会往超时配置上找。
报错三:PermissionError: [WinError 5] 拒绝访问。(来自 os.replace)
目标是文件被打开或字节区被锁。处理方式是:替换前确保没人持有目标句柄,或者改用「锁独立锁文件、替换数据文件」。我实际测试时把读句柄放在 with 里忘了关,报错信息只给了两个路径,不告诉你谁挡着 —— 排查要靠进程级别的句柄枚举。
报错四:FileExistsError: [WinError 183] 当文件已存在时,无法创建该文件。(来自 os.rename)
Windows 上 os.rename 不覆盖目标。要覆盖改 os.replace。这个错和上一条常一起出现,因为改完 rename 又忘了目标可能被打开。
报错五:FileExistsError: [Errno 17] File exists(来自 O_CREAT | O_EXCL)
要么真的有另一个实例在跑,要么上一个实例崩溃留下了锁文件。判据是看锁文件里的 PID 和启动时间,而不是直接删。
报错六:ModuleNotFoundError: No module named 'fcntl'
fcntl 是 Unix 模块,Windows 上不存在。所有把 import fcntl 写在文件顶层的跨平台脚本,在 Windows 上会连启动都启动不了。要按平台分支导入,别在顶层裸 import。
一份最小可用的写法
下面这段把三条结论都写死了:先 seek 再锁、区间长度用同一个变量、解锁前再 seek 一次。
import contextlib, msvcrt, os, time
class ByteLock:
def __init__(self, path, offset=0, length=1, timeout=5.0):
self.path = path
self.offset = offset
self.length = length
self.timeout = timeout
@contextlib.contextmanager
def hold(self):
f = open(self.path, 'r+b')
try:
for _ in range(max(1, int(self.timeout / 0.05))):
f.seek(self.offset)
try:
msvcrt.locking(f.fileno(), msvcrt.LK_NBLCK, self.length)
break
except PermissionError:
time.sleep(0.05)
else:
raise TimeoutError(
'lock busy: %s [%d:%d]' % (self.path, self.offset, self.length))
try:
yield f
finally:
f.seek(self.offset)
msvcrt.locking(f.fileno(), msvcrt.LK_UNLCK, self.length)
finally:
f.close()
用法就是 with ByteLock('state.dat', 0, 8).hold() as f:。三点说明:用 LK_NBLCK 自己轮询,而不是 LK_LOCK 让它内部重试 10 次 —— 这样超时时间由你控制,报错也是你能读懂的 TimeoutError;PermissionError 要单独接,它是 OSError 的子类,顺序反了会被上层那个 except 吃掉;f.close() 放在最外层 finally,即使解锁失败也能释放句柄,否则锁会一直挂到你进程退出。
同一份代码在 Linux 上是另一回事
三处差异,全部会改变行为而不改变代码。
第一,fcntl 在 Windows 上不存在,msvcrt 在 Linux 上不存在,顶层裸导入必然一边起不来。
第二,Linux 的 flock 是建议锁,别人不查就照写;Windows 的字节锁是强制的,别人读都会失败。所以「加锁之后不会有别人写」在 Linux 上不成立,只在这台 Windows 上成立。
第三,释放时机不同。flock(2) 手册写的是锁与 open file description 绑定,「the lock is released either by an explicit LOCK_UN operation on any of these duplicate file descriptors, or when all such file descriptors have been closed」;而 Windows 上锁跟句柄走,同一进程开第二个句柄反而读不到自己的锁区。这两个模型都能用,但不能假设它们等价。
如果代码要同时跑两端,要么在锁这一层做平台分支(Windows 走 msvcrt,其余走 fcntl),要么直接用一个成熟的跨平台锁库。自己写的抽象层最容易漏掉的就是「解锁范围」和「第二句柄」这两个坑。
本文的边界
本机没有 Linux 环境,POSIX 部分只引官方文档,没有实测数字。网络文件系统(实际挂载的 SMB 与 NFS)没有测,只引了手册页里关于 CIFS 的那一段。多线程加多进程混合的场景、超过缓冲区的大块追加写、以及 os.replace 在跨卷时的行为都没有覆盖。
结论可以这么用:在 Windows 本地磁盘上,字节区锁是目前唯一实测能挡住另一个进程的方案,但它只锁字节区、只认当前指针、只对打开着的那个文件对象有效。要覆盖整个文件,加锁的区间必须显式覆盖整段长度,并且在文件被替换时重新加锁。
顺带说一句,这套「锁的是字节区不是文件」的理解,和 Windows 路径语义那篇 是同一个母题:你写下的字符串、你打开的句柄、你以为的那个对象,三者经常不是同一个东西。想继续往下钻,可以接 Python import 取错文件 与 SQLite 热备为什么少了 14500 行 两篇 —— 前者讲「模块对象指向哪个文件」,后者讲「备份文件为什么打开也能少数据」,都属同一类静默分歧。
常见问题
Q:两个进程都用 threading.Lock 为什么还是会丢数据?
因为 threading.Lock 是当前进程里的一个对象,两个进程各有一把,互相看不见。要跨进程必须用操作系统级别的锁(msvcrt.locking、fcntl.flock 或锁文件)。实测 400 次里丢 100 次,与完全不加锁几乎没有差别。
Q:LK_LOCK 报 Resource deadlock avoided 是不是超时?
不是。它是 10 次、每次间隔 1 秒的重试都失败后放弃,实测 9.07 秒。错误号是 36,文案是「避免死锁」。要自定义超时就改用 LK_NBLCK 自己轮询。
Q:能不能直接锁整个文件?
字节锁本身不支持「整个文件」这个单位,只能给一个区间。要覆盖全文就锁一个足够大的长度 —— 实测锁到文件末尾之外是允许的,16 字节的文件加锁 4096 字节成功。但要注意,文件被 os.replace 换掉之后,锁还在旧对象上,新文件是完全没锁的。
Q:锁文件方案是不是更简单?
更简单,但崩溃后会永久残留,而且和 PID 复用混在一起很难判断。字节锁在进程退出时由系统自动释放,实测 0.000 秒就能被下一个进程接手。两者各有代价,选哪个取决于你更怕「锁不住」还是更怕「起不来」。
三条可以直接贴进代码审查的检查
一,凡是跨进程互斥,搜一遍 threading.Lock 和 multiprocessing.Lock 用错地方的地方 —— 前者只挡线程。
二,凡是出现 msvcrt.locking,检查加锁与解锁之前是否都 seek 到同一位置、长度是否同一个变量。
三,凡是「临时文件 + os.replace」,检查替换时是否还有人持有目标句柄。Windows 上这条不是建议,是硬条件。
👉 立即参与小米 MiMo 开放平台:国内领先的 AI 大模型开放平台,高性价比推理服务
👉 立即参与阿里云 AI:汇集爆款 AI 产品,热门模型专属权益优惠券助力企业创新加速
📌 本文由 AI 辅助生成并经人工审核发布 | TechPassive — AI 驱动的内容测试站点,专注于效率工具与 SaaS 真实评测
🔗 精选推荐工具
使用以下链接支持我们持续产出高质量内容(点击可直接前往购买):
作为亚马逊联盟会员,符合条件的购买会为我们带来佣金,不会增加你的购买成本。