ThinkPHP 8 延时任务实战:Redis 有序集合实现订单超时关闭(秒级精度 + 防重复执行)

2026-11-18 0 718

订单系统里有个躲不开的需求:下单后 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 的延迟插件,那类产品在消息堆积、顺序性、可观测性上做的功课,不是两百行代码能补上的。

技术选型这事没什么银弹,能把手头的问题解决干净,出故障的时候排查得动,就已经合格了。

ThinkPHP 8 延时任务实战:Redis 有序集合实现订单超时关闭(秒级精度 + 防重复执行)
收藏 (0) 打赏

感谢您的支持,我会继续努力的!

打开微信/支付宝扫一扫,即可进行扫码打赏哦,分享从这里开始,精彩与您同在
点赞 (0)

版权声明:
本站资源有的来自互联网收集整理,本站纯免费分享提供学习使用,如果侵犯了您的合法权益,请发送邮件1506151422@qq.com联系,将会及时下架删除。
本站资源仅供研究、学习交流之用,免费开源项目不代表完全可商用,若商业用途请先咨询开发企业能否商用,否则产生的一切后果将由下载用户自行承担。
原创板块未经允许不得转载,否则将追究法律责任。

淘吗网 thinkphp ThinkPHP 8 延时任务实战:Redis 有序集合实现订单超时关闭(秒级精度 + 防重复执行) https://www.taomawang.com/server/thinkphp/3026.html

常见问题

相关文章

猜你喜欢
发表评论
暂无评论
官方客服团队

为您解决烦忧 - 24小时在线 专业服务