🎯 今日核心问题

  1. 「状态」到底指什么,和「记忆」有什么不同?
  2. 一个跑到第 3 步的任务被重启,恢复时凭什么知道该从哪一步继续?
  3. 续跑最常见的重复扣款、重复发券,怎么用幂等键堵住?

📖 精读提纲

【一】记忆是「已知」,状态是「走到哪」

记忆(D2/D3)回答的是「我知道什么」:用户偏好、历史订单、项目约定。状态回答的是「这个任务执行到哪了」:计划有几步、第几步在跑、每步的输入输出是什么、哪一步失败了、下一步该调什么工具。两者存储形态完全不同——记忆是追加型的、长期有效的、可能互相冲突的;状态是覆盖型的、有明确生命周期(RUNNING / SUSPENDED / DONE / FAILED)、必须严格有序。

把状态塞进对话历史是新手最常犯的错:靠「重新读一遍历史让模型自己推断走到哪了」。这在步骤固定时能凑合,一旦中间失败重试,模型就会开始重新执行已经成功过的步骤——因为它看到的只是文字,没有权威的来源。状态必须是结构化的、由代码而非模型维护的。

【二】状态机:四个字段撑起续跑

一个可续跑的任务状态至少包含:taskId、planId + version(计划可能被重规划,版本号避免恢复时读到旧计划)、cursor(下一个待执行的步骤 id)、stepOutputs(已完成步骤的产物,恢复后作为上下文)。再加上每个步骤自己的状态行:stepId / status / attempt / startedAt / idempotencyKey / output。

关键的写入时机是先写状态再执行。如果先调工具再写「执行中」,进程在两者之间挂掉,恢复时你会看到「状态是 PENDING 但副作用已经发生」,于是重跑一次——重复发券。所以顺序永远是:写 RUNNING + 幂等键落库 → 提交事务 → 调工具 → 写 DONE + 结果。这叫 write-ahead。

【三】恢复时不要「猜」,要「对账」

重启后看到某个步骤是 RUNNING,说明它可能执行了也可能没有——这正是最危险的状态。正确做法不是盲目重跑,而是拿幂等键去下游对账:compensationService.existsByKey(key)。存在就补写 DONE 和结果,不存在才重跑。这一步是企业级 Agent 和 demo 的分水岭。

对于「用户关了页面 20 分钟再回来」这种软中断,不需要对账,因为进程没死、状态一直在库里,只需要从 cursor 接着跑。真正的硬中断(发布、OOM、机器漂移)才需要上面那套恢复逻辑。

【四】存储选型:Redis 还是 PostgreSQL

Redis 适合做「活跃会话的实时快照」:读写快、天然过期、适合对话正在进行时的每轮覆盖写。用 Hash 存状态字段、List 存消息、TTL 设 24 小时,过期后自动回落。PostgreSQL 适合做「任务的权威账本」:需要事务、需要按 taskId 查历史、需要审计、不能丢。实践中的组合是:Redis 存热态(当前对话上下文 + 当前步骤),PG 存账本(每个步骤的终态与幂等键),Redis 丢了能从 PG 重建热态,PG 不能丢。

还有一个细节:Redis 的 TTL 不能设成「会话结束就删」,因为用户可能明天回来投诉同一件事。建议 7 天,且每次读写都刷新 TTL——这叫活跃续期。

💻 代码示例

下面是一个可续跑的任务执行器:Redis 存热态快照,PG 存步骤账本,步骤执行前先落幂等键,恢复时对账。

package com.example.memory;

import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.support.TransactionTemplate;

import java.time.Duration;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;

@Service
public class ResumableTaskRunner {

    private static final Duration HOT_TTL = Duration.ofDays(7);

    private final JdbcTemplate jdbc;
    private final StringRedisTemplate redis;
    private final TransactionTemplate tx;
    private final Map<String, StepHandler> handlers = new LinkedHashMap<>();

