订单系统里有个躲不开的需求:下单后 30 分钟没付款,自动关单,库存回滚,优惠券退回。项目刚上线那会儿,我们用 crontab 每分钟跑一次 php think order:close,扫一遍 create_time < now-30min and pay_status = 0 的记录。几百条订单的时候屁事没有,等订单表过了两百万行,这个扫描就成了 CPU 曲线上的固定尖刺,加索引也只是让尖刺矮一点,并不能让它消失。
中间也试过 think-queue 自带的延迟消息,能跑通,但项目里同时还想要几个能力:任务能主动取消、失败按次数退避重试、同一个订单重复投递不能执行两次。为了这几个点在上面再包一层,还不如自己写一版来得清楚。最后落地的方案很简单——Redis 有序集合 + 一个自定义常驻命令,两百行出头。
下面的代码基于 PHP 8.1、ThinkPHP 8.0、phpredis 5.3、Redis 7.0,所有片段都是从项目里抠出来的,改改就能用。
先把数据结构定下来
这套东西一共用到四个键,命名都带统一前缀,方便运维按前缀做监控和清理:
delay:job:zset:ZSet,score 是任务的执行时间戳,member 是任务 ID。取“已经到期”的任务只需要一句ZRANGEBYSCORE -inf now,Redis 内部按跳表查,几万条任务也就微秒级。delay:job:data:Hash,任务 ID 映射到任务内容(处理类名 + 参数)。任务体放这里而不是塞进 ZSet 的 member,原因是 member 会被反复写、还要参与字符串比较,放 Hash 里更干净,以后加字段也不用动 ZSet。delay:job:retry:Hash,记录每个任务已经重试了几次。delay:job:dead:Hash,超过最大重试次数的任务进这里,等人工处理,别让它无限循环。
防止重复执行的抓手是 ZREM 的返回值。ZREM 本身是原子的,返回 1 的那个进程才算拿到了任务的所有权,返回 0 说明已经被别人抢走了。所以消费者开多少个进程都不会出现同一单被关两次。当然业务层的幂等判断该做还得做,后面会讲。
投递端:一个只有三个方法的类
ThinkPHP 8 里操作 Redis 的方式不止一种,我这里用的是缓存驱动的原生句柄:Cache::store('redis')->handler() 会返回 phpredis 实例,可以直接调 zAdd、hSet 这些方法,比在缓存门面上面绕一圈方便得多。前提是 config/cache.php 里存在名为 redis 的通道,默认配置里就有。
<?php
declare(strict_types=1);
namespace appcommonservice;
use thinkfacadeCache;
class DelayQueue
{
public const ZSET = 'delay:job:zset';
public const HASH = 'delay:job:data';
public const RETRY = 'delay:job:retry';
public const DEAD = 'delay:job:dead';
public static function redis(): Redis
{
return Cache::store('redis')->handler();
}
/**
* 投递一个延时任务
*
* @param string $handler 处理类,需实现 handle(array $payload)
* @param array $payload 任务参数
* @param int $delay 延迟秒数
* @param string $bizId 业务唯一键,同键重复投递只保留最后一次
*/
public static function push(string $handler, array $payload, int $delay = 0, string $bizId = ''): string
{
$jobId = $bizId !== '' ? $bizId : uniqid($handler . ':', true);
$redis = self::redis();
$redis->hSet(self::HASH, $jobId, json_encode([
'handler' => $handler,
'payload' => $payload,
'created' => time(),
], JSON_UNESCAPED_UNICODE));
$redis->zAdd(self::ZSET, time() + $delay, $jobId);
return $jobId;
}
/**
* 取消任务(订单提前支付时调用)
*/
public static function cancel(string $jobId): bool
{
$redis = self::redis();
$redis->hDel(self::HASH, $jobId);
$redis->hDel(self::RETRY, $jobId);
return $redis->zRem(self::ZSET, $jobId) > 0;
}
}
如果你的项目用的是 predis 驱动,handler() 返回的是 PredisClient,方法名是小驼峰(zadd、hset),参数结构一致,照着改一下大小写就行。
投递的时机放在订单落库之后,用订单号当 jobId:
// app/api/logic/OrderLogic.php
public function create(array $data, int $userId): array
{
Db::startTrans();
try {
$order = Order::create([
'order_sn' => $this->buildSn(),
'user_id' => $userId,
'amount' => $data['amount'],
'status' => Order::STATUS_UNPAID,
'create_time'=> date('Y-m-d H:i:s'),
]);
DelayQueue::push(
appjobCloseOrder::class,
['order_sn' => $order->order_sn],
1800,
'close_order:' . $order->order_sn
);
Db::commit();
} catch (Throwable $e) {
Db::rollback();
throw $e;
}
return ['order_sn' => $order->order_sn];
}
用业务键当 jobId 的好处是天然去重:接口重试、消息重发导致同一个订单被投递两次,Hash 和 ZSet 里都是同一个 key,第二次写入只是覆盖了 score,队列里不会多出一个任务。支付成功后的取消更简单,DelayQueue::cancel('close_order:' . $orderSn) 一行搞定,不用等它到期再在业务里判断状态。
任务类:只关心一件事
任务类刻意写得很薄,只做状态变更,库存回滚、优惠券退回这些全部扔给事件去处理。任务里堆业务是维护噩梦的开始,尤其是这种半夜才会跑、出问题还不容易复现的逻辑。
<?php
declare(strict_types=1);
namespace appjob;
use appmodelOrder;
use thinkfacadeDb;
use thinkfacadeEvent;
use thinkfacadeLog;
class CloseOrder
{
public function handle(array $payload): void
{
$orderSn = $payload['order_sn'] ?? '';
if ($orderSn === '') {
return;
}
$order = Order::where('order_sn', $orderSn)->find();
if (!$order) {
return;
}
// 已经支付、已经关闭、已经发货,都不该再走关闭流程
if ((int) $order->status !== Order::STATUS_UNPAID) {
return;
}
// 条件更新:把状态判断写进 where,影响行数为 0 说明被别的流程改过
$affected = Db::name('order')
->where('order_sn', $orderSn)
->where('status', Order::STATUS_UNPAID)
->where('pay_status', 0)
->update([
'status' => Order::STATUS_CLOSED,
'close_time' => date('Y-m-d H:i:s'),
'update_time' => date('Y-m-d H:i:s'),
]);
if ($affected === 0) {
return;
}
Log::info('[order] closed by delay job: ' . $orderSn);
Event::trigger('OrderClosed', $order);
}
}
这段里最关键的是 $affected === 0 这个判断。关单和支付是两条独立链路,用户完全可能在关单语句执行的前一秒完成支付,用 where status = 未支付 做条件更新,数据库会帮我们把并发卡死,不需要额外加锁。
消费端:自定义命令
命令的逻辑就是一个循环:取到期任务,抢一个,执行一个。没抢到的直接跳过,接着处理下一个。
<?php
declare(strict_types=1);
namespace appcommand;
use appcommonserviceDelayQueue;
use thinkconsoleCommand;
use thinkconsoleInput;
use thinkconsoleOutput;
use thinkfacadeLog;
class DelayWorker extends Command
{
private const BATCH = 200; // 单轮取多少个
private const MAX_RETRY = 5; // 最大重试次数
private const TICK_US = 200000; // 空闲时 200ms 扫一次
private const IDLE_SLEEP = 3; // 长时间空闲后降频到 3s
protected function configure()
{
$this->setName('delay:work')
->setDescription('消费 Redis 延时任务');
}
protected function execute(Input $input, Output $output)
{
$redis = DelayQueue::redis();
$output->writeln('delay worker started, pid=' . getmypid());
$empty = 0;
while (true) {
try {
$now = time();
$jobs = $redis->zRangeByScore(
DelayQueue::ZSET,
'-inf',
(string) $now,
['limit' => [0, self::BATCH]]
);
if (!$jobs) {
$empty++;
// 连续空转就降频,别白白消耗 Redis 的往返
usleep($empty > 10 ? self::IDLE_SLEEP * 1000000 : self::TICK_US);
continue;
}
$empty = 0;
foreach ($jobs as $jobId) {
// 原子抢占:返回 1 才有执行权
if ((int) $redis->zRem(DelayQueue::ZSET, $jobId) !== 1) {
continue;
}
$this->consume($redis, $jobId);
}
} catch (Throwable $e) {
Log::error('[delay] worker error: ' . $e->getMessage()
. PHP_EOL . $e->getTraceAsString());
sleep(1);
}
}
}
private function consume(Redis $redis, string $jobId): void
{
$raw = $redis->hGet(DelayQueue::HASH, $jobId);
if ($raw === false || $raw === null) {
return; // 任务体没了,直接丢弃
}
$job = json_decode($raw, true);
$handler = $job['handler'] ?? '';
$payload = $job['payload'] ?? [];
try {
if (!class_exists($handler)) {
throw new RuntimeException('handler not found: ' . $handler);
}
(new $handler())->handle($payload);
$redis->hDel(DelayQueue::HASH, $jobId);
$redis->hDel(DelayQueue::RETRY, $jobId);
} catch (Throwable $e) {
$retry = (int) $redis->hIncrBy(DelayQueue::RETRY, $jobId, 1);
if ($retry > self::MAX_RETRY) {
$redis->hSet(DelayQueue::DEAD, $jobId, $raw);
$redis->hDel(DelayQueue::HASH, $jobId);
$redis->hDel(DelayQueue::RETRY, $jobId);
Log::error("[delay] dead: {$jobId} " . $e->getMessage());
return;
}
// 退避:1、2、4、8、16 分钟
$delay = 60 * (2 ** ($retry - 1));
$redis->zAdd(DelayQueue::ZSET, time() + $delay, $jobId);
Log::warning("[delay] retry#{$retry} {$jobId} " . $e->getMessage());
}
}
}
命令注册到 config/console.php:
<?php
return [
'commands' => [
'delay:work' => appcommandDelayWorker::class,
],
];
然后 php think delay:work 就能跑了。
一个必须说清楚的边界
这套逻辑在进程被 kill -9 或者机器断电时会丢任务——因为 ZREM 之后、hDel 之前有个时间窗,任务既不在 ZSet 里,Hash 里还留着,看起来像执行中,实际上已经没人管了。常规做法是加一个 processing 集合(抢占时 LPUSH,成功后 LREM),再起一个补偿命令定期扫 processing 里超过 5 分钟没动的任务,把它们重新写回 ZSet。
我们的订单场景没做这一步,原因是关单本身幂等,而且每天还有一次全量对账兜底。如果你的任务是“发短信”“扣积分”这类丢了就麻烦的事,补偿机制别省。
部署:交给 supervisor
常驻进程不要用 nohup 挂着跑,机器重启就没了。supervisor 的配置大概长这样:
[program:delay-worker]
command=php /www/wwwroot/shop/think delay:work
process_name=%(program_name)s_%(process_num)02d
numprocs=4
directory=/www/wwwroot/shop
autostart=true
autorestart=true
user=www
redirect_stderr=true
stdout_logfile=/www/wwwroot/shop/runtime/delay.log
stdout_logfile_maxbytes=50MB
stdout_logfile_backups=5
stopwaitsecs=15
numprocs=4 是安全的,靠的就是前面 ZREM 的原子抢占。stopwaitsecs=15 给正在执行的任务留了收尾时间,别设成 1 秒,不然重启就是批量丢任务。队列短、任务少的项目 numprocs=1 完全够用,别一上来就开 8 个,白白多占内存。
监控:两个数字就够了
运维看板上放两个指标,出问题先看它们:
$redis = DelayQueue::redis();
// 待执行任务数,持续上涨说明消费能力跟不上
$pending = $redis->zCard(DelayQueue::ZSET);
// 死信数,大于 0 就该有人去看了
$dead = $redis->hLen(DelayQueue::DEAD);
if ($dead > 0) {
// 这里接你们的钉钉/飞书告警
}
再补一个:定期 ZRANGEBYSCORE 查一下 -inf 到 now - 600 之间有没有残留——正常情况下这里应该是空的,有残留说明某个消费者的时间窗口出了问题。
踩过的坑,按踩的时间排序
- 常驻进程里的 MySQL 连接会断。 命令挂一整天,凌晨开始报
General error: 2006 MySQL server has gone away。MySQL 的wait_timeout默认 8 小时,连接空闲超时后被服务端单方面断掉。解决办法是在数据库配置里打开break_reconnect => true,或者捕获异常后重建连接。Redis 连接也有类似问题,长时间空闲一样会被踢。 - 改了代码必须重启。 常驻命令在启动那一刻就把代码加载进内存了,改完
CloseOrder不重启,跑的还是旧逻辑。本地调试时最容易在这上面浪费十分钟。 - Hash 忘了删。 早期版本的
hDel只写在重试分支里,成功分支漏了,三个月后delay:job:data涨到四千多万条,Redis 内存多了三个 G。ZSet 和 Hash 是两份数据,删除的时候必须成对删,这个没什么捷径。 - 多台机器时钟不同步。 score 是应用服务器的
time()算出来的,A 机器比 B 机器慢两分钟,任务就会提前或延后执行,严重时还会出现“未来任务永远取不到”的错觉。NTP 该开就开。 - 别在循环里
new模型。 每轮批量处理时尽量用Db::name()或者把结果缓存一下,模型实例化的开销在一秒几百次的循环里是会累积的。 - 批量大小别贪心。
BATCH一次取 200 条比较合适,取到几千条时单轮处理时间会超过扫描间隔,反而让队列延迟变大。
这套方案适合什么场景
单实例 Redis 配两三台应用机,任务量在每秒几千以内,这个方案足够稳,代码量和可维护性都优于引入一套 MQ。我们线上日均处理七八万条关单任务,CPU 占用基本可以忽略。
但它不是万金油。需要毫秒级精度、需要多语言消费、任务量到了每分钟几十万条,还是老老实实上 RocketMQ 的延迟消息或者 RabbitMQ 的延迟插件,那类产品在消息堆积、顺序性、可观测性上做的功课,不是两百行代码能补上的。
技术选型这事没什么银弹,能把手头的问题解决干净,出故障的时候排查得动,就已经合格了。

