← 返回首页

Python 文件锁:锁住了却没锁住的地方

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。全程只用标准库,没有装任何第三方包。每组输出都是原样粘贴。文中不含任何联盟推广链接,也不含佣金链接。

// FLOW_01一次「两个进程抢同一个文件」的排查顺序6 NODES01STEP_01现象:数字对不上,但没有异常02STEP_02先确认有没有跨进程互斥03STEP_03看锁的起点是不是当前文件指针04STEP_04看锁的范围有没有重叠05STEP_05看解锁范围是否与加锁一致06STEP_06再检查原子替换是否被句柄挡住END_OF_FLOW
一次「两个进程抢同一个文件」的排查顺序 · 依据本文步骤自绘示意图
64 字节文件上的两个字节区锁:进程 A 锁住 0..7,进程 B 因文件指针在末尾而锁住 64..71
64 字节文件上的两个字节区锁:进程 A 锁住 0..7,进程 B 因文件指针在末尾而锁住 64..71 · 依据本文主题生成的示意图
PythonLinux
文中涉及的技术标识 · 图标来自 Simple Icons(CC0)

先说结论:三种锁里只有一种能挡住另一个进程

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 真实评测

🔗 精选推荐工具

使用以下链接支持我们持续产出高质量内容(点击可直接前往购买):

作为亚马逊联盟会员,符合条件的购买会为我们带来佣金,不会增加你的购买成本。

☁️ DigitalOcean 云服务器 ⚡ Vultr 高性能 VPS 🤖 QoderWork 中国版(推荐有奖) ☁️ 阿里云爆款 AI 产品 📚 WordPress 实用书单 🧠 AI / 大模型书单 🏗️ 系统设计/云架构书单 🐳 Docker/K8s 书单 🐧 Linux 系统管理书单 🐍 Python 编程书单 🗄️ 数据库/PostgreSQL 书单 🚀 DevOps/SRE 书单 🤖 小米 MiMo 开放平台
← 返回首页