一、什么是工作流引擎?
工作流引擎(Workflow Engine)是一种负责定义、调度、执行和管理工作流的运行时系统。
它将一个复杂任务拆分成多个独立执行单元,通过节点之间的依赖关系确定执行顺序,并在运行过程中维护任务状态、传递数据、处理异常和记录执行历史。
从系统职责来看,工作流引擎主要解决六个问题:
- 任务如何组织:将业务任务拆分成节点,建立节点之间的依赖关系。
- 任务何时执行:根据依赖条件、触发事件和调度策略确定执行时机。
- 任务如何协作:管理节点输入、输出和共享状态。
- 任务如何并发:识别可并行执行的节点,控制资源和并发数量。
- 任务如何恢复:处理超时、失败、重试、暂停和进程重启。
- 任务如何追踪:记录每个节点的执行过程和工作流实例的生命周期。
一个典型的工作流引擎可以抽象为:
flowchart TD
A["工作流定义"] --> B["工作流解析"]
B --> C["构建执行图"]
C --> D["创建工作流实例"]
D --> E["节点调度器"]
E --> F["节点执行器"]
F --> G["状态管理"]
G --> H["结果持久化"]
H --> I["执行监控与追踪"]
G --> E
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#EAF3EC,stroke:#83A995,color:#315D49
style C fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style D fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style E fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style F fill:#EAF3EC,stroke:#83A995,color:#315D49
style G fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style H fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style I fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
需要区分两个概念:
- 工作流定义(Workflow Definition):描述任务应该如何执行。
- 工作流引擎(Workflow Engine):负责让工作流定义真正运行起来。
工作流定义是静态的执行描述,工作流引擎则负责动态执行和状态管理。
二、工作流引擎的核心数据模型
理解工作流引擎,首先要建立几个核心对象之间的关系。
1. Workflow:工作流
Workflow 是一个完整的任务流程定义。
通常包含:
- 工作流 ID。
- 工作流名称。
- 节点集合。
- 节点之间的连接关系。
- 输入输出定义。
- 条件分支。
- 循环规则。
- 错误处理策略。
- 超时和重试配置。
- 版本信息。
例如,一个文档分析工作流:
{
"workflow_id": "document_analysis",
"version": 1,
"nodes": [
{
"id": "parse",
"type": "document_parser"
},
{
"id": "extract",
"type": "information_extractor"
},
{
"id": "analyze",
"type": "llm_analysis"
},
{
"id": "output",
"type": "result_output"
}
],
"edges": [
{
"source": "parse",
"target": "extract"
},
{
"source": "extract",
"target": "analyze"
},
{
"source": "analyze",
"target": "output"
}
]
}
这里的 JSON 只是简化示例,生产系统还需要定义节点参数、输入输出 Schema、边条件、失败策略和版本兼容规则。
2. Workflow Instance:工作流实例
Workflow Instance 表示某一次实际运行。
同一个工作流定义可以创建多个实例,每个实例具有独立的输入、状态和执行历史。
例如:
工作流定义:document_analysis
工作流实例:
├── instance_001:分析合同 A
├── instance_002:分析合同 B
└── instance_003:分析合同 C
工作流实例通常包含:
| 字段 | 含义 |
|---|---|
| instance_id | 实例唯一标识 |
| workflow_id | 所属工作流 |
| workflow_version | 执行时使用的定义版本 |
| status | 当前实例状态 |
| input | 初始输入 |
| context | 工作流运行上下文 |
| created_at | 创建时间 |
| started_at | 开始执行时间 |
| completed_at | 结束时间 |
| error | 实例级错误信息 |
3. Node:节点
Node 是工作流中的基本执行单元。
一个节点通常具有:
- 节点 ID。
- 节点类型。
- 节点配置。
- 输入 Schema。
- 输出 Schema。
- 执行函数。
- 超时配置。
- 重试策略。
- 错误处理策略。
例如:
{
"id": "llm_analysis",
"type": "llm",
"config": {
"model": "example-model",
"temperature": 0.2
},
"timeout": 30000,
"retry": {
"max_attempts": 3
}
}
节点定义描述如何执行,而节点执行记录描述某一次具体执行发生了什么。
这两个对象必须区分。
4. Edge:边
Edge 表示节点之间的依赖关系。
例如:
flowchart TD
A["文档解析"] --> B["信息抽取"]
B --> C["风险分析"]
C --> D["报告生成"]
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#EAF3EC,stroke:#83A995,color:#315D49
style C fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style D fill:#DCEFE5,stroke:#4F8B70,color:#24563F
边可以包含更多执行语义:
- 普通依赖:上游节点完成后执行下游节点。
- 条件依赖:只有满足特定条件才执行。
- 多输入依赖:等待多个上游节点完成。
- 错误依赖:上游失败后进入错误处理节点。
- 循环连接:满足循环条件时重新执行指定节点。
5. Node Execution:节点执行记录
一个节点可能被执行多次,因此不能只在 Node 对象上记录一个执行状态。
例如,一个节点由于失败重试,可能产生多次执行尝试。
建议将节点定义和执行记录分离:
Node Definition
└── Node Execution
├── Attempt 1:Failed
├── Attempt 2:Failed
└── Attempt 3:Completed
Node Execution 通常记录:
- execution_id。
- instance_id。
- node_id。
- attempt_number。
- status。
- input_snapshot。
- output_snapshot。
- started_at。
- completed_at。
- error。
- worker_id。
这种设计可以保留完整的执行历史,也便于问题定位和重试分析。
三、节点模型:工作流的执行基础
节点不仅是一个函数调用,更是工作流引擎管理任务执行的基本抽象。
1. 节点的基本结构
一个节点可以抽象为:
其中:
- ID:节点唯一标识。
- Type:节点类型。
- Config:节点运行配置。
- Input:节点输入数据。
- Output:节点输出数据。
- Executor:具体执行逻辑。
节点的执行可以抽象为:
其中 Context 表示工作流运行上下文。
对于纯函数节点,相同输入和配置应产生相同输出;但对于 LLM、随机计算、外部 API 和数据库操作,执行结果可能受到外部状态和非确定性因素影响。
2. 节点类型
工作流引擎通常需要支持多种节点类型。
| 节点类型 | 主要职责 | 典型场景 |
|---|---|---|
| Start Node | 启动工作流 | 接收请求 |
| End Node | 结束工作流 | 返回结果 |
| LLM Node | 调用大模型 | 分类、生成、推理 |
| Tool Node | 调用外部工具 | API、数据库、搜索 |
| Code Node | 执行代码 | 数据转换、计算 |
| Condition Node | 条件判断 | 分支路由 |
| Loop Node | 循环执行 | 批量处理 |
| Parallel Node | 并行执行 | 多任务协同 |
| Join Node | 汇聚执行结果 | 多分支合并 |
| Human Node | 等待人工操作 | 审核、审批 |
| Subworkflow Node | 调用子工作流 | 复用业务流程 |
节点类型可以扩展,但底层执行接口应尽量统一。
3. 节点执行接口
一个通用节点执行接口可以抽象为:
interface NodeExecutor {
execute(
input: Record<string, unknown>,
context: WorkflowContext,
config: Record<string, unknown>
): Promise<NodeResult>;
}
interface NodeResult {
output: Record<string, unknown>;
status: "completed" | "failed";
}
这里的接口是架构示意,实际生产实现还应考虑:
- 取消信号。
- 超时控制。
- 执行元数据。
- 错误分类。
- 重试策略。
- 日志和 Trace。
- 资源限制。
节点执行器只负责完成节点自身的业务逻辑,不应直接承担整个工作流的调度职责。
4. 节点执行生命周期
一个节点从被调度到完成,需要经历多个阶段。
flowchart TD
A["节点等待中"] --> B["满足执行条件"]
B --> C["加入调度队列"]
C --> D["分配执行资源"]
D --> E["加载节点输入"]
E --> F["执行节点逻辑"]
F --> G["校验执行结果"]
G --> H{"执行是否成功"}
H -->|"是"| I["保存输出"]
I --> J["标记 Completed"]
H -->|"否"| K["记录异常"]
K --> L{"是否允许重试"}
L -->|"是"| M["等待重试"]
M --> C
L -->|"否"| N["标记 Failed"]
style A fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style C fill:#EAF3EC,stroke:#83A995,color:#315D49
style D fill:#EAF3EC,stroke:#83A995,color:#315D49
style E fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style F fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style G fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style H fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style I fill:#EAF3EC,stroke:#83A995,color:#315D49
style J fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style K fill:#F7EAE7,stroke:#C98D7C,color:#754438
style L fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style M fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style N fill:#F7EAE7,stroke:#C98D7C,color:#754438
这里需要区分两个动作:
- 节点被调度,不代表节点已经开始执行。
- 节点函数执行完成,不代表节点结果已经可靠持久化。
只有执行结果经过必要校验并完成状态提交,才能安全地将节点标记为完成。
四、工作流图结构与节点依赖
工作流引擎通常使用图结构描述节点之间的关系。
1. DAG:有向无环图
DAG(Directed Acyclic Graph)是工作流编排中非常常见的数据结构。
它具有两个核心特征:
- 有向:边具有方向,表示任务依赖关系。
- 无环:沿着边的方向无法回到原始节点。
例如:
flowchart TD
A["开始"] --> B["读取用户数据"]
A --> C["读取订单数据"]
B --> D["数据整合"]
C --> D
D --> E["生成分析结果"]
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#EAF3EC,stroke:#83A995,color:#315D49
style C fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style D fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style E fill:#DCEFE5,stroke:#4F8B70,color:#24563F
DAG 能够表达:
- 节点依赖。
- 执行顺序。
- 并行关系。
- 汇聚关系。
对于静态 DAG,可以在工作流启动前进行拓扑排序,提前发现循环依赖。
2. 拓扑排序
拓扑排序(Topological Sorting)用于确定有向无环图中节点的合法执行顺序。
如果存在边:
则 A 必须在 B 之前完成。
常见算法包括:
- Kahn 算法:通过入度为零的节点逐步构建执行顺序。
- DFS 算法:通过深度优先搜索和完成时间构建拓扑序列。
Kahn 算法的基本过程:
- 计算每个节点的入度。
- 将所有入度为零的节点加入队列。
- 取出一个节点并加入拓扑序列。
- 删除该节点的出边,更新下游节点入度。
- 将新出现的入度为零节点加入队列。
- 重复直到队列为空。
flowchart TD
A["构建节点依赖图"] --> B["计算所有节点入度"]
B --> C["寻找入度为零的节点"]
C --> D{"是否存在可执行节点"}
D -->|"是"| E["取出节点加入拓扑序列"]
E --> F["移除该节点的出边"]
F --> G["更新下游节点入度"]
G --> C
D -->|"否"| H{"是否所有节点都已处理"}
H -->|"是"| I["得到拓扑排序"]
H -->|"否"| J["检测到循环依赖"]
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#EAF3EC,stroke:#83A995,color:#315D49
style C fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style D fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style E fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style F fill:#EAF3EC,stroke:#83A995,color:#315D49
style G fill:#EAF3EC,stroke:#83A995,color:#315D49
style H fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style I fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style J fill:#F7EAE7,stroke:#C98D7C,color:#754438
Kahn 算法的时间复杂度为:
其中:
- V:节点数量。
- E:边数量。
如果最终处理的节点数量小于图中节点总数,说明图中存在环。
需要注意,静态拓扑排序主要适合 DAG。动态条件分支、循环和运行时生成节点的工作流,通常还需要结合执行状态和动态调度机制。
3. 节点依赖与执行就绪条件
节点的执行条件不仅仅是上游节点已经执行。
通常还需要判断:
- 所有必需依赖是否完成。
- 对应分支是否被选中。
- 节点是否已经被取消。
- 是否满足运行时间和资源限制。
- 工作流实例是否仍允许继续执行。
对于一个普通的多输入节点,可以定义:
其中:
- Pred(v):节点 v 的前驱节点集合。
- Completed(u):前驱节点 u 是否完成。
对于条件边,还需要将边的条件纳入判断:
这里的 Satisfied(e) 不仅包括上游执行完成,还包括边是否被激活。
这一区别非常重要:某个分支没有被选择,不应该被当作一个永远等待的未完成依赖。
4. 条件分支
条件分支根据节点输出决定后续执行路径。
flowchart TD
A["接收用户问题"] --> B["识别问题类型"]
B --> C{"问题类型"}
C -->|"订单问题"| D["查询订单系统"]
C -->|"产品问题"| E["检索产品知识库"]
C -->|"技术问题"| F["检索技术文档"]
D --> G["整合结果"]
E --> G
F --> G
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style C fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style D fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style E fill:#EAF3EC,stroke:#83A995,color:#315D49
style F fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style G fill:#DCEFE5,stroke:#4F8B70,color:#24563F
条件节点负责计算分支结果,调度器负责根据分支结果激活对应边。
两者不应该混为一谈。
5. 并行节点与汇聚节点
如果多个节点之间没有依赖关系,工作流引擎可以并行执行。
例如:
flowchart TD
A["开始"] --> B["读取用户信息"]
A --> C["读取订单信息"]
A --> D["读取商品信息"]
B --> E["汇总分析"]
C --> E
D --> E
E --> F["输出结果"]
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#EAF3EC,stroke:#83A995,color:#315D49
style C fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style D fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style E fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style F fill:#DCEFE5,stroke:#4F8B70,color:#24563F
B、C、D 可以同时执行。
E 是汇聚节点,需要等待所有被激活且必需的上游分支完成。
这里有三个容易混淆的概念:
- Parallel:表示多个任务可以同时执行。
- Join:表示等待多个分支达到汇聚条件。
- Merge:表示将多个分支的结果合并为统一数据。
Join 解决控制依赖,Merge 解决数据合并。两者可以由同一个节点实现,也可以分开实现。
五、工作流状态机:如何管理执行生命周期
工作流引擎不仅需要执行节点,还需要知道整个任务当前处于什么状态。
状态机(State Machine)是工作流运行时的核心机制之一。
1. 工作流实例状态
常见工作流实例状态:
| 状态 | 含义 |
|---|---|
| Created | 实例已创建,尚未启动 |
| Running | 正在执行 |
| Waiting | 等待外部事件或人工输入 |
| Paused | 已暂停 |
| Completed | 成功完成 |
| Failed | 执行失败 |
| Cancelled | 已取消 |
| TimedOut | 执行超时 |
不同引擎可能使用不同的状态名称,也可能将超时表示为失败原因,而不是独立状态。
2. 状态转换
工作流状态转换可以抽象为:
flowchart TD
A["Created"] --> B["Running"]
B --> C["Waiting"]
C --> B
B --> D["Paused"]
D --> B
B --> E["Completed"]
B --> F["Failed"]
B --> G["Cancelled"]
B --> H["TimedOut"]
H --> F
style A fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style C fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style D fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style E fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style F fill:#F7EAE7,stroke:#C98D7C,color:#754438
style G fill:#F7EAE7,stroke:#C98D7C,color:#754438
style H fill:#F7EAE7,stroke:#C98D7C,color:#754438
这只是一个简化状态图,实际引擎还需要明确:
- 哪些状态可以暂停。
- 哪些状态可以恢复。
- 取消请求如何传播到运行中的节点。
- 超时后是否允许重试。
- 终态是否允许重新执行。
- 等待状态如何通过外部事件恢复。
3. 状态机的核心约束
状态机的意义不仅是记录当前状态,还要限制非法转换。
例如:
Created → Running 合法
Running → Completed 合法
Running → Failed 合法
Waiting → Running 合法
Completed → Running 通常不允许直接转换
Cancelled → Completed 不允许直接转换
状态转换应通过统一的状态管理接口完成,而不是让不同节点随意修改实例状态。
一个状态转换操作可以抽象为:
interface StateTransition {
instanceId: string;
expectedState: string;
targetState: string;
reason?: string;
}
更新时应检查当前状态是否仍然等于 expectedState。
例如,两个 Worker 同时尝试更新同一个实例时,只有一个符合预期状态的更新应该成功。
可以通过数据库条件更新、版本号或乐观锁实现这一约束。
4. 工作流状态与节点状态必须分离
工作流实例状态和节点执行状态不是同一个层次。
例如:
Workflow Instance: Running
Node A: Completed
Node B: Completed
Node C: Running
Node D: Pending
工作流处于 Running,不代表所有节点都在执行。
节点处于 Failed,也不一定意味着整个工作流立即 Failed。引擎可能选择重试、降级、执行错误分支或等待人工处理。
因此,应分别维护:
- Workflow State:工作流实例状态。
- Node State:节点执行状态。
- Execution Attempt:节点的每次执行尝试状态。
5. 节点状态
节点状态通常包括:
| 状态 | 含义 |
|---|---|
| Pending | 尚未满足执行条件 |
| Ready | 已满足依赖,可以调度 |
| Queued | 已进入调度队列 |
| Running | 正在执行 |
| Waiting | 等待外部条件 |
| Retrying | 等待下一次重试 |
| Completed | 执行成功 |
| Failed | 执行失败 |
| Skipped | 根据流程条件跳过 |
| Cancelled | 已取消 |
节点状态转换示意:
flowchart TD
A["Pending"] --> B["Ready"]
B --> C["Queued"]
C --> D["Running"]
D --> E["Completed"]
D --> F["Failed"]
D --> G["Waiting"]
G --> D
F --> H{"是否允许重试"}
H -->|"是"| I["Retrying"]
I --> C
H -->|"否"| J["终止失败"]
B --> K["Skipped"]
C --> L["Cancelled"]
style A fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style C fill:#EAF3EC,stroke:#83A995,color:#315D49
style D fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style E fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style F fill:#F7EAE7,stroke:#C98D7C,color:#754438
style G fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style H fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style I fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style J fill:#F7EAE7,stroke:#C98D7C,color:#754438
style K fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style L fill:#F7EAE7,stroke:#C98D7C,color:#754438
注意:Queued 和 Ready 是否作为独立状态,取决于引擎的实现。简单引擎可能将它们合并,分布式引擎通常需要区分调度资格与队列状态。
六、工作流引擎的调度机制
调度器(Scheduler)负责决定哪些节点可以执行,以及何时执行。
它连接工作流图结构与实际执行资源,是工作流引擎的核心组件。
1. 调度器的主要职责
- 查找已经满足执行条件的节点。
- 判断节点是否被激活。
- 将节点加入执行队列。
- 控制并发数量。
- 分配 Worker。
- 处理执行超时。
- 监听节点完成事件。
- 更新节点状态。
- 触发下游节点。
调度器通常不直接执行节点内部业务逻辑,而是将任务交给执行器或 Worker。
2. 调度过程
flowchart TD
A["工作流状态更新"] --> B["查找待调度节点"]
B --> C["检查节点依赖"]
C --> D{"是否满足执行条件"}
D -->|"否"| E["保持 Pending"]
D -->|"是"| F["检查并发与资源限制"]
F --> G{"是否有可用资源"}
G -->|"否"| H["等待资源"]
G -->|"是"| I["加入执行队列"]
I --> J["Worker 获取任务"]
J --> K["执行节点"]
K --> L["提交执行结果"]
L --> M["更新节点状态"]
M --> A
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#EAF3EC,stroke:#83A995,color:#315D49
style C fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style D fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style E fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style F fill:#EAF3EC,stroke:#83A995,color:#315D49
style G fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style H fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style I fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style J fill:#EAF3EC,stroke:#83A995,color:#315D49
style K fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style L fill:#EAF3EC,stroke:#83A995,color:#315D49
style M fill:#DCEFE5,stroke:#4F8B70,color:#24563F
3. 事件驱动调度
一种简单的实现方式是周期性扫描所有待执行节点。
例如每隔一定时间检查:
- 哪些节点已经满足依赖。
- 哪些节点等待重试。
- 哪些节点已经超时。
- 哪些实例需要恢复。
这种方式实现简单,但随着工作流数量增加,会产生大量无效扫描。
更常见的优化是事件驱动调度。
事件示例:
NodeCompletedNodeFailedNodeRetryDueWorkflowStartedHumanApprovalReceivedTimeoutTriggered
当节点完成时,系统只需要检查它影响到的下游节点,而不必扫描整个工作流。
flowchart TD
A["节点执行完成"] --> B["发布 NodeCompleted 事件"]
B --> C["事件处理器接收事件"]
C --> D["定位下游依赖节点"]
D --> E["更新依赖状态"]
E --> F{"是否满足执行条件"}
F -->|"是"| G["提交调度任务"]
F -->|"否"| H["继续等待其他依赖"]
G --> I["调度器执行后续调度"]
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style C fill:#EAF3EC,stroke:#83A995,color:#315D49
style D fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style E fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style F fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style G fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style H fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style I fill:#EAF3EC,stroke:#83A995,color:#315D49
事件驱动可以减少无效扫描,但需要处理事件重复投递、乱序和丢失问题。
因此,事件处理应具备幂等性,并且要有可靠的事件持久化机制。
4. 调度队列与 Worker
在分布式工作流引擎中,调度器通常不会直接执行所有节点,而是通过任务队列分配执行任务。
典型架构:
flowchart TB
A["Workflow Engine"] --> B["Scheduler"]
B --> C["Task Queue"]
C --> D["Worker 1"]
C --> E["Worker 2"]
C --> F["Worker 3"]
D --> G["Node Executor"]
E --> G
F --> G
G --> H["执行结果"]
H --> I["State Store"]
I --> A
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style C fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style D fill:#EAF3EC,stroke:#83A995,color:#315D49
style E fill:#EAF3EC,stroke:#83A995,color:#315D49
style F fill:#EAF3EC,stroke:#83A995,color:#315D49
style G fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style H fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style I fill:#EAE8FA,stroke:#A49BD5,color:#51477D
Worker 负责:
- 获取执行任务。
- 加载节点输入。
- 调用节点执行器。
- 处理执行超时。
- 提交执行结果。
- 发送执行事件。
任务队列和 Worker 可以独立扩展,从而提高系统吞吐能力。
5. 并发控制
工作流中的多个节点可能同时具备执行资格,但并不意味着可以无限并发。
需要考虑:
- 全局并发上限。
- 单个工作流实例并发上限。
- 单个节点类型并发上限。
- 模型 API 限流。
- 数据库连接数。
- Worker 可用资源。
- 用户级资源配额。
例如,一个工作流可以同时执行多个文档解析任务,但调用外部模型的节点可能需要限制并发数量。
常见控制策略:
| 策略 | 作用 |
|---|---|
| Semaphore | 限制同时执行的任务数量 |
| Token Bucket | 控制一定时间内的请求速率 |
| Priority Queue | 按任务优先级调度 |
| Rate Limiter | 限制接口调用频率 |
| Resource Pool | 管理可用执行资源 |
| Backpressure | 过载时减缓任务提交速度 |
6. 优先级调度
当多个工作流实例同时等待执行时,可以根据业务优先级安排任务。
例如:
- 付费用户任务优先。
- 交互式任务优先于批量任务。
- 临近截止时间的任务优先。
- 高优先级业务任务优先。
但优先级调度需要考虑饥饿问题。
如果高优先级任务持续到达,低优先级任务可能长期无法执行。
可采用动态优先级、等待时间加权和公平调度等策略。
七、工作流的数据传递与上下文管理
工作流中的节点通常不是孤立执行的。上游节点产生的数据需要传递给下游节点。
1. 工作流上下文 Context
Context 是工作流实例运行期间的数据容器。
它通常包含:
- 初始输入。
- 节点输出。
- 中间处理结果。
- 用户和租户信息。
- 运行配置。
- 执行元数据。
- 共享状态。
例如:
{
"workflow_id": "customer_service",
"instance_id": "run_1001",
"context": {
"input": {
"question": "订单什么时候发货?"
},
"intent": {
"type": "order_status"
},
"order": {
"order_id": "O10001",
"status": "shipped"
},
"answer": {
"text": "您的订单已经发货。"
}
}
}
2. 显式数据映射
更可靠的方式是通过节点之间明确的数据映射传递数据。
例如:
{
"source": "extract_node",
"target": "analysis_node",
"mapping": {
"contract_name": "input.name",
"parties": "input.parties",
"amount": "input.amount"
}
}
这种设计能够明确数据依赖,避免节点之间形成隐式耦合。
3. 数据传递的三种模式
共享上下文模式
所有节点访问统一的 Workflow Context。
优点是实现简单,缺点是容易产生数据覆盖和并发写入冲突。
显式输入输出模式
节点声明输入和输出,执行引擎负责数据映射。
优点是依赖关系清晰,适合类型校验和静态分析。
事件传递模式
节点完成后发布事件,下游节点订阅事件并获取结果。
适合异步、分布式和事件驱动架构。
实际系统可以组合使用这些模式,但需要明确数据所有权和一致性边界。
4. 并发写入冲突
假设两个节点同时更新同一个上下文:
Node A:context.user.profile
Node B:context.user.profile
如果没有并发控制,后写入的数据可能覆盖先写入的数据。
常见解决方案:
- 每个节点只写入自己的命名空间。
- 使用不可变状态和状态补丁。
- 使用版本号进行乐观锁控制。
- 对共享字段使用显式合并策略。
- 将关键业务状态放到独立数据库事务中管理。
对于并行工作流,不建议让多个节点直接修改同一个大型 JSON 对象。
八、工作流持久化、Checkpoint 与断点恢复
持久化是工作流引擎区别于普通函数调用链的重要能力。
1. 为什么需要持久化?
假设一个工作流需要执行 20 个节点,已经完成前 15 个节点。
此时服务进程崩溃,如果没有持久化机制,系统可能需要重新执行全部任务。
如果前面的节点包含:
- 大模型调用。
- 大文件解析。
- 外部 API 请求。
- 数据库写入。
重新执行会带来额外成本,甚至可能产生重复副作用。
因此,工作流引擎需要保存执行进度。
2. Checkpoint 检查点
Checkpoint 是工作流在某个时刻保存的可恢复状态快照。
通常包括:
- 工作流实例状态。
- 已完成节点集合。
- 当前节点状态。
- 节点输出。
- 工作流上下文。
- 待执行任务。
- 等待事件信息。
- 状态版本。
flowchart TD
A["工作流开始"] --> B["执行节点 A"]
B --> C["保存 Checkpoint 1"]
C --> D["执行节点 B"]
D --> E["保存 Checkpoint 2"]
E --> F["执行节点 C"]
F --> G{"进程是否正常"}
G -->|"是"| H["继续执行节点 D"]
G -->|"否"| I["重新加载持久化状态"]
I --> J["恢复 Checkpoint 2"]
J --> K["重新判断节点 C 的执行结果"]
K --> L["恢复后继续执行"]
H --> M["工作流完成"]
L --> M
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#EAF3EC,stroke:#83A995,color:#315D49
style C fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style D fill:#EAF3EC,stroke:#83A995,color:#315D49
style E fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style F fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style G fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style H fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style I fill:#F7EAE7,stroke:#C98D7C,color:#754438
style J fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style K fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style L fill:#EAF3EC,stroke:#83A995,color:#315D49
style M fill:#DCEFE5,stroke:#4F8B70,color:#24563F
注意:Checkpoint 保存了执行状态,不一定保存了所有外部系统的真实状态。
如果节点调用了外部支付接口,Checkpoint 无法自动保证支付操作和本地状态更新处于同一个事务中。
3. 节点级持久化与工作流级持久化
工作流级持久化
保存整个工作流实例的状态和上下文。
适合恢复工作流整体执行进度。
节点级持久化
保存每个节点的执行记录、输入、输出和状态。
适合定位节点故障、执行重试和审计。
两者通常需要结合使用。
4. Exactly-once 问题
工作流引擎经常面临一个重要问题:
如何保证一个节点只执行一次?
在分布式环境中,严格的 Exactly-once 执行语义很难保证。
例如:
- Worker 调用外部 API。
- 外部 API 已经成功执行。
- Worker 在提交本地结果之前崩溃。
- 调度器认为任务没有完成。
- 任务重新进入队列。
- 另一个 Worker 再次执行。
这会造成重复操作。
因此,实际系统通常采用:
- At-least-once 投递。
- 幂等执行。
- 去重机制。
- 操作状态查询。
- 事务性消息机制。
对于具有副作用的节点,应使用稳定的业务幂等键。
例如:
idempotency_key =
workflow_instance_id + node_id + business_operation_id
同一个业务操作重复提交时,外部服务根据幂等键识别重复请求。
需要注意,幂等键的作用范围、有效期和存储位置必须由业务系统明确约定,不能只依赖工作流引擎生成一个随机 ID。
5. 状态提交与任务投递的一致性
分布式工作流引擎还存在一个问题:
节点状态更新成功,但下游任务没有成功投递;或者任务已经投递,但状态更新失败。
这会导致任务丢失或重复执行。
一种常见解决方案是 Transactional Outbox:
- 在同一个数据库事务中更新节点状态。
- 同时写入待发布事件。
- 后台事件发布器读取 Outbox。
- 将事件投递到消息队列。
- 标记事件已发布。
- 消费端通过幂等机制处理重复事件。