去年 11 月,我们一个商城项目在大促当天出了个不大不小的事故:同一个用户连续下单 3 次,库存扣了 3 次,钱只付了 1 次。客诉进来的时候已经是下午,运维在群里甩了一张订单表截图,三条记录除了订单号以外其他字段一模一样,创建时间相差 200 毫秒。
这才是真正让人头皮发麻的地方——200 毫秒,说明不是用户手滑点了三次,而是前端重试逻辑加上后端没有做任何并发拦截,三个请求几乎同时进来了。
这篇文章把我们后来做的改造完整写一遍。用 ThinkPHP 8,代码都是在生产上跑过的,不是示例。中间踩的几个坑也一并记下来,尤其是最后那个「锁加了但幂等还是没做到」的问题,我排查了整整两天。
一、先搞清楚:加锁 != 幂等
事故刚出来的时候,团队里的第一反应是「加个 Redis 锁」。这个方向不算错,但只做一半。
锁解决的是并发问题:同一时刻只让一个请求进到业务逻辑里。而幂等解决的是重复问题:同一个请求执行一次和执行多次,对系统状态的影响必须一致。
差在哪?举个例子。用户第一次下单成功,订单号 A001,返回给前端。前端因为网络抖动没收到响应,1 秒后又发了一次。这时候锁已经释放了,第二个请求顺利进到业务逻辑,又创建了一条订单 A002。锁一点问题没有,但幂等没做到。
所以完整的方案至少有三层:
- 并发层:Redis 分布式锁,挡住同一瞬间的重复请求
- 结果层:缓存首次执行的结果,让重复请求拿到同样的响应
- 数据层:数据库唯一索引,兜住任何漏网的重复写入
下面一层层来。
二、为什么单机文件锁、进程锁都不行
我们线上是 4 台 8 核机器,前面挂 Nginx 做负载均衡。ThinkPHP 8 默认的多应用模式下,每个请求都是独立的 PHP-FPM 进程,进程之间内存不共享。
有人说用 flock() 加文件锁不就行了?单机确实管用,但请求经过负载均衡以后根本落不到同一台机器上。三个请求分别打到 A、B、C 三台机,三把文件锁互不相干,等于没加。
还有个同学提过 Db::name('order')->where(...)->lock(true) 做悲观锁。这在单库单表下是能用的,问题是我们的订单表已经分库了,而且行锁在事务没提交的时候会一直持有,高并发下 MySQL 连接池会被拖垮。压测的时候 200 并发跑了两分钟,数据库连接直接打满,整个服务跟着雪崩。
最后落在 Redis 上。原因是它快、原子、跨机器共享。
三、Redis 加锁:SET NX EX 才是对的写法
先说一个很多人写错的地方。下面这段代码在网上的教程里出现频率极高:
$redis = Cache::store('redis')->handler();
if (!$redis->exists($key)) {
$redis->set($key, 1);
// 业务逻辑
$redis->del($key);
}
这段代码有两个致命问题。第一,exists 和 set 是两次往返,中间有窗口期,两个请求可以同时通过 exists 判断。第二,如果业务逻辑抛异常,del 根本不会执行,锁就永远留在那里了。
正确的做法是用 Redis 的 SET key value NX EX seconds,一条命令同时完成「不存在才设置」和「设置过期时间」,Redis 保证这个操作是原子的。
在 ThinkPHP 8 里通过 Cache::store('redis')->handler() 拿到原生 phpredis 实例之后,可以这样写:
<?php
declare(strict_types=1);
namespace appcommon;
use thinkfacadeCache;
class Lock
{
protected static function redis()
{
return Cache::store('redis')->handler();
}
/**
* 获取锁
* @param string $key 锁的键
* @param string $token 持有者标识,释放时校验
* @param int $ttl 过期秒数
*/
public static function acquire(string $key, string $token, int $ttl = 10): bool
{
$result = self::redis()->set($key, $token, ['nx', 'ex' => $ttl]);
return $result === true || $result === 'OK';
}
/**
* 释放锁
*/
public static function release(string $key, string $token): bool
{
$script = <<<'LUA'
if redis.call('get', KEYS[1]) == ARGV[1] then
return redis.call('del', KEYS[1])
end
return 0
LUA;
return (bool) self::redis()->eval($script, [$key, $token], 1);
}
}
注意 $token 这个参数,它不是多余的。假如 A 请求拿到锁,但因为某种原因执行超过了 10 秒,锁自动过期了,B 请求进来拿到了新锁。这时候 A 执行完去调 release,如果直接 del,删掉的是 B 的锁。
用 token 做校验就没这个问题:删之前先比对值是不是自己写进去的那个。而「比对 + 删除」必须原子,所以要用 Lua 脚本。eval($script, [$key, $token], 1) 里的 1 表示第一个参数是 key(KEYS[1]),后面的是参数(ARGV[1])。
四、封装成 ThinkPHP 8 中间件
锁的逻辑写好了,接下来把它做成中间件,这样在路由上挂一下就能复用,不用每个控制器里都写一遍。
<?php
declare(strict_types=1);
namespace appmiddleware;
use appcommonLock;
use Closure;
use thinkfacadeCache;
use thinkRequest;
use thinkResponse;
class Idempotent
{
/**
* 需要做幂等控制的请求方法
* GET / HEAD 天然幂等,不用处理
*/
protected array $methods = ['POST', 'PUT', 'PATCH', 'DELETE'];
/**
* 请求中不参与 Key 计算的字段
*/
protected array $ignore = ['timestamp', 'ts', 'sign', '_t', 'nonce'];
public function handle(Request $request, Closure $next, int $ttl = 10): Response
{
if (!in_array($request->method(), $this->methods, true)) {
return $next($request);
}
$key = $this->buildKey($request);
$cache = Cache::store('redis');
// 第一层:结果缓存。命中说明这个请求已经成功执行过
$cached = $cache->get($key . ':result');
if ($cached !== null) {
return json($cached);
}
$token = bin2hex(random_bytes(8));
// 第二层:并发锁
if (!Lock::acquire($key, $token, $ttl)) {
return json([
'code' => 42901,
'msg' => '请求正在处理中,请稍后重试',
'data' => null,
], 429);
}
try {
$response = $next($request);
// 只缓存成功结果,失败允许重试
if ($response instanceof Response && $response->getCode() === 200) {
$cache->set($key . ':result', $response->getData(), 60);
}
return $response;
} finally {
Lock::release($key, $token);
}
}
protected function buildKey(Request $request): string
{
$uid = $request->uid ?? 'guest';
$params = $request->param();
foreach ($this->ignore as $field) {
unset($params[$field]);
}
ksort($params);
$raw = implode('|', [
$uid,
$request->method(),
$request->pathinfo(),
json_encode($params, JSON_UNESCAPED_UNICODE),
]);
return 'idem:' . md5($raw);
}
}
路由上挂载的时候可以带参数,控制锁的 TTL:
Route::group('api/order', function () {
Route::post('create', 'Order/create');
Route::post('cancel', 'Order/cancel');
})->middleware(appmiddlewareIdempotent::class, 15);
这个 15 会作为 handle() 的第三个参数传进去。ThinkPHP 8 的中间件参数就是这么传的,写在路由后面从 handle 的可变参数里接。
五、踩坑记录:这三个地方最容易出问题
坑一:Key 里混进了每次都会变的字段
刚上线第一版的时候,幂等完全没生效,日志里锁的命中率是 0。翻了半天才发现请求体里带着 timestamp 和 sign,前端每次重试都会重新生成,于是每次算出来的 md5 都不一样,看起来全是「新请求」。
这也是我在中间件里加 $ignore 数组的原因。任何随时间变化、或者跟前一次请求不同的字段,都必须排除掉,否则幂等 Key 就失效了。常见的还有 _t、nonce、验签用的 sign。
坑二:上传接口的 Key 全部撞车
这个坑比较隐蔽。ThinkPHP 的 $request->param() 不包含文件上传的内容,所以同一个用户往同一个上传接口发两个不同的文件,算出来的 Key 是一模一样的。第二个文件直接被当成重复请求拒掉了。
解决办法是在 buildKey 里把文件信息也拼进去:
foreach ($request->file() as $field => $file) {
$raw .= '|' . $field . ':' . $file->getOriginalName() . ':' . $file->getSize();
}
当然更稳妥的做法是让上传接口先拿 token 再传文件,但那是另一个话题了。
坑三:锁的 TTL 小于业务执行时间
这个问题最要命,也是最难查的。我们有个「批量导出订单」的接口,一个请求要跑 8 到 15 秒。锁的 TTL 设了 10 秒,结果就是:
- 请求 A 拿到锁,开始导出
- 第 10 秒锁自动过期
- 请求 B(用户的第二次点击)拿到新锁,也导出一遍
- 请求 A 执行完,Lua 脚本比对 token 失败,没有误删 B 的锁
- 两个请求都成功了,导出任务跑了两遍
注意第 4 步——Lua 脚本帮我们避免了误删,但它不能阻止重复执行。这就是为什么我在中间件里加了结果缓存那一层:只要 A 成功了并把结果写进 Redis,B 就会直接返回缓存,压根不会进业务逻辑。
对于特别长耗时的任务,TTL 要按「最长执行时间 + 缓冲」来设。我们那个导出接口最后设了 60 秒,或者在业务里做锁续期(watch dog),不过续期的实现复杂,一般接口用不着。
六、兜底:数据库唯一索引
Redis 万一挂了、或者被清空了怎么办?所有并发都会直接打到数据库上。所以数据库层面必须有一道硬约束。
我们的订单表加了这样一条唯一索引:
ALTER TABLE `order`
ADD UNIQUE KEY `uk_user_goods_batch` (`user_id`, `goods_id`, `batch_no`);
这里的 batch_no 是大促活动的批次号,保证同一用户在同一批次里对同一商品只能下一单。索引字段怎么选要看业务,没有通用答案。比如充值场景可以用 (user_id, out_trade_no),签到场景用 (user_id, sign_date)。
插入的时候一定要捕获重复键异常,不能让它冒泡成 500:
use thinkfacadeDb;
use thinkdbexceptionPDOException;
try {
$id = Db::name('order')->insertGetId($data);
} catch (PDOException $e) {
if ($e->getCode() === '23000' || str_contains($e->getMessage(), 'Duplicate entry')) {
$exist = Db::name('order')
->where('user_id', $data['user_id'])
->where('goods_id', $data['goods_id'])
->where('batch_no', $data['batch_no'])
->find();
return json(['code' => 0, 'msg' => 'ok', 'data' => $exist]);
}
throw $e;
}
这里返回的是已存在的那条订单,而不是报错。因为从调用方的角度看,他的请求确实「成功」了,只是被合并了而已。这就是幂等的语义。
七、状态机:更新也要走幂等
下单防住了,支付回调又出问题。第三方支付平台的回调本来就允许重复推送,我们在测试环境模拟推送了 5 次,账户余额被加了 5 次。
订单状态流转的写法一定要带前置状态条件,用影响行数判断是否真的更新成功:
$affected = Db::name('order')
->where('id', $orderId)
->where('status', 0) // 只能是待支付状态才能改
->update([
'status' => 1,
'pay_time' => time(),
]);
if ($affected === 0) {
// 说明已经被处理过了,直接返回成功,不要重复加余额
return json(['code' => 0, 'msg' => 'already processed']);
}
// 走到这里才说明是本进程完成了状态流转
Db::name('user')->where('id', $userId)->inc('balance', $amount)->update();
where('status', 0) 这个条件配合 update 的原子性,天然形成了一道 CAS(Compare And Swap)。只有第一个把状态从 0 改成 1 的请求能拿到 $affected = 1,后面的全是 0。这比先用 find 查状态再判断要可靠得多——查和改是两步,中间有窗口。
八、压测数据与遗留问题
改造完成后用 JMeter 做了一轮压测:200 并发线程,循环 25 次,总共 5000 个请求,全部指向创建订单接口。
- 改造前:成功 5000 次,实际生成订单 5000 条,重复订单 137 条
- 改造后:成功 5000 次,实际生成订单 4863 条,重复订单 0 条
- 接口平均响应时间:改造前 86ms,改造后 94ms
- P99 响应时间:改造前 210ms,改造后 248ms
性能损耗大概在 8% 到 15% 之间,主要是多了一次 Redis 往返和一次结果缓存读写。这个代价换 137 条重复订单,怎么算都划算。
还有几个没彻底解决的问题,一并写出来:
结果缓存的 TTL 怎么定。我们设了 60 秒,意味着用户 61 秒后再发同样的请求,会重新走一遍业务逻辑。虽然数据库唯一索引能兜住,但会走到异常分支,日志里会出现 Duplicate entry 记录。这个时间窗口没有标准答案,得看业务对「重复」的容忍度。
Redis 集群下 Lua 脚本的 key slot。如果 Redis 是 Cluster 模式,Lua 脚本里操作的 key 必须落在同一个 slot,否则会报 CROSSSLOT。我们现在只操作一个 key,暂时没问题,但如果后面要同时对多个 key 加锁,得用 hash tag,比如 {order:123}:lock 这种写法。
中间件的执行顺序。幂等中间件必须放在鉴权中间件之后,因为 buildKey 里要用到 $request->uid。如果顺序反了,所有用户的 key 都会变成 guest 开头,等于做了个全局锁,那场面会很壮观。
九、小结
回过头看,这次事故的本质不是「没加锁」,而是对幂等的理解有偏差。锁只能让请求排队,不能让重复请求消失。真正管用的方案是三层叠加:Redis 锁控制并发入口,结果缓存保证相同请求返回相同响应,数据库唯一索引在最后兜底。
另外还有一点体会:任何跟钱、库存、账户余额相关的写操作,都要先想清楚「这个接口被调用两次会怎样」。这个问题的答案如果不能在 10 秒内给出,就说明设计上还有漏洞。宁可多加一个唯一索引,也别指望前端不重复点。

