🎯 今日核心问题
- 「状态」到底指什么,和「记忆」有什么不同?
- 一个跑到第 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 行。
🔖 明日预告
状态能续跑了,但记忆会打架:用户三个月前说「只要顺丰」,上周又说「顺丰太慢换京东」,两条记忆都在库里,召回时模型该信哪个?明天讲记忆冲突与遗忘。