返回专栏
· 34 分钟阅读

工作流引擎的节点、状态与执行机制:从任务调度到持久化执行的核心原理


一、什么是工作流引擎?

工作流引擎(Workflow Engine)是一种负责定义、调度、执行和管理工作流的运行时系统。

它将一个复杂任务拆分成多个独立执行单元,通过节点之间的依赖关系确定执行顺序,并在运行过程中维护任务状态、传递数据、处理异常和记录执行历史。

从系统职责来看,工作流引擎主要解决六个问题:

  1. 任务如何组织:将业务任务拆分成节点,建立节点之间的依赖关系。
  2. 任务何时执行:根据依赖条件、触发事件和调度策略确定执行时机。
  3. 任务如何协作:管理节点输入、输出和共享状态。
  4. 任务如何并发:识别可并行执行的节点,控制资源和并发数量。
  5. 任务如何恢复:处理超时、失败、重试、暂停和进程重启。
  6. 任务如何追踪:记录每个节点的执行过程和工作流实例的生命周期。

一个典型的工作流引擎可以抽象为:

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. 节点的基本结构

一个节点可以抽象为:

Node=(ID,Type,Config,Input,Output,Executor)

其中:

  • ID:节点唯一标识。
  • Type:节点类型。
  • Config:节点运行配置。
  • Input:节点输入数据。
  • Output:节点输出数据。
  • Executor:具体执行逻辑。

节点的执行可以抽象为:

Output=f(Input,Config,Context)

其中 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\rightarrow B

则 A 必须在 B 之前完成。

常见算法包括:

  • Kahn 算法:通过入度为零的节点逐步构建执行顺序。
  • DFS 算法:通过深度优先搜索和完成时间构建拓扑序列。

Kahn 算法的基本过程:

  1. 计算每个节点的入度。
  2. 将所有入度为零的节点加入队列。
  3. 取出一个节点并加入拓扑序列。
  4. 删除该节点的出边,更新下游节点入度。
  5. 将新出现的入度为零节点加入队列。
  6. 重复直到队列为空。
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 算法的时间复杂度为:

O(V+E)

其中:

  • V:节点数量。
  • E:边数量。

如果最终处理的节点数量小于图中节点总数,说明图中存在环。

需要注意,静态拓扑排序主要适合 DAG。动态条件分支、循环和运行时生成节点的工作流,通常还需要结合执行状态和动态调度机制。

3. 节点依赖与执行就绪条件

节点的执行条件不仅仅是上游节点已经执行。

通常还需要判断:

  • 所有必需依赖是否完成。
  • 对应分支是否被选中。
  • 节点是否已经被取消。
  • 是否满足运行时间和资源限制。
  • 工作流实例是否仍允许继续执行。

对于一个普通的多输入节点,可以定义:

Ready(v)=\bigwedge_{u\in Pred(v)}Completed(u)

其中:

  • Pred(v):节点 v 的前驱节点集合。
  • Completed(u):前驱节点 u 是否完成。

对于条件边,还需要将边的条件纳入判断:

Ready(v)=\bigwedge_{e\in In(v)}Satisfied(e)

这里的 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. 事件驱动调度

一种简单的实现方式是周期性扫描所有待执行节点。

例如每隔一定时间检查:

  • 哪些节点已经满足依赖。
  • 哪些节点等待重试。
  • 哪些节点已经超时。
  • 哪些实例需要恢复。

这种方式实现简单,但随着工作流数量增加,会产生大量无效扫描。

更常见的优化是事件驱动调度。

事件示例:

  • NodeCompleted
  • NodeFailed
  • NodeRetryDue
  • WorkflowStarted
  • HumanApprovalReceived
  • TimeoutTriggered

当节点完成时,系统只需要检查它影响到的下游节点,而不必扫描整个工作流。

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 执行语义很难保证。

例如:

  1. Worker 调用外部 API。
  2. 外部 API 已经成功执行。
  3. Worker 在提交本地结果之前崩溃。
  4. 调度器认为任务没有完成。
  5. 任务重新进入队列。
  6. 另一个 Worker 再次执行。

这会造成重复操作。

因此,实际系统通常采用:

  • At-least-once 投递。
  • 幂等执行。
  • 去重机制。
  • 操作状态查询。
  • 事务性消息机制。

对于具有副作用的节点,应使用稳定的业务幂等键。

例如:

idempotency_key =
    workflow_instance_id + node_id + business_operation_id

同一个业务操作重复提交时,外部服务根据幂等键识别重复请求。

需要注意,幂等键的作用范围、有效期和存储位置必须由业务系统明确约定,不能只依赖工作流引擎生成一个随机 ID。

5. 状态提交与任务投递的一致性

分布式工作流引擎还存在一个问题:

节点状态更新成功,但下游任务没有成功投递;或者任务已经投递,但状态更新失败。

这会导致任务丢失或重复执行。

一种常见解决方案是 Transactional Outbox:

  1. 在同一个数据库事务中更新节点状态。
  2. 同时写入待发布事件。
  3. 后台事件发布器读取 Outbox。
  4. 将事件投递到消息队列。
  5. 标记事件已发布。
  6. 消费端通过幂等机制处理重复事件。