多台设备共享一个 NFS,怎么保证压力测试不同时跑?一把互斥锁的设计与最简验证
场景:多台整机挂在同一个 NFS(我们的生产环境是 Lustre,原理一样)共享存储上,做验收要跑压力测试。但机柜的供电容量只够一台满载,两台同时压就有跳闸风险。所以必须保证:同一时刻只有一台在跑压测。
这篇从"为什么需要锁"讲起,用一个 20 行的 demo 把机制跑通,最后给出生产环境的几个坑。全文的命令都能直接复制运行。
一、先说清楚:这个锁到底在解决什么问题
很多讲互斥锁的文章一上来就是 flock、semaphore,容易让人只记住 API 不理解动机。先看我们的真实处境:
- 两台整机,各自几十个计算刀片,满载压测时功耗加起来接近整机柜的供电上限
- 两台同时跑 → 超过 PDU 的额定输出 → 空开跳闸,严重时整柜断电,连带别的机器一起完蛋
- 所以"跑压力测试"这个动作,在物理上就是排他的
注意这里的关键:这是物理约束,不是软件约束。 软件层面这两台机器互相不知道对方在干嘛,各自都觉得自己跑得好好的。
于是问题变成:怎么让两台机器对"现在有没有人在跑压测"这件事达成共识?
顺着这个问题往下推,答案几乎是唯一的:
| 状态存在哪 | 另一台机器能不能看到 | 能不能用 |
|---|---|---|
| 进程内存里的变量 | 看不到 | ✗ |
本机的某个文件 /tmp/running |
看不到 | ✗ |
| 一个只有本机能连的 Redis / 数据库 | 看不到(而且要额外部署) | ✗ |
| 共享存储上的一个文件 | 看得到 | ✓ |
这就是为什么锁必须放在共享盘上。 不是因为"文件锁"这个技术名词高级,而是因为:只有共享存储是这两台机器都能看到、都能改的同一块地方。
理解了这一层,后面所有细节都是围绕"怎么把这块共享的地方用对"展开的。
二、用一个类比把机制说透
想象工厂里只有一台电钻,放在公共工具房,墙上钉个钩子挂钥匙:
- 电钻 = 压力测试(物理资源,同时只能一个人用)
- 钥匙 = 锁文件(放在公共工具房 = 共享盘)
- 拿钥匙 = 抢锁
- 还钥匙 = 释放锁
这个类比能推出三个必须解决的问题,正好对应后面要讲的三个技术点:
- 两个人同时伸手拿钥匙,会不会都拿到?→ 需要"拿钥匙"这个动作是原子的:要么拿到,要么没拿到,不能"都拿到了"。
- 拿钥匙的人晕倒了没还,钥匙就一直挂着?→ 需要异常时自动释放。
- 有人把钩子拆了换一个,钥匙看着还在其实是另一把?→ 锁的载体本身必须稳定,不能被人删了重建。
flock 用内核机制帮你解决了第 1 点(原子性)和第 2 点(异常自动释放)。第 3 点------锁的载体必须稳定 ------纯靠写代码的纪律,而这恰恰是最容易翻车的地方:它会静默失效,两边日志都显示"抢锁成功",但互斥从来没发生过(第五节问题 2 详述)。
三、最简 demo:核心只有 4 行
先看不加锁的反例,20 秒就能理解问题:
bash
#!/bin/bash
# stress_nolock.sh ------ 反例
DEVICE=${1:?用法: ./stress_nolock.sh <设备名> <秒数>}
DURATION=${2:-5}
SHARE=${SHARE:-./share} # 换成你的共享盘挂载点
LOG="$SHARE/stress.log"
echo "[$(date +%T)] $DEVICE 开始压测(${DURATION}s)" >> "$LOG"
for i in $(seq 1 "$DURATION"); do
echo "[$(date +%T)] $DEVICE 压测中 $i/$DURATION" >> "$LOG"
sleep 1
done
echo "[$(date +%T)] $DEVICE 压测结束" >> "$LOG"
两台机器各自调用它,stress.log 上就会同时出现两台的记录------两份压测真的在同时跑。
现在加上锁,改动就是开头加 4 行:
bash
#!/bin/bash
# stress_lock.sh ------ 正解
set -u
DEVICE=${1:?用法: ./stress_lock.sh <设备名> <秒数>}
DURATION=${2:-5}
SHARE=${SHARE:-./share}
LOCK="$SHARE/.stress.lock"
LOG="$SHARE/stress.log"
# ---------- 核心就这 4 行 ----------
exec 9>>"$LOCK" # ① 用 >> 打开锁文件,绝不能是 >
if ! flock -n 9; then # ② -n = 拿不到立刻返回,不排队
echo "[$(date +%T)] $DEVICE 跳过:压测锁被占用" | tee -a "$LOG"
exit 77 # ③ 77 = 跳过,不产生"通过/失败"结论
fi
# ④ fd 9 一直持有到进程退出
echo "hold device=$DEVICE host=$(hostname) pid=$$ start=$(date +%T)" >> "$LOCK"
echo "[$(date +%T)] $DEVICE 开始压测(${DURATION}s)" >> "$LOG"
for i in $(seq 1 "$DURATION"); do
echo "[$(date +%T)] $DEVICE 压测中 $i/$DURATION" >> "$LOG"
sleep 1
done
echo "[$(date +%T)] $DEVICE 压测结束" >> "$LOG"
逐行解释这 4 行:
exec 9>>"$LOCK":把文件描述符 9 指向锁文件,并且在整个脚本生命周期内保持打开 。这是关键------flock锁的是这个 fd,fd 不关,锁就不放。flock -n 9:尝试对 fd 9 加排他锁。-n是 non-blocking,拿不到立刻返回非零,不等待。exit 77:拿不到就退出,退出码用 77 而不是 1(原因在第七节讲,这是个很实用的约定)。- 不手动释放 :进程结束时 fd 9 自动关闭,内核自动释放锁。所以你在脚本末尾不需要写任何
unlock。
四、跑起来看:三个实验
光讲不够,我写了个 verify.sh,一条命令跑三个实验。
说明:以下是我在本地实际运行的真实输出。本机是 Windows(没有
flock),所以验证用的是等价的mkdir原子操作版本,机制完全一样(都是"共享文件系统上的原子操作"),只是释放方式不同,第五节会讲两种写法的区别。
实验一:不加锁,两台同时开跑
css
────────────────────────────────────────────────
实验一:不加锁,两台设备同时开跑
────────────────────────────────────────────────
--- 日志(两台交错,说明真的同时在跑)---
[11:19:40] 整机A 开始压测(4s)
[11:19:40] 整机A 压测中 1/4
[11:19:41] 整机B 开始压测(4s)
[11:19:41] 整机B 压测中 1/4
[11:19:42] 整机A 压测中 2/4
[11:19:43] 整机B 压测中 2/4
[11:19:43] 整机A 压测中 3/4
[11:19:44] 整机B 压测中 3/4
[11:19:44] 整机A 压测中 4/4
[11:19:45] 整机B 压测中 4/4
[11:19:46] 整机A 压测结束
[11:19:47] 整机B 压测结束
--- 「开始压测」出现了 2 次 → 两台都在跑 ❌ ---
日志是交错的:40 秒 A 开始,41 秒 B 也开始,之后每隔一秒两边各写一行。这就是真实世界里的灾难------如果这是压测,整柜的供电此刻已经超了。
实验二:加锁,两台同时开跑
css
────────────────────────────────────────────────
实验二:加锁,两台设备同时开跑
────────────────────────────────────────────────
[11:19:53] 整机B 跳过:压测锁被占用
--- 日志 ---
[11:19:52] 整机A 开始压测(5s)
[11:19:53] 整机A 压测中 1/5
[11:19:53] 整机B 跳过:压测锁被占用
[11:19:54] 整机A 压测中 2/5
[11:19:55] 整机A 压测中 3/5
[11:19:57] 整机A 压测中 4/5
[11:19:58] 整机A 压测中 5/5
[11:19:59] 整机A 压测结束
--- 「开始压测」出现了 1 次,整机B 退出码 = 77(77=跳过)✅ ---
只有一台在跑。 B 拿不到锁,打了一行"跳过",退出码 77。注意 B 不是"失败",是"没轮到"------这个区别很重要。
实验三:等前一台跑完,第二台再跑
这个实验验证的是"锁到底会不会被释放"------很多实现看起来能互斥,但实际上会死锁。
css
────────────────────────────────────────────────
实验三:先跑一台,跑完再跑第二台
────────────────────────────────────────────────
整机A 结束,锁应已释放,现在起整机B:
整机B 退出码 = 0(0=跑完)
--- 日志 ---
[11:20:08] 整机A 开始压测(3s)
[11:20:08] 整机A 压测中 1/3
[11:20:10] 整机A 压测中 2/3
[11:20:11] 整机A 压测中 3/3
[11:20:12] 整机A 压测结束
[11:20:18] 整机B 开始压测(3s)
[11:20:18] 整机B 压测中 1/3
[11:20:19] 整机B 压测中 2/3
[11:20:20] 整机B 压测中 3/3
[11:20:22] 整机B 压测结束
--- 「开始压测」出现了 2 次 → 两台先后都跑到了 ✅ ---
两台先后都跑到,B 退出码 0,说明锁确实被干净地释放了。
这个实验我一开始是失败的,而且失败得很有教育意义,第五节讲。
五、四个必须搞懂的问题
问题 1:为什么是 >> 而不是 >
> 是带 O_TRUNC 的打开,会先把文件内容清空 。>> 是追加,不清空。
差别在哪?看这个场景:
bash
exec 9>"$LOCK"
if ! flock -n 9; then
cat "$LOCK" # 想看是谁占着锁
exit 77
fi
你抢锁失败,想去看看"现在是谁在跑",结果 cat 出来是空的 ------因为你的 > 在抢锁之前就把对方写的 hold device=整机A pid=1234 start=10:23 全清掉了。
注意:> 不会导致互斥失效。 它只是 O_TRUNC,inode 不变,锁还是同一把锁。它毁掉的是可观测性------出问题时你查不到是谁占着。
所以规则是:锁文件只用 >> 打开。省一个字符的代价是排障时完全抓瞎。
问题 2:为什么锁文件永远不能删
这个是真会导致互斥失效的,而且是静默失效。
关键在于:flock 锁的是"inode",不是"文件名"。 文件名和 inode 是两回事,rm 删掉的只是目录里的那个名字,已经打开的那个 inode 还在(直到最后一个 fd 关闭才真正回收)。
于是就有了这个经典的 inode 竞态:
csharp
时刻 T1 整机A 打开 .lock → inode 1001,加锁成功,开始跑压测
时刻 T2 某人执行了 rm .lock(比如"清理残留锁"的定时任务)
时刻 T3 整机B 执行 exec 9>>.lock → 文件不存在,新建 → inode 1002,加锁成功
↑ 也成功!
结果:A 锁着 inode 1001,B 锁着 inode 1002,
内核认为这是两把完全不相干的锁 ------ 互斥从来没生效过,
而且两边的日志都显示"抢锁成功"。
所以铁律是:锁文件永不删除。 需要"释放"就关 fd,不要 rm。
这也是 flock 相比 mkdir 方案的最大优势------进程怎么死,锁都会自动释放:
| 死法 | flock(fd 锁) | mkdir(目录锁) |
|---|---|---|
| 正常退出 | 自动释放 | trap 触发,释放 |
exit 1 |
自动释放 | trap 触发,释放 |
| Ctrl-C | 自动释放 | trap 触发,释放 |
kill -9 |
自动释放(内核关闭所有 fd) | 锁残留,必须人工删 |
| 机器掉电/宕机 | 自动释放 | 锁残留,必须人工删 |
kill -9 和掉电这两行是决定性的。无人值守的夜间测试最怕的就是"锁卡住了没人管" ,一卡就是一整晚。所以生产环境我只用 flock。
问题 3:mkdir 方案为什么会踩坑(我真踩了)
第一节验证里用的 stress_lock_mkdir.sh,原理是利用 mkdir 的原子性:同名目录只能创建一次,两个进程同时 mkdir 只有一个成功。
第一版我这么写释放逻辑:
bash
if ! mkdir "$LOCKDIR" 2>/dev/null; then
exit 77
fi
trap 'rmdir "$LOCKDIR" 2>/dev/null' EXIT # ← 这里错了
echo "hold device=$DEVICE ..." >> "$LOCKDIR/owner"
跑实验三,结果:
css
整机A 结束,锁应已释放,现在起整机B:
[11:17:20] 整机B 跳过:压测锁被占用 ← A 都结束了,B 还是拿不到
死锁了。 原因很简单:rmdir 只能删空目录 ,而我为了记录持有者信息,往锁目录里写了个 owner 文件。目录非空 → rmdir 静默失败(我加了 2>/dev/null 连报错都看不到)→ 锁目录永远留着 → 之后所有设备都拿不到锁。
修正成 rm -rf 才通过:
bash
release () { [ -n "${LOCKDIR:-}" ] && [ -d "$LOCKDIR" ] && rm -rf "$LOCKDIR"; }
trap release EXIT
这个 bug 极有代表性 :它不是我"想错了",而是"没想到目录里会有文件"。真实环境里更常见的是 kill -9 ------ trap 压根不执行,rm -rf 也没机会跑,锁一样残留。
结论:mkdir 方案只适合"跑一次就结束、有人看着"的场景。要无人值守,就用 flock。
问题 4:后台持锁时,sleep 会偷偷抱着 fd 不放
写自测用例时还有个坑:想验证"锁释放后能被抢到",常见的写法是后台起个进程持锁一段时间:
perl
( exec 9>>"$LOCK"; flock 9; sleep 30 ) & # ← 有问题
这样写,sleep 是子 shell 的子进程,它继承了 fd 9 。你 kill 掉子 shell 之后,sleep 还活着、还抱着 fd 9,锁不会释放------于是"释放后应该能抢到"这个断言会假失败。
正确写法是让 sleep 替换掉子 shell:
perl
( exec 9>>"$LOCK"; flock 9; exec sleep 30 ) &
exec sleep 用 sleep 的进程镜像替换了当前 shell 进程,不再有额外的父进程持有 fd。
六、NFS / Lustre 上,flock 真的跨机生效吗
这是最容易出事的一节。flock 返回 0 只代表"本机这个 fd 加锁成功",不代表"另一台机器也认这把锁"。
跨机能不能生效,取决于两件事:
1. 文件系统是否支持服务端锁
- NFSv4 :协议内建文件锁,
flock直接映射过去,正常可用 - NFSv3 :靠 NLM 协议,需要
rpc.statd、rpc.lockd在两端都跑起来。少一个,flock就退化成只在本机有效,而且不报错 - Lustre :支持,但挂载选项必须是
flock
检查 NFSv3 的锁服务:
perl
systemctl status rpc-statd # 应该 active
rpcinfo -p | grep -E 'nlockmgr|status' # 应有 nlockmgr 和 status
2. 挂载参数是否悄悄关掉了跨机锁
这是最阴的一种,我踩过:
bash
$ mount | grep /mnt/share
172.16.0.1-8@tcp:/sharefs/datapool/share on /mnt/share type lustre (rw,localflock,...)
^^^^^^^^^^
localflock。这四个字的意思是:flock 只在本节点生效。两台机器各自锁住自己命名空间里的同一个文件名,互相看不见。
可怕的地方在于:抢锁代码没错、退出码没错、日志也显示"抢锁成功",但互斥这件事从来没发生过。 两台机器同时在跑同一项压测,谁都不知道。
所以每次动过存储或挂载参数,第一件事就是:
perl
mount | grep /mnt/share
必须看到 flock,出现 localflock 或者压根没有 flock,就当互斥已经失效。
更稳妥的做法是在抢锁成功后自动校验,把这件事变成代码而不是人的记忆:
bash
# 抢到锁之后,顺手校验挂载参数(Lustre 环境)
if mount | grep -q 'localflock'; then
echo "[WARN] 锁已退化为单机锁,跨机互斥不再生效!" >&2
fi
这个告警的尴尬之处:它在成功路径上,不在失败路径上。所以特别容易被当成噪音忽略------但它恰恰是唯一能发现"锁静默失效"的信号。
3. 最硬的验证:两台真跑一次
所有静态检查都不如真跑一遍。在两台机器上同时执行:
css
# 机器 A
ssh node-a 'SHARE=/mnt/share ./stress_lock.sh 整机A 30'
# 机器 B(同时在另一个终端敲,或者 &
ssh node-b 'SHARE=/mnt/share ./stress_lock.sh 整机B 30'
期望结果:一台打"开始压测",另一台打"跳过"、退出码 77。
如果两台都打"开始压测",就是跨机锁没生效 ------这时候别怀疑代码,先去看 mount 和 rpc-statd。
七、锁该管多大范围:一把还是三把
我们的环境里刻意用了三把独立的锁,没有合并成一把:
| 锁 | 文件 | 保护什么 |
|---|---|---|
| 压力锁 | .stress.lock |
压力测试 / 整机混合压力(耗电的) |
| 加速卡网锁 | .accel_net.lock |
加速卡千兆网打流 |
| 刀片网锁 | .blade_net.lock |
刀片万兆 bond 打流 |
为什么不合并成一把? 因为干扰源不同:
- 两台同时跑压测 → 供电超限 → 必须互斥
- 一台跑压测、一台打网络流 → 供电没问题、网络也不冲突 → 应该允许并行
- 两台同时打同一张网的流 → 带宽互相抢 → 必须互斥,但不影响压测
一把大锁虽然最简单,但会把"本该并行"的排期全都串行化,测试周期直接翻倍。
判断锁粒度的原则:一把锁对应一个真实的物理稀缺资源。 供电是一个资源、万兆网带宽是另一个资源,就该有两把锁。
反过来,同一份资源绝对不能有两把锁------那就等于没锁。
顺便说清"什么该加锁":只有真正持续拉高功耗/带宽的才加。像 dm、filter、pcie、emmc、oam、上下电这些不产生持续满载的,一律不加压力锁。我们吃过亏:曾经 dm0_mreg 和压力测试同时压了十几分钟,因为压力锁只管"压测 vs 压测",压根拦不住。
八、抢不到锁之后怎么办:为什么用 exit 77
拿不到锁时,退出码用 77 而不是 1,这个约定很实用。
原因是 exit 77 在 automake 体系里是 SKIP 的约定,语义是:"这一项根本没开始跑,别去查是不是硬件坏了。"
区别在哪:
bash
# 不好:失败和跳过混在一起
if ! flock -n 9; then exit 1; fi
# 后果:夜间编排把 77 记成 Fail → 运维半夜被叫起来查"坏刀片"
# 结果查了半天发现是另一台机器在跑压测,纯属浪费时间
# 好:分开
if ! flock -n 9; then exit 77; fi
# 后果:编排看到 77,记"跳过",汇总表显示"跳过 1 项",不触发告警
状态机要分三种,不能分两种 :通过 / 失败 / 跳过(没跑)。少第三种,就会出现"因为资源冲突所以报硬件故障"的荒唐工单。
排队该放哪:不要放进锁库
有人会想,那让锁自己等不就行了?
perl
flock -w 3600 9 # 等最多一小时
不建议。原因:锁库不知道上层要等多久、等几次、超时了要不要换一项继续。它一阻塞,编排层的超时控制、失败即停、跳过统计全部失效。
正确的分层是:
- 锁只回答"能不能跑" ------ 一个原子判决,不需要上下文
- 编排查决定"要不要等" ------ 遇 77 等 300 秒重试、最多重试 N 轮、超限就报 timeout
我们编排层的写法:
bash
while (( _r < WAIT_MAX_ROUNDS )); do
timeout -k 60 "$ITEM_LIMIT" ./"$item"; rc=$?
if (( rc == 77 )); then
echo "[wait] 被占用,300s 后重试 ($_r/$WAIT_MAX_ROUNDS)"
sleep 300
(( _r++ ))
continue
fi
break
done
排队是调度问题,不是锁的问题。 把它放对地方,两边都简单。
九、完整清单:要在你自己环境落地,按这个顺序
bash
# ---------- 1. 先确认共享盘支持跨机锁 ----------
mount | grep /mnt/share
# 必须含 flock;出现 localflock 就停下,先解决挂载
# NFSv3 还要确认锁服务
systemctl status rpc-statd
rpcinfo -p | grep -E 'nlockmgr|status'
# ---------- 2. 写锁(复制第三节的 stress_lock.sh)----------
# 检查三个要点:exec 9>>、flock -n、exit 77
# ---------- 3. 单机验证(同一台开两个终端)----------
SHARE=/mnt/share ./stress_lock.sh 整机A 30 &
sleep 2
SHARE=/mnt/share ./stress_lock.sh 整机B 30
echo "B 退出码=$?" # 期望 77
# ---------- 4. 跨机验证(两台同时)----------
# 机器A: SHARE=/mnt/share ./stress_lock.sh 整机A 30
# 机器B: SHARE=/mnt/share ./stress_lock.sh 整机B 30
# 期望:一台跑、一台跳过
# ---------- 5. 异常释放验证(最关键的一步)----------
SHARE=/mnt/share ./stress_lock.sh 整机A 60 &
PID=$!
kill -9 $PID # 模拟崩死
sleep 1
SHARE=/mnt/share ./stress_lock.sh 整机B 5
echo "B 退出码=$?" # 期望 0 ------ 证明 kill -9 之后锁自动释放
# ---------- 6. 出问题时查这里 ----------
cat /mnt/share/.stress.lock # 谁占着(靠 >> 才留得住)
bash lib/stress_lock.sh status # 封装版:内容 + fuser + 实时再抢一次
mount | grep /mnt/share # 挂载参数还是不是 flock
第 5 步千万别跳过。"能互斥"很容易做到,"崩了之后不卡死"才是真正难的那一半。
十、一句话总结
互斥锁的本质不是"加了个锁",而是让多台机器对同一份共享状态达成共识。所以锁必须放在共享存储上;而共享存储的锁语义有前提(挂载参数、锁服务),这个前提不会自己告诉你失效了------你得自己去查。
剩下的都是纪律:开锁用
>>、锁文件永不删、抢锁在第一个动作之前、崩了要能自动释放。
附:demo 文件清单
| 文件 | 作用 |
|---|---|
stress_nolock.sh |
反例:不加锁,两台会同时跑 |
stress_lock.sh |
正解 :flock 版,生产用这个 |
stress_lock_mkdir.sh |
降级版:没有 flock 时用 mkdir 原子性抢锁 |
verify.sh |
一键跑三个实验(互斥生效 / 释放后可再抢 / 不互斥对比) |
本地试跑:
bash
cd demo
chmod +x *.sh
./verify.sh # 用当前目录下的 share/ 模拟共享盘
SHARE=/mnt/share ./verify.sh # 在真实共享盘上验证
注意:
verify.sh默认用mkdir版做演示,因为要兼容没有flock的环境(比如 Windows 的 Git Bash)。真实环境请用stress_lock.sh。