一、LangGraph 并行执行核心优势

相比其他工作流框架,LangGraph 的并行能力具备三大核心亮点:

  1. 极简定义,无冗余代码:无需手动管理线程、协程,框架底层自动处理任务并发,专注业务逻辑即可;
  2. 状态自动管理,数据无缝聚合:内置状态管理机制,并行任务的执行结果会自动同步、合并,无需手动处理数据传递;
  3. 流程可视化,结构一目了然:支持工作流图形化展示,并行分支、聚合节点清晰可见,调试和维护更简单。

本次实践中,我们构建了双任务并行的工作流:两个独立任务同时启动,耗时任务不阻塞其他任务执行,最终自动聚合所有结果,完美体现了 LangGraph 并行处理的核心价值。

二、LangGraph 并行执行的实现逻辑

实现 LangGraph 并行工作流,核心遵循状态定义→节点构建→并行入口配置→结果聚合四步逻辑,全程无需关注底层并发细节:

1. 定义结构化状态,奠定数据基础

首先通过结构化类型定义工作流的全局状态,包含输入数据、各任务的执行结果,以及专门用于聚合的结果集合。关键特性:状态支持自动合并注解,并行任务产生的数据会按照规则自动整合,避免数据冲突。

2. 编写独立任务节点

将需要并行执行的业务逻辑,封装为独立的处理节点,每个节点只关注自身的业务功能。节点之间完全解耦,互不干扰,这是并行执行的基础 —— 框架会自动识别独立节点,为其分配并行执行的资源。

3. 配置多入口,触发并行执行

这是实现并行的核心步骤:为工作流设置多个入口节点。LangGraph 会识别多个入口配置,同时启动所有入口节点,让多个任务真正意义上同步运行,而非串行等待。比如本次实践中,两个任务节点同时启动,快速任务无需等待耗时任务完成,极大缩短了总执行时间。

4. 自动聚合结果,完成闭环

并行任务执行完成后,所有分支会自动汇聚到统一的聚合节点。框架会自动同步所有并行任务的状态数据,在聚合节点中轻松获取所有任务的执行结果,完成最终的数据整合,流程闭环结束。

三、实战效果:并行执行的直观体现

在本次并行工作流中,我们设置了一个耗时 3 秒的任务和一个即时任务,运行效果完美验证了并行能力:

  1. 两个任务同时启动,即时任务瞬间完成执行,无需等待耗时任务;
  2. 耗时任务执行完毕后,流程自动进入聚合阶段;
  3. 最终统一输出所有任务的处理结果,总耗时仅等于最长单个任务的耗时,而非所有任务耗时之和。

同时,LangGraph 提供了工作流可视化能力,我们可以清晰看到:起始节点同时分叉出两个并行任务,任务执行完成后汇聚到聚合节点,最终结束流程,结构清晰易懂。

四、总结

LangGraph 让并行工作流的开发告别了复杂的并发编程,通过状态管理 + 多入口配置 + 自动聚合的极简模式,就能轻松实现多任务并行执行。

无论是 AI 多模型并行调用、数据多渠道同步处理,还是业务多分支同时执行,LangGraph 都能以最低的开发成本,实现最高效的流程处理,是构建现代工作流、AI 应用的绝佳工具。

代码实现:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

from langgraph.graph import StateGraph, END

from typing import TypedDict, Annotated

import operator

import time

# 定义状态(必须继承TypedDict)

class ParallelState(TypedDict):

    input_data: str

    task_a_result: str

    task_b_result: str

    all_results: Annotated[list, operator.add]  # 使用注解实现自动合并

# 创建图构建器

graph_builder = StateGraph(state_schema=ParallelState)

# 定义并行执行函数

def process_task_a(state: ParallelState):

    print("\nA开始执行...")

    time.sleep(3)  # 休眠3秒

    print("3秒后继续执行")

    print(f"Task A processing: {state['input_data']}")

    return {"task_a_result": f"A处理结果: {state['input_data']}"}

def process_task_b(state: ParallelState):

    print("\nB开始执行...")

    print(f"Task B processing: {state['input_data']}")

    return {"task_b_result": f"B处理结果: {state['input_data']}"}

def aggregate_results(state: ParallelState):

    all_results = [state['task_a_result'], state['task_b_result']]

    print(f"聚合结果: {all_results}")

    return {"all_results": all_results}

# 添加节点

graph_builder.add_node("task_a", process_task_a)

graph_builder.add_node("task_b", process_task_b)

graph_builder.add_node("aggregator", aggregate_results)

# 设置入口点 - 多个入口点实现并行

graph_builder.set_entry_point("task_a")

graph_builder.set_entry_point("task_b")

# 添加边连接

graph_builder.add_edge("task_a""aggregator")

graph_builder.add_edge("task_b""aggregator")

graph_builder.add_edge("aggregator", END)

# 编译图

graph = graph_builder.compile()

#画图

print(graph.get_graph().draw_ascii())

# 执行

initial_state = {"input_data""测试数据"}

result = graph.invoke(initial_state)

print("最终结果:", result)

输出数据:

       +-----------+          
        | __start__ |          
        +-----------+          
          *         *          
        **           **        
       *               *       
+--------+          +--------+ 
| task_a |          | task_b | 
+--------+          +--------+ 
          *         *          
           **     **           
             *   *             
        +------------+         
        | aggregator |         

Logo

Agent 垂直技术社区,欢迎活跃、内容共建。

更多推荐