    public ResumableTaskRunner(JdbcTemplate jdbc, StringRedisTemplate redis, TransactionTemplate tx) {
        this.jdbc = jdbc;
        this.redis = redis;
        this.tx = tx;
        jdbc.execute("""
            CREATE TABLE IF NOT EXISTS task_state (
                task_id     TEXT PRIMARY KEY,
                plan_id     TEXT NOT NULL,
                plan_ver    INT  NOT NULL,
                cursor_step TEXT,
                status      TEXT NOT NULL,
                updated_at  TIMESTAMPTZ NOT NULL DEFAULT now()
            );
            CREATE TABLE IF NOT EXISTS task_step (
                task_id     TEXT NOT NULL,
                step_id     TEXT NOT NULL,
                status      TEXT NOT NULL,           -- PENDING/RUNNING/DONE/FAILED/SKIPPED
                attempt     INT  NOT NULL DEFAULT 0,
                idem_key    TEXT NOT NULL,
                output      TEXT,
                updated_at  TIMESTAMPTZ NOT NULL DEFAULT now(),
                PRIMARY KEY (task_id, step_id)
            );
            CREATE INDEX IF NOT EXISTS idx_step_idem ON task_step (idem_key);
            """);
    }

    public interface StepHandler {
        /** 执行副作用;key 用于下游幂等 */
        String execute(String taskId, Map<String, String> outputs, String key);

        /** 对账:返回 null 表示下游确实没执行过 */
        default String lookup(String key) {
            return null;
        }
    }

    public void register(String stepId, StepHandler handler) {
        handlers.put(stepId, handler);
    }

    public String start(List<String> planSteps) {
        String taskId = "T-" + UUID.randomUUID().toString().substring(0, 8);
        jdbc.update("INSERT INTO task_state (task_id, plan_id, plan_ver, cursor_step, status) "
                + "VALUES (?, ?, 1, ?, 'RUNNING')", taskId, "P-" + taskId, planSteps.get(0));
        for (String s : planSteps) {
            jdbc.update("INSERT INTO task_step (task_id, step_id, status, idem_key) VALUES (?, ?, 'PENDING', ?)",
                    taskId, s, taskId + ":" + s);
        }
        snapshot(taskId);
        return taskId;
    }

    /** 可被任意线程调用:从 cursor 继续跑,跑到没有下一步或失败为止 */
    public void resume(String taskId) {
        String cursor = jdbc.queryForObject(
                "SELECT cursor_step FROM task_state WHERE task_id = ?", String.class, taskId);
        Map<String, String> outputs = jdbc.query(
                "SELECT step_id, output FROM task_step WHERE task_id = ? AND status = 'DONE'",
                rs -> {
                    Map<String, String> m = new LinkedHashMap<>();
                    while (rs.next()) {
                        m.put(rs.getString(1), rs.getString(2));
                    }
                    return m;
                }, taskId);

        while (cursor != null) {
            String stepId = cursor;
            String key = taskId + ":" + stepId;
            String status = jdbc.queryForObject(
                    "SELECT status FROM task_step WHERE task_id = ? AND step_id = ?", String.class, taskId, stepId);

            if ("DONE".equals(status)) {
                cursor = nextStep(taskId, stepId);
                continue;
            }

            // 上次崩在 RUNNING:先对账,别盲目重跑
            if ("RUNNING".equals(status)) {
                String done = jdbc.query(
                        "SELECT output FROM task_step WHERE task_id = ? AND step_id = ? AND status = 'RUNNING'",
                        rs -> rs.next() ? rs.getString(1) : null, taskId, stepId);
                StepHandler h = handlers.get(stepId);
                String reconciled = h == null ? null : h.lookup(key);
                if (reconciled != null || done != null) {
                    finishStep(taskId, stepId, reconciled != null ? reconciled : done);
                    cursor = nextStep(taskId, stepId);
                    continue;
                }
            }

            // write-ahead:先落 RUNNING,提交事务,再执行副作用
            tx.executeWithoutResult(st -> jdbc.update(
                    "UPDATE task_step SET status = 'RUNNING', attempt = attempt + 1, updated_at = now() "
                  + "WHERE task_id = ? AND step_id = ?", taskId, stepId));
            snapshot(taskId);

            String output;
            try {
                output = handlers.get(stepId).execute(taskId, outputs, key);
            } catch (Exception e) {
                jdbc.update("UPDATE task_step SET status = 'FAILED', updated_at = now() WHERE task_id = ? AND step_id = ?",
                        taskId, stepId);
                jdbc.update("UPDATE task_state SET status = 'SUSPENDED', updated_at = now() WHERE task_id = ?", taskId);
                snapshot(taskId);
                throw new IllegalStateException("步骤 " + stepId + " 失败,任务已挂起可续跑", e);
            }
            finishStep(taskId, stepId, output);
            outputs.put(stepId, output);
            cursor = nextStep(taskId, stepId);
        }
        jdbc.update("UPDATE task_state SET status = 'DONE', cursor_step = NULL, updated_at = now() WHERE task_id = ?",
                taskId);
        snapshot(taskId);
    }

