多台设备共享一个 NFS,怎么保证压力测试不同时跑?一把互斥锁的设计与最简验证

多台设备共享一个 NFS,怎么保证压力测试不同时跑?一把互斥锁的设计与最简验证

场景:多台整机挂在同一个 NFS(我们的生产环境是 Lustre,原理一样)共享存储上,做验收要跑压力测试。但机柜的供电容量只够一台满载,两台同时压就有跳闸风险。所以必须保证:同一时刻只有一台在跑压测。

这篇从"为什么需要锁"讲起,用一个 20 行的 demo 把机制跑通,最后给出生产环境的几个坑。全文的命令都能直接复制运行。

一、先说清楚:这个锁到底在解决什么问题

很多讲互斥锁的文章一上来就是 flock、semaphore,容易让人只记住 API 不理解动机。先看我们的真实处境:

  • 两台整机,各自几十个计算刀片,满载压测时功耗加起来接近整机柜的供电上限
  • 两台同时跑 → 超过 PDU 的额定输出 → 空开跳闸,严重时整柜断电,连带别的机器一起完蛋
  • 所以"跑压力测试"这个动作,在物理上就是排他的

注意这里的关键:这是物理约束,不是软件约束。 软件层面这两台机器互相不知道对方在干嘛,各自都觉得自己跑得好好的。

于是问题变成:怎么让两台机器对"现在有没有人在跑压测"这件事达成共识?

顺着这个问题往下推,答案几乎是唯一的:

状态存在哪 另一台机器能不能看到 能不能用
进程内存里的变量 看不到 ✗
本机的某个文件 /tmp/running 看不到 ✗
一个只有本机能连的 Redis / 数据库 看不到(而且要额外部署) ✗
共享存储上的一个文件 看得到 ✓

这就是为什么锁必须放在共享盘上。 不是因为"文件锁"这个技术名词高级,而是因为:只有共享存储是这两台机器都能看到、都能改的同一块地方。

理解了这一层,后面所有细节都是围绕"怎么把这块共享的地方用对"展开的。

二、用一个类比把机制说透

想象工厂里只有一台电钻,放在公共工具房,墙上钉个钩子挂钥匙:

  • 电钻 = 压力测试(物理资源,同时只能一个人用)
  • 钥匙 = 锁文件(放在公共工具房 = 共享盘)
  • 拿钥匙 = 抢锁
  • 还钥匙 = 释放锁

这个类比能推出三个必须解决的问题,正好对应后面要讲的三个技术点:

  1. 两个人同时伸手拿钥匙,会不会都拿到?→ 需要"拿钥匙"这个动作是原子的:要么拿到,要么没拿到,不能"都拿到了"。
  2. 拿钥匙的人晕倒了没还,钥匙就一直挂着?→ 需要异常时自动释放。
  3. 有人把钩子拆了换一个,钥匙看着还在其实是另一把?→ 锁的载体本身必须稳定,不能被人删了重建。

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。

相关推荐
心之语歌18 分钟前
uni-app uts原生插件开发:uts 与 Kotlin 交互踩坑实录(附解决方案)
前端·后端
AndreaYYmm1 小时前
手动敲能跑,cron 一跑就 command not found?聊聊 PATH 到底从哪来
后端
bcbnb1 小时前
Windows 上 iOS 开发接 CI,KXBuild 自托管 runner 出签名 ipa
后端·ios
十有八七2 小时前
手搓 Agent(一):先有大脑——大模型只会做一件事
前端·人工智能·后端
锋行天下2 小时前
「踩坑实录」给 LangGraph Agent 接两个 FastMCP,我被 langchain 偷偷改了工具名
前端·人工智能·后端
Resean02232 小时前
Spring 源码分析(一)IOC 容器总览与 refresh() 全景
java·后端·spring
苍何2 小时前
一句话出成片,我搭了个AI视频工厂
后端
bysking3 小时前
GitHub Actions 快速入门+场景实践案例
前端·后端·github