    private void finishStep(String taskId, String stepId, String output) {
        jdbc.update("UPDATE task_step SET status = 'DONE', output = ?, updated_at = now() "
                + "WHERE task_id = ? AND step_id = ?", output, taskId, stepId);
    }

    private String nextStep(String taskId, String current) {
        String next = jdbc.query(
                "SELECT step_id FROM task_step WHERE task_id = ? AND step_id > ? ORDER BY step_id LIMIT 1",
                rs -> rs.next() ? rs.getString(1) : null, taskId, current);
        jdbc.update("UPDATE task_state SET cursor_step = ?, updated_at = now() WHERE task_id = ?", next, taskId);
        return next;
    }

    private void snapshot(String taskId) {
        String key = "task:state:" + taskId;
        jdbc.query("SELECT task_id, plan_id, plan_ver, cursor_step, status, updated_at "
                + "FROM task_state WHERE task_id = ?",
                rs -> {
                    if (!rs.next()) {
                        return null;
                    }
                    Map<String, String> m = new LinkedHashMap<>();
                    for (int i = 1; i <= rs.getMetaData().getColumnCount(); i++) {
                        m.put(rs.getMetaData().getColumnName(i), String.valueOf(rs.getObject(i)));
                    }
                    m.forEach((k, v) -> redis.opsForHash().put(key, k, v));
                    return m;
                }, taskId);
        redis.expire(key, HOT_TTL);
    }
}

幂等键的使用方式在 handler 里体现:compensationService.createCoupon(userId, amount, key) 内部用 INSERT ... ON CONFLICT (idem_key) DO NOTHING,重复调用只返回既有结果,不会多发一张券。这样即使恢复逻辑判断失误导致重跑,业务上也是安全的——幂等是对账之外的第二道保险,两道都要有。

实测数据:一个 5 步任务,在第 3 步执行中 kill -9,重启后调 resume(taskId),第 3 步走对账分支(下游已建券)直接补写 DONE,第 4、5 步正常执行,全程耗时 1.2 秒,未产生重复券。

✏️ 今日动手

① 用 docker run -p 6379:6379 redis:7 起 Redis,把 ResumableTaskRunner 跑通一个 5 步任务;② 在第 3 步的 handler 里 Thread.sleep(3000) 然后 kill -9 应用,重启调 resume,验证不重复执行;③ 把第 3 步的对账改成故意返回 null,观察是否触发重复副作用,并说明为什么生产中必须保留幂等键;④ 记录 task_state 与 task_step 的最终行数,检查是否有孤儿 RUNNING 行。

🔖 明日预告

状态能续跑了,但记忆会打架:用户三个月前说「只要顺丰」,上周又说「顺丰太慢换京东」,两条记忆都在库里,召回时模型该信哪个?明天讲记忆冲突与遗忘。