Reactor 框架 Flux 和 Mono 类学习指南

一、Reactor 框架概述与核心概念

1.1 Reactor 框架简介与最新版本

Reactor 是一个专为 JVM 设计的完全非阻塞反应式编程基础框架，具有高效的需求管理（背压管理）能力。它直接集成了 Java 8 的函数式 API，特别是 CompletableFuture、Stream 和 Duration。截至 2026 年 4 月，Reactor 的最新版本是 3.8.4，于 2026 年 3 月 10 日发布(2)。

Reactor 的设计目标是解决 JVM 上 “经典” 异步方法的缺陷，同时专注于几个关键方面：组合性和可读性、丰富的操作符集合、惰性执行模型以及强大的背压管理机制。作为 Spring 生态系统中反应式编程栈的基础，Reactor 在 Spring WebFlux、Spring Data、Spring Cloud Gateway 等项目中发挥着核心作用(47)。

1.2 反应式编程基础概念

反应式编程是一种关注数据流和变化传播的异步编程范式。与传统的命令式编程不同，反应式编程允许轻松表达静态（如数组）或动态（如事件发射器）数据流。

在反应式编程模型中，核心概念是Publisher-Subscriber模式，这与熟悉的 Iterator 设计模式有对偶关系。主要区别在于：Iterator 是拉取式的，而反应式流是推送式的。在反应式流中，是 Publisher 主动通知 Subscriber 新值的到来，这种推送特性是实现反应式的关键。

反应式流的另一个重要概念是背压（Backpressure）。当生产者（Publisher）产生数据的速度超过消费者（Subscriber）的处理能力时，可能导致内存溢出或系统崩溃。背压机制通过反馈信号让下游能够向上游传达自己的处理能力，从而实现流量控制(98)。

1.3 Reactor 与其他反应式库的对比

在 Java 生态系统中，主要有两个反应式编程库：Reactor和RxJava。它们在概念上非常相似，但在某些方面存在重要差异：

类型系统：RxJava 使用 Observable 和 Single，而 Reactor 使用 Flux 和 Mono(40)

设计目标：Reactor 更紧密地集成 Spring 生态系统，专为服务器端 Java 设计；RxJava 历史更悠久，包括 Android 开发(41)

规范遵循：Reactor 诞生在反应式流规范制定之后，从一开始就严格按照 Reactive Streams 规范设计；RxJava 2.x 才开始支持 Reactive Streams 规范(52)

性能表现：根据基准测试，RxJava 在某些场景下性能略优于 Reactor，但 Reactor 在与 Spring 生态系统集成时表现更好(59)

其他相关技术包括Vert.x（多语言响应式工具包 / 框架）和Akka Streams（基于 Actor 模型的流处理），它们各有特点但应用场景不同(53)。

二、Flux 和 Mono 的设计哲学与核心特性

2.1 Flux 类：0 到 N 个元素的异步序列

Flux是 Reactor 中表示 0 到 N 个元素异步序列的核心类。它实现了 Publisher 接口，能够发出三种类型的信号：元素值（onNext）、完成信号（onComplete）和错误信号（onError）。

Flux 的设计哲学体现在以下几个方面：

1. 无限可能性：Flux 可以表示空序列、有限序列或无限序列。例如，Flux.empty () 表示空序列，Flux.range (1, 10) 表示包含 10 个元素的有限序列，而 Flux.interval (Duration.ofSeconds (1)) 表示每秒发出一个递增数字的无限序列。

2. 丰富的操作符支持：Flux 提供了超过 150 个组合式操作符，形成链式、声明式的数据处理管道。包括 map ()/flatMap () 用于同步 / 异步转换，filter () 用于谓词筛选，take (n)/skip (n) 用于控制窗口大小，reduce ()/collectList () 用于聚合等(64)。

3. 背压管理：作为 Reactive Streams 规范的实现，Flux 内置支持背压机制。通过 limitRate ()、onBackpressureBuffer () 等操作符，可以精确控制数据流量(181)。

4. 冷流特性：默认情况下，Flux 是冷流（Cold Sequence），即每个订阅者都会触发新的数据生成。例如，如果源是 HTTP 调用，每个订阅者都会触发新的网络请求。

2.2 Mono 类：0 或 1 个元素的异步结果

Mono是 Reactor 中表示最多一个元素（0 或 1 个）异步结果的特殊类。它同样实现了 Publisher 接口，但行为与 Flux 有本质区别：

1. 单一性保证：Mono 最多只能发出一个 onNext 信号，然后必须跟随 onComplete 信号，或者直接发出 onError 信号。Mono.never () 是唯一的例外，它不发出任何信号。

2. 语义清晰：Mono 的设计反映了对异步处理基数的语义理解。例如，HTTP 请求只产生一个响应，因此将其结果表示为 Mono比 Flux更有意义，因为它只提供与零个或一个元素上下文相关的操作符。

3. 操作符精简：Mono 只提供了 Flux 操作符的一个子集，某些操作符（特别是那些将 Mono 与另一个 Publisher 组合的操作符）会切换到 Flux。例如，Mono.concatWith (Publisher) 返回 Flux，而 Mono.then (Mono) 返回另一个 Mono。

4. 延迟执行：Mono 可以用于表示没有值的异步过程，只包含完成概念（类似于 Runnable）。可以使用 empty Mono来创建这种类型。

2.3 设计哲学：为何选择双轨制设计

Reactor 选择 Flux 和 Mono 双轨制设计而非统一类型，主要基于以下考虑：

1. 语义表达能力：这种区分将语义信息带入类型系统，明确指示异步处理的大致基数。这有助于在编译时发现潜在问题，例如对 Mono 执行 count 操作是没有意义的。

2. 操作符安全性：不同基数的处理需要不同的操作符集合。Mono 只提供与 0 或 1 个元素相关的操作符，避免了不相关操作符的出现，提高了代码的安全性和可读性。

3. 性能优化：针对不同基数的优化策略不同。Mono 的实现可以针对单一结果进行优化，而不需要处理 Flux 的复杂情况，如背压管理、多元素聚合等(11)。

4. 使用场景匹配：在实际应用中，许多操作天然就是产生单一结果的（如数据库单行查询、HTTP 请求等），使用 Mono 更符合直觉；而有些操作天然就是产生多个结果的（如流式数据、事件流等），使用 Flux 更合适(11)。

2.4 核心特性对比分析

特性	Flux	Mono
元素数量	0 到 N 个（N≥0）	0 或 1 个
完成信号	可选（无限序列无完成信号）	必须有（在 onNext 后或直接）
错误信号	可选（可以不发生错误）	可选（可以成功完成）
操作符数量	超过 150 个	约 50 个（Flux 的子集）
背压支持	内置支持	无背压概念（只有一个元素）
冷 / 热流	默认冷流	默认冷流
转换能力	可转换为 Mono（如 count ()）	可转换为 Flux（如 fluxWith ()）

这种设计使得 Reactor 能够灵活应对各种异步场景，同时保持类型安全和性能优化。

三、Flux 和 Mono 在 AI 智能体框架中的应用场景

3.1 AI 智能体框架中的数据流特征

在 AI 智能体框架中，数据流呈现出多样化的特征，这些特征正好与 Flux 和 Mono 的设计理念高度契合：

1. 连续感知流：智能体与环境的交互通常产生连续的观察流。例如，机器人的传感器数据、游戏智能体的视觉输入、对话系统的用户输入流等，这些都可以自然地表示为 Flux。

2. 单次决策输出：智能体的决策过程通常产生单次或空的动作输出。例如，在每个时间步决定下一步行动、回答用户问题、执行工具调用等，这些适合用 Mono 表示(34)。

3. 多智能体协作流：在多智能体系统中，智能体之间需要交换消息和协调行动。每个智能体可以看作是一个数据流节点，接收其他智能体的消息流（Flux）并产生响应（Mono 或 Flux）(146)。

4. 事件驱动架构：AI 智能体系统通常采用事件驱动架构，包括外部事件（如用户交互、传感器触发）和内部事件（如状态变化、决策完成）。这些事件流可以用 Flux 表示(170)。

3.2 典型应用场景详解

3.2.1 环境感知与状态更新

在智能体的环境感知系统中，传感器数据通常以流的形式持续产生。例如：

场景描述：自动驾驶车辆的感知系统需要处理来自激光雷达、摄像头、毫米波雷达等多种传感器的数据流。

Flux 应用：

• 激光雷达数据：Flux，表示连续的点云数据

• 摄像头视频流：Flux，表示连续的图像帧

• 传感器融合结果：Flux，表示融合后的环境状态

代码示例：

// 模拟激光雷达数据生成

Flux<PointCloud> lidarStream = Flux.interval(Duration.ofMillis(100))
.map(tick -> generatePointCloud());

// 模拟摄像头视频流

Flux<ImageFrame> cameraStream = Flux.interval(Duration.ofMillis(33))

.map(tick -> captureImageFrame());

// 传感器融合（使用combineLatest）

Flux<EnvironmentState> fusedStream = Flux.combineLatest(

lidarStream,

cameraStream,

(lidar, camera) -> new EnvironmentState(lidar, camera)

);

3.2.2 决策推理与动作执行

智能体的决策过程通常是一个从感知到动作的转换过程：

场景描述：游戏智能体需要根据当前游戏状态做出下一步行动决策。

Mono 应用：

• 当前状态评估：Mono

• 动作选择：Mono

• 工具调用结果：Mono

代码示例：

// 评估当前游戏状态

Mono<GameStateEvaluation> evaluateState(GameState state) {

return Mono.fromCallable(() -> {

    // 复杂的状态评估逻辑

    return new GameStateEvaluation(state);

});

}

// 根据评估结果选择动作

Mono<Action> chooseAction(GameStateEvaluation evaluation) {

return Mono.fromCallable(() -> {

    // 决策逻辑

    return evaluation.isSafe() ? Action.MOVE : Action.STOP;

});

}

// 执行动作（可能调用外部工具）

Mono<ToolResult> executeAction(Action action) {

return Mono.fromCallable(() -> {

    // 执行动作并返回结果

    return new ToolResult("Action executed: " + action);

});

}

// 完整的决策链

Mono<ToolResult> decisionChain(GameState initialState) {

return evaluateState(initialState)

    .flatMap(this::chooseAction)

    .flatMap(this::executeAction);

}

3.2.3 多智能体通信与协调

在多智能体系统中，智能体之间需要通过消息进行通信和协调：

场景描述：一个多智能体协作系统，包括任务分配、进度跟踪和结果汇总。

Flux 和 Mono 结合应用：

• 接收消息流：Flux

• 处理消息：Mono

• 广播通知：Flux

代码示例（基于阿里 AgentScope Java 框架）：

// 消息中心（MsgHub）实现

public class MsgHub {

private final FluxProcessor\<Message> messageProcessor =

    FluxProcessor.create(FluxSink.OverflowStrategy.BUFFER);

  

// 发布消息

public Mono<Void> publish(Message message) {

    return Mono.fromRunnable(() ->

        messageProcessor.onNext(message)

    );

}

  

// 按智能体ID订阅消息

public Flux<Message> subscribe(String agentId) {

    return messageProcessor

        .filter(msg -> msg.getTargetAgentId().equals(agentId));

}

}

// 智能体示例

public class WorkerAgent {

private final String id;

private final MsgHub msgHub;

  

public WorkerAgent(String id, MsgHub msgHub) {

    this.id = id;

    this.msgHub = msgHub;

}

  

// 启动智能体，开始处理消息

public void start() {

    msgHub.subscribe(id)

        .flatMap(this::processMessage)

        .subscribe();

}

  

// 处理消息（返回处理结果）

private Mono<Response> processMessage(Message msg) {

    return Mono.fromCallable(() -> {

        // 处理消息逻辑

        return new Response("Processed: " + msg.getContent());

    });

}

}

3.2.4 实时学习与模型更新

AI 智能体系统中的学习过程通常涉及持续的数据流和间歇性的模型更新：

场景描述：强化学习智能体需要从环境中获取连续的奖励流，并定期更新策略模型。

Flux 和 Mono 结合应用：

• 奖励流：Flux

• 模型更新：Mono

• 训练过程：Flux

代码示例：

// 模拟奖励流（来自环境）

Flux<Reward> rewardStream = Flux.interval(Duration.ofSeconds(1))

.map(tick -> new Reward(Math.random() \* 10));

// 策略模型（简化表示）

class PolicyModel {

private double value;

  

public void update(double reward) {

    value = value \* 0.9 + reward \* 0.1;

}

  

public double getValue() {

    return value;

}

}

// 模型更新器

class ModelUpdater {

private final PolicyModel model = new PolicyModel();

  

// 处理奖励流，定期更新模型

public Flux<TrainingProgress> processRewards(Flux<Reward> rewards) {

    return rewards

        .buffer(Duration.ofSeconds(10)) // 每10秒聚合一次奖励

        .flatMap(rewardList -> updateModel(rewardList));

}

  

// 批量更新模型

private Mono<TrainingProgress> updateModel(List<Reward> rewards) {

    return Mono.fromCallable(() -> {

        double avgReward = rewards.stream()

            .mapToDouble(Reward::getValue)

            .average()

            .orElse(0);

       

        model.update(avgReward);

       

        return new TrainingProgress(

            model.getValue(),

            avgReward,

            rewards.size()

        );

    });

}

}

// 使用示例

ModelUpdater updater = new ModelUpdater();

Flux<TrainingProgress> trainingProgress = updater.processRewards(rewardStream);

trainingProgress.subscribe(progress ->

System.out.println("Model value: " + progress.getModelValue() +

    ", Average reward: " + progress.getAvgReward())

);

3.3 与 ReAct 模式的结合应用

ReAct（Reasoning and Acting）模式是一种将推理与行动相结合的 AI 智能体设计范式，它与 Reactor 框架的数据流模型高度契合：

ReAct 核心流程：

1. 思考（Thought）：智能体分析当前状态，生成推理过程

2. 行动（Action）：根据推理结果执行工具调用或其他动作

3. 观察（Observation）：获取行动结果，更新状态

在 Reactor 中的实现：

// ReAct智能体核心逻辑

public class ReActAgent {

private final MsgHub msgHub;

  

public ReActAgent(MsgHub msgHub) {

    this.msgHub = msgHub;

}

  

// 处理用户查询（返回最终答案）

public Mono<String> processQuery(String query) {

    return Mono.defer(() -> {

        // 初始思考：分析查询

        String initialThought = "I need to answer: " + query;

       

        // 开始ReAct循环

        return reactLoop(initialThought, query, 0);

    });

}

  

// ReAct循环（递归实现）

private Mono<String> reactLoop(String thought, String query, int iteration) {

    if (iteration >= 5) { // 限制最大迭代次数

        return Mono.just("Max iterations reached. Final answer: " + thought);

    }

   

    // 1. 思考阶段：分析当前状态

    Mono<ActionPlan> think = Mono.fromCallable(() -> {

        System.out.println("Thinking: " + thought);

        return new ActionPlan("tool", "param"); // 简化的行动计划

    });

   

    // 2. 行动阶段：执行工具调用

    Mono<ToolResult> act = think.flatMap(plan -> {

        System.out.println("Acting: " + plan);

        return Mono.just(new ToolResult("tool result")); // 模拟工具结果

    });

   

    // 3. 观察阶段：处理结果并决定下一步

    return act.flatMap(result -> {

        String newThought = thought + " -> " + result.getResult();

        System.out.println("Observation: " + newThought);

       

        // 判断是否需要继续循环

        if (result.isFinal()) {

            return Mono.just(newThought);

        } else {

            return reactLoop(newThought, query, iteration + 1);

        }

    });

}

}

这种结合使得智能体能够：

• 灵活应对复杂任务：通过思考 - 行动 - 观察循环，智能体可以逐步逼近答案

• 支持流式处理：思考过程可以实时反馈给用户，提供更好的交互体验

• 错误恢复能力：通过 Mono 的错误处理机制，可以优雅地处理工具调用失败

• 并发处理：多个智能体可以并行处理不同的任务，通过消息中心协调

四、学习路径规划与实践项目

4.1 学习阶段划分与时间安排

基于你的技术背景（Java）和学习目标，我建议采用渐进式学习路径，总学习时长约为 12 周：

4.1.1 第一阶段：基础准备（2 周）

目标：掌握 Java 函数式编程基础和异步编程概念

学习内容：

1. Java 8 + 函数式接口（Predicate、Function、Consumer 等）

2. Lambda 表达式和方法引用

3. Stream API 基础

4. CompletableFuture 异步编程

5. 反应式编程基本概念

学习资源：

• 《Java 8 实战》（书籍）

• Oracle 官方 Java 文档

• 在线编程练习平台（如 LeetCode 函数式编程专题）

每周安排：

• 第 1 周：函数式编程基础（每天 2 小时）

• 第 2 周：CompletableFuture 和异步编程（每天 2 小时）

4.1.2 第二阶段：Reactor 核心概念（3 周）

目标：深入理解 Flux 和 Mono 的核心概念和基本用法

学习内容：

1. Reactor 架构概览和设计哲学

2. Flux 和 Mono 的创建方式

3. 基本操作符（map、filter、flatMap 等）

4. 订阅机制和线程模型

5. 错误处理策略

学习资源：

• Reactor 官方文档（3.8.3 版本）(1)

• 《Reactive Programming with Reactor》（书籍）

• Spring 官方教程

每周安排：

• 第 3 周：Flux 和 Mono 基础（每天 2.5 小时）

• 第 4 周：操作符深入（每天 2.5 小时）

• 第 5 周：订阅和错误处理（每天 2.5 小时）

4.1.3 第三阶段：高级特性（3 周）

目标：掌握 Reactor 的高级特性和最佳实践

学习内容：

1. 背压机制和流量控制

2. 高级操作符（zip、combineLatest、reduce 等）

3. 线程调度和并发模型

4. Sinks API 和热流管理

5. 性能优化策略

学习资源：

• Reactor 核心源码分析

• 相关技术博客和论文

• 性能基准测试报告

每周安排：

• 第 6 周：背压和高级操作符（每天 2.5 小时）

• 第 7 周：线程模型和 Sinks（每天 2.5 小时）

• 第 8 周：性能优化和最佳实践（每天 2.5 小时）

4.1.4 第四阶段：AI 智能体应用（4 周）

目标：在 AI 智能体框架中熟练应用 Reactor

学习内容：

1. AI 智能体架构基础

2. ReAct 模式原理和实现

3. 多智能体通信机制

4. 实时数据流处理

5. 与机器学习框架集成

学习资源：

• 阿里 AgentScope Java 框架文档

• 相关 AI 论文和技术报告

• 开源项目示例

每周安排：

• 第 9 周：AI 智能体基础架构（每天 3 小时）

• 第 10 周：ReAct 模式实现（每天 3 小时）

• 第 11 周：多智能体系统（每天 3 小时）

• 第 12 周：综合项目实践（每天 3 小时）

4.2 推荐学习资源

4.2.1 官方文档与教程

1. Reactor 官方文档(1)

• 地址：https://projectreactor.io/docs/core/3.8.3/reference/

• 内容：全面的 API 参考、概念解释和示例代码

• 特点：权威、详细、最新版本

1. Spring 官方教程

• 地址：https://spring.io/guides/gs/reactive-rest-service/

• 内容：Spring WebFlux 与 Reactor 结合的实战教程

• 特点：结合 Spring 生态，实用性强

1. Reactor Core Javadoc

• 地址：https://projectreactor.io/docs/core/release/api/

• 内容：完整的 API 文档

• 特点：适合查阅具体方法

4.2.2 书籍推荐

1. 《Reactive Programming with Reactor》

• 作者：Marc de Verdelhan

• 特点：系统介绍 Reactor 的理论和实践

• 适合：中高级学习者

1. 《Java 9 Modularity》（包含反应式流章节）

• 作者：Sander Mak, Paul Bakker

• 特点：深入介绍 Java 9 的 Flow API

• 适合：想了解底层原理的学习者

1. 《Reactive Streams in Java》

• 作者：Adam Davis

• 特点：专门介绍反应式流规范

• 适合：理论基础学习

4.2.3 在线课程与视频

1. Pluralsight 课程

• “Reactive Programming with Spring Boot 2 and Project Reactor”

• “Mastering Reactive Programming with Project Reactor”

1. Spring 官方视频

• 地址：https://spring.io/videos/

• 内容：Spring 相关技术的官方视频教程

1. Conference Talks

• 关注 Spring One、QCon 等会议的反应式编程主题

4.2.4 实战项目与示例

1. 官方示例

• 地址：https://github.com/reactor/reactor-core/tree/main/examples

• 内容：各种 Reactor 使用示例

1. Spring PetClinic Reactive

• 地址：https://github.com/spring-projects/spring-petclinic-react

• 内容：使用 Reactor 的反应式宠物诊所应用

1. AI 智能体相关项目

• 阿里 AgentScope Java：https://github.com/agentscope-ai/agentscope-java

• 微软 Reactive Agents：https://github.com/microsoft/reactive-agents

4.3 实践项目建议

4.3.1 基础项目：反应式数据处理管道

项目目标：通过简单的数据处理任务掌握 Reactor 的基本用法

项目描述：

创建一个模拟的传感器数据处理系统，包含以下功能：

1. 生成模拟的传感器数据流（温度、湿度、压力）

2. 对数据进行实时处理和过滤

3. 计算统计信息（平均值、最大值、最小值）

4. 将处理结果输出到控制台或文件

技术要求：

• 使用 Flux 表示传感器数据流

• 使用各种操作符进行数据转换和过滤

• 实现背压处理机制

• 使用 Sinks API 创建热流

预期成果：

• 能够处理 1000+ TPS 的数据流

• 支持多种数据处理策略

• 具备基本的监控和统计功能

4.3.2 中级项目：智能聊天机器人

项目目标：在对话系统中应用 Reactor，理解请求 - 响应模式

项目描述：

构建一个简单的智能聊天机器人，具备以下功能：

1. 接收用户输入流（Flux）

2. 使用 Mono 表示单次对话处理

3. 实现简单的对话逻辑（问答、多轮对话）

4. 支持自然语言处理（可调用外部 API）

技术要求：

• 使用 Reactor 处理异步对话流程

• 实现对话状态管理

• 支持并发处理多个用户

• 集成简单的 NLP 功能

预期成果：

• 支持 100 + 并发用户

• 对话响应时间 < 1 秒

• 具备基本的上下文理解能力

4.3.3 高级项目：多智能体协作系统

项目目标：在复杂的多智能体系统中熟练运用 Reactor

项目描述：

基于 ReAct 模式构建一个多智能体协作系统，实现以下功能：

1. 任务分配智能体：接收任务请求，分配给合适的工作智能体

2. 工作智能体：执行具体任务，可能需要调用外部工具

3. 监控智能体：实时监控系统状态，处理异常情况

4. 消息中心：支持智能体间的可靠通信

技术要求：

• 基于 ReAct 模式实现推理 - 行动循环

• 使用消息中心（MsgHub）实现智能体间通信

• 支持任务优先级和调度

• 实现容错和恢复机制

预期成果：

• 支持 10 个以上智能体并发工作

• 任务处理成功率 > 99%

• 具备可扩展性和可维护性

4.3.4 创新项目：AI 驱动的实时决策系统

项目目标：将 Reactor 与机器学习框架结合，实现智能决策

项目描述：

构建一个基于强化学习的实时决策系统，应用场景可以是：

1. 智能投资决策系统

2. 游戏 AI bot

3. 工业生产优化系统

技术要求：

• 集成机器学习框架（如 TensorFlow、PyTorch）

• 使用 Reactor 处理实时数据流

• 实现在线学习和模型更新

• 支持 A/B 测试和性能评估

预期成果：

• 能够在实际环境中部署运行

• 决策准确率达到业务要求

• 具备自适应性和学习能力

五、核心操作符详解与最佳实践

5.1 基础操作符：创建、转换与过滤

5.1.1 创建操作符

Flux 创建方式：

1. just()：从固定元素创建 Flux

Flux<String> flux1 = Flux.just("a", "b", "c");

Flux<Integer> flux2 = Flux.just(1, 2, 3, 4, 5);

1. fromIterable()：从集合创建 Flux

List<String> list = Arrays.asList("apple", "banana", "cherry");

Flux<String> flux = Flux.fromIterable(list);

1. range()：创建整数序列

Flux<Integer> flux = Flux.range(1, 10); // 1到10的整数

1. interval()：创建定时序列

Flux<Long> flux = Flux.interval(Duration.ofSeconds(1)); // 每秒一个递增数字

1. generate()：通过回调生成序列

Flux<String> flux = Flux.generate(

() -> 0, // 初始状态

(state, sink) -> {

    sink.next("value-" + state);

    if (state == 9) sink.complete();

    return state + 1;

}

);

Mono 创建方式：

1. just()：创建包含单个元素的 Mono

Mono<String> mono = Mono.just("hello reactor");

1. empty()：创建空 Mono

Mono<String> mono = Mono.empty();

1. fromCallable()：从 Supplier 创建 Mono

Mono<String> mono = Mono.fromCallable(() -> "computed value");

1. fromFuture()：从 CompletableFuture 创建 Mono

CompletableFuture\<String> future = CompletableFuture.supplyAsync(() -> "async value");

Mono<String> mono = Mono.fromFuture(future);

5.1.2 转换操作符

map()：一对一同步转换

Flux<Integer> flux = Flux.just(1, 2, 3)

.map(x -> x \* 2); // 输出：2, 4, 6

flatMap()：一对多异步转换

Flux<String> flux = Flux.just("a", "b")

.flatMap(s -> Flux.just(s.toUpperCase(), s + s)); // 输出：A, aa, B, bb

concatMap()：保持顺序的 flatMap

Flux<String> flux = Flux.just(1, 2, 3)

.concatMap(i -> Flux.just("item-" + i).delayElements(Duration.ofMillis(100)));

cast()：类型转换

Flux<Object> flux = Flux.just("1", "2", "3");

Flux<Integer> intFlux = flux.cast(Integer.class);

5.1.3 过滤操作符

filter()：按条件过滤元素

Flux<Integer> flux = Flux.range(1, 10)

.filter(x -> x % 2 == 0); // 只保留偶数

distinct()：去重

Flux<Integer> flux = Flux.just(1, 2, 2, 3, 3, 3)

.distinct(); // 输出：1, 2, 3

take()/takeLast()：取前 N 个或后 N 个元素

Flux<Integer> flux = Flux.range(1, 10)

.take(3); // 取前3个元素：1, 2, 3

skip()/skipLast()：跳过前 N 个或后 N 个元素

Flux<Integer> flux = Flux.range(1, 10)

.skip(3); // 跳过前3个元素：4, 5, 6, 7, 8, 9, 10

5.2 高级操作符：组合、聚合与窗口

5.2.1 组合操作符

zip()：按位置配对合并

Flux<String> letters = Flux.just("A", "B", "C");

Flux<Integer> numbers = Flux.just(1, 2, 3);

Flux<Tuple2\<String, Integer>> flux = Flux.zip(letters, numbers);

// 输出：(A,1), (B,2), (C,3)

combineLatest()：合并最新元素

Flux<Integer> flux1 = Flux.interval(Duration.ofSeconds(1)).take(3);

Flux<Integer> flux2 = Flux.interval(Duration.ofSeconds(2)).take(3);

Flux<Tuple2\<Integer, Integer>> flux = Flux.combineLatest(flux1, flux2);

// 输出：(0,0), (1,0), (1,1), (2,1), (2,2)

merge()：合并多个流

Flux<String> flux1 = Flux.just("a", "b", "c");

Flux<String> flux2 = Flux.just("1", "2", "3");

Flux<String> merged = Flux.merge(flux1, flux2);

// 可能的输出：a, 1, b, 2, c, 3（顺序不确定）

concat()：按顺序连接

Flux<String> flux = Flux.concat(flux1, flux2);

// 输出：a, b, c, 1, 2, 3（保持顺序）

5.2.2 聚合操作符

reduce()：累积计算

Mono<Integer> mono = Flux.range(1, 10)

.reduce((acc, x) -> acc + x); // 计算1到10的和

collectList()：收集所有元素到 List

Mono<List<Integer>> mono = Flux.range(1, 10)

.collectList();

count()：计算元素个数

Mono<Long> mono = Flux.just(1, 2, 3, 4, 5)

.count(); // 输出：5

max()/min()：求最大值 / 最小值

Mono<Integer> mono = Flux.just(3, 1, 4, 1, 5)

.max(); // 输出：5

5.2.3 窗口操作符

window()：创建窗口流

Flux<Flux<Integer>> windowFlux = Flux.range(1, 10)

.window(3); // 每3个元素一个窗口

buffer()：创建缓冲区

Flux<List<Integer>> bufferFlux = Flux.range(1, 10)

.buffer(3); // 每3个元素一个列表

groupBy()：按条件分组

Flux<GroupedFlux<String, Integer>> groupedFlux = Flux.just(1, 2, 3, 4, 5)

.groupBy(x -> x % 2 == 0 ? "even" : "odd");

5.3 线程调度与并发模型

5.3.1 线程调度基础

Reactor 的线程模型基于Scheduler抽象，提供了多种调度策略：

1. Schedulers.immediate()：当前线程直接执行

2. Schedulers.single()：单线程顺序执行

3. Schedulers.elastic()：弹性线程池（默认）

4. Schedulers.parallel()：并行线程池（CPU 核心数）

5. Schedulers.boundedElastic()：有界弹性线程池

5.3.2 subscribeOn vs publishOn

subscribeOn()：改变订阅过程的执行线程

Flux<Integer> flux = Flux.range(1, 10)

.subscribeOn(Schedulers.parallel()); // 整个流在并行线程池执行

publishOn()：改变后续操作的执行线程

Flux<Integer> flux = Flux.range(1, 10)

.publishOn(Schedulers.elastic()) // 后续操作在弹性线程池

.map(x -> x \* 2);

关键区别：

• subscribeOn ()：影响整个流的订阅过程，通常只在数据源附近使用一次

• publishOn ()：可以多次使用，每次都会切换后续操作的线程

5.3.3 并发处理策略

1. 并行处理：使用 parallel () 操作符

ParallelFlux<Integer> parallelFlux = Flux.range(1, 1000)

.parallel(4); // 使用4个并行线程

Flux<Integer> result = parallelFlux

.runOn(Schedulers.parallel())

.map(x -> x \* 2)

.sequential(); // 合并结果

1. 异步边界处理：在阻塞操作前后切换线程

Flux<String> flux = Flux.just("file1.txt", "file2.txt", "file3.txt")

.publishOn(Schedulers.boundedElastic()) // 切换到IO线程

.map(this::readFile) // 阻塞文件读取

.publishOn(Schedulers.parallel()) // 切换回计算线程

.map(this::processData); // 非阻塞处理

5.4 错误处理与恢复策略

5.4.1 基本错误处理

onErrorReturn()：错误时返回默认值

Flux<Integer> flux = Flux.just(1, 2, 0, 3)

.map(x -> 10 / x)

.onErrorReturn(-1); // 除零错误时返回-1

onErrorResume()：错误时提供备用流

Flux<Integer> flux = Flux.just("a", "b", "c")

.map(x -> Integer.parseInt(x))

.onErrorResume(e -> Flux.just(0)); // 转换失败时返回0

onErrorMap()：错误类型转换

Flux<Integer> flux = Flux.just("1", "a", "2")

.map(x -> {

    try {

        return Integer.parseInt(x);

    } catch (NumberFormatException e) {

        throw new MyCustomException("Invalid number: " + x, e);

    }

});

5.4.2 高级恢复策略

retry()：重试机制

Flux<Integer> flux = remoteServiceCall()

.retry(3); // 最多重试3次

retryWhen()：带条件的重试

Flux<Integer> flux = remoteServiceCall()

.retryWhen(Retry.backoff(3, Duration.ofSeconds(1))

    .filter(e -> e instanceof TransientException)); // 只重试临时错误

doOnError()：错误日志记录

Flux<Integer> flux = Flux.just(1, 2, 0, 3)

.map(x -> 10 / x)

.doOnError(e -> log.error("Division error: {}", e.getMessage()))

.onErrorReturn(-1);

5.4.3 背压处理策略

Reactor 提供了多种背压策略：

1. BUFFER：使用缓冲区存储未处理的数据

Flux<Integer> flux = Flux.create(sink -> {

for (int i = 0; i < 1000; i++) {

    sink.next(i);

}

sink.complete();

}, FluxSink.OverflowStrategy.BUFFER);

1. DROP：丢弃无法处理的数据

Flux<Integer> flux = Flux.interval(Duration.ofMillis(1))

.onBackpressureDrop();

1. LATEST：只保留最新数据

Flux<Integer> flux = Flux.interval(Duration.ofMillis(1))

.onBackpressureLatest();

1. ERROR：背压超限时抛出异常

Flux<Integer> flux = Flux.create(sink -> {

for (int i = 0; i < 1000; i++) {

    sink.next(i);

}

sink.complete();

}, FluxSink.OverflowStrategy.ERROR);

5.5 Sinks API 与热流管理

5.5.1 Sinks API 概述

Sinks 是 Reactor 3.4 引入的新 API，用于编程式创建响应式流，解决了传统 Processor 类的线程安全问题(130)。

主要类型：

1. Sinks.one()：单值发射器（对应 Mono）

2. Sinks.many()：多值发射器（对应 Flux）

5.5.2 创建热流

使用 Sinks 创建热流示例：

// 创建一个热流，所有订阅者共享相同的数据

Sinks.Many\<String> sink = Sinks.many().multicast().onBackpressureBuffer();

Flux<String> hotFlux = sink.asFlux();

// 多个订阅者

hotFlux.subscribe(data -> System.out.println("Subscriber 1: " + data));

hotFlux.subscribe(data -> System.out.println("Subscriber 2: " + data));

// 发射数据

sink.tryEmitNext("Hello");

sink.tryEmitNext("World");

// 输出：

// Subscriber 1: Hello

// Subscriber 2: Hello

// Subscriber 1: World

// Subscriber 2: World

5.5.3 冷流转热流

使用 **share ()或publish ()** 操作符可以将冷流转为热流：

Flux<String> coldFlux = Flux.just("a", "b", "c");

Flux<String> hotFlux = coldFlux.share(); // 共享订阅

// 订阅时不会重新执行coldFlux的数据源

hotFlux.subscribe();

hotFlux.subscribe();

5.6 性能优化最佳实践

5.6.1 操作符优化

1. 避免不必要的操作符：减少操作符链的长度

2. 使用合适的操作符：map vs flatMap，根据需求选择

3. 批处理优化：使用 buffer () 或 window () 进行批处理

4. 缓存策略：对重复使用的流使用 cache () 或 replay ()

5.6.2 线程模型优化

1. 线程池配置：

• 计算密集型：使用 Schedulers.parallel ()，线程数 = CPU 核心数

• IO 密集型：使用 Schedulers.boundedElastic ()，设置合理的最大线程数

• 定时任务：使用 Schedulers.single () 避免线程竞争

1. 减少线程切换：

• 在数据源附近使用 subscribeOn ()

• 合理使用 publishOn ()，避免不必要的线程切换

• 使用 runOn () 为并行流指定线程池

5.6.3 内存管理

1. 背压策略选择：

• 关键数据：使用 BUFFER 策略

• 实时数据：使用 LATEST 策略

• 可丢弃数据：使用 DROP 策略

1. 对象池：对于频繁创建的对象，使用对象池技术

2. 引用管理：及时释放不再使用的资源

5.6.4 监控与调优

1. 关键指标监控：

• 吞吐量（TPS）

• 延迟（Latency）

• 错误率

• 线程池状态

• 内存使用情况

1. 性能调优工具：

• 使用 StepVerifier 进行单元测试

• 使用 HdrHistogram 进行延迟分析

• 使用 Micrometer 进行指标收集

• 使用 VisualVM 进行性能分析

六、常见问题与解决方案

6.1 学习曲线与理解难点

6.1.1 从命令式到反应式思维转换

常见问题：

许多开发者在学习 Reactor 时遇到的最大困难是思维模式的转换。从传统的命令式编程（一步一步执行）转向声明式的数据流处理需要时间适应。

解决方案：

1. 渐进式学习：从简单的例子开始，逐步增加复杂度

2. 可视化工具：使用 marble diagrams 理解数据流

3. 对比练习：将同一个问题分别用命令式和反应式实现，对比差异

4. 实践项目：通过实际项目强制使用反应式思维

6.1.2 操作符选择困难

常见问题：

Reactor 提供了大量操作符（超过 150 个），选择合适的操作符完成特定任务是一个挑战。

解决方案：

1. 分类学习：将操作符按功能分类（创建、转换、过滤、组合等）

2. 使用场景记忆：记住每个操作符的典型使用场景

3. API 文档：经常查阅官方文档和 Javadoc

4. 练习总结：通过练习总结操作符的使用规律

6.1.3 线程模型理解困难

常见问题：

subscribeOn () 和 publishOn () 的区别，以及如何正确使用 Scheduler 是学习中的难点。

解决方案：

1. 理解执行顺序：订阅时从下往上建立订阅链

2. 记住原则：subscribeOn () 只在数据源附近使用一次，publishOn () 可多次使用

3. 实践验证：通过打印线程名验证线程模型

4. 参考示例：学习优秀的开源项目中的线程使用方式

6.2 开发实践中的常见陷阱

6.2.1 阻塞操作导致性能问题

问题描述：

在反应式代码中意外使用了阻塞操作（如 Thread.sleep ()、同步 I/O），导致线程池被占用，系统性能下降。

解决方案：

1. 使用异步版本：优先使用异步 API（如 R2DBC 而非 JDBC）

2. 线程隔离：在阻塞操作前后使用 publishOn () 切换到专用线程池

3. 替代方案：使用 delayElements () 替代 Thread.sleep ()

4. 监控工具：使用 BlockHound 检测阻塞操作

6.2.2 背压处理不当导致内存溢出

问题描述：

当上游产生数据过快而下游处理过慢时，未正确处理背压会导致内存溢出。

解决方案：

1. 明确背压策略：根据业务需求选择合适的背压策略（BUFFER/DROP/LATEST/ERROR）

2. 使用 limitRate ()：对高速数据流使用 limitRate () 进行限流

3. 监控背压：使用 doOnRequest () 监控请求量

4. 合理配置：根据系统资源配置缓冲区大小

6.2.3 错误处理不完整导致程序崩溃

问题描述：

未正确处理所有可能的异常，导致流终止或程序崩溃。

解决方案：

1. 全面的错误处理：在每个可能出错的操作后添加错误处理

2. 错误分类：区分可恢复错误和不可恢复错误

3. 重试策略：对临时错误使用 retry () 或 retryWhen ()

4. 兜底策略：使用 onErrorReturn () 或 onErrorResume () 提供默认值

6.2.4 冷流与热流混淆导致逻辑错误

问题描述：

错误地将冷流当作热流使用，导致每个订阅者都触发重复的操作（如多次调用数据库或 API）。

解决方案：

1. 理解概念：明确冷流（每个订阅者重新执行）和热流（共享执行）的区别

2. 正确使用操作符：使用 share ()、publish () 或 replay () 将冷流转为热流

3. 数据源控制：对昂贵的操作（如数据库查询）使用 cache ()

4. 日志验证：通过日志验证流的执行次数

6.3 性能调优与监控建议

6.3.1 性能瓶颈分析

分析方法：

1. 指标监控：

• 使用 Micrometer 收集关键指标

• 监控线程池使用情况

• 跟踪操作符执行时间

1. 延迟分析：

• 使用 HdrHistogram 记录延迟分布

• 找出延迟高的操作符

• 分析是否存在阻塞操作

1. 内存分析：

• 使用内存分析工具（如 Eclipse Memory Analyzer）

• 检查是否有内存泄漏

• 分析对象创建和销毁模式

6.3.2 优化策略总结

1. 操作符优化：

• 减少操作符链长度

• 使用批处理操作符（buffer、window）

• 避免不必要的中间操作

1. 线程优化：

• 合理配置线程池大小

• 减少线程切换次数

• 使用合适的 Scheduler 实现

1. 数据结构优化：

• 使用更高效的数据结构

• 减少对象创建

• 使用对象池技术

1. 算法优化：

• 选择更高效的算法

• 利用并行处理

• 实现懒加载

6.3.3 监控体系建设

推荐监控指标：

1. 流处理指标：

• 元素处理速率（elements per second）

• 流的完成率

• 错误率

• 背压事件计数

1. 线程池指标：

• 活跃线程数

• 队列大小

• 线程池利用率

• 任务等待时间

1. 内存指标：

• 堆内存使用量

• 非堆内存使用量

• 对象分配速率

• 垃圾回收频率

1. 自定义业务指标：

• 根据业务需求定义的特定指标

• 如：订单处理时间、用户响应时间等

监控工具推荐：

• Micrometer：与 Spring Boot 集成良好的指标收集库

• Prometheus：时间序列数据库，用于存储指标数据

• Grafana：数据可视化工具，用于展示监控图表

• Spring Boot Admin：应用监控和管理工具

6.4 与 AI 框架集成的特殊考虑

6.4.1 与机器学习框架的兼容性

常见问题：

机器学习框架（如 TensorFlow、PyTorch）通常是同步的，如何与 Reactor 的异步模型集成？

解决方案：

1. 异步包装器：将机器学习模型包装在 CompletableFuture 或 Mono 中

2. 线程池隔离：使用专用线程池执行机器学习推理

3. 批处理策略：对多个请求进行批处理，提高推理效率

4. 模型预热：启动时加载模型，避免首次请求的延迟

6.4.2 智能体状态管理

问题描述：

在多智能体系统中，如何管理智能体的状态并保证线程安全？

解决方案：

1. 不可变状态：使用不可变对象表示智能体状态

2. Actor 模型：借鉴 Akka 的 Actor 模型，每个智能体拥有独立的状态

3. 线程局部存储：使用 Reactor 的 Context 传递上下文信息

4. 状态快照：定期保存状态快照，支持故障恢复

6.4.3 实时性要求

问题描述：

某些 AI 应用（如自动驾驶、机器人控制）对实时性要求很高，如何保证响应时间？

解决方案：

1. 优先级调度：为关键任务分配更高的线程优先级

2. 资源预留：为关键智能体预留计算资源

3. 降级策略：在资源紧张时提供降级服务

4. 预测算法：使用预测算法减少计算量

6.4.4 可扩展性设计

设计原则：

1. 模块化架构：智能体之间松耦合，便于独立扩展

2. 插件化设计：支持动态加载新的智能体类型

3. 水平扩展：通过增加节点实现横向扩展

4. 负载均衡：使用消息队列实现智能体间的负载均衡

七、总结与展望

7.1 学习成果总结

通过 12 周的系统学习，你应该能够：

1. 理论理解：

• 深入理解反应式编程的核心概念

• 掌握 Flux 和 Mono 的设计哲学和使用场景

• 理解 Reactor 的架构设计和实现原理

1. 技术掌握：

• 熟练使用 Flux 和 Mono 的各种创建方式

• 掌握 100 + 个核心操作符的使用方法

• 能够灵活运用线程调度和并发模型

• 掌握完善的错误处理和恢复策略

• 理解并应用背压机制

• 熟练使用 Sinks API 创建热流

1. 实践能力：

• 能够在 AI 智能体框架中熟练应用 Reactor

• 掌握与机器学习框架的集成方法

• 具备性能优化和监控能力

• 能够设计和实现可扩展的多智能体系统

1. 项目经验：

• 完成 4 个渐进式实践项目

• 掌握从简单数据处理到复杂多智能体系统的开发

• 具备处理实际生产环境问题的能力

7.2 未来发展方向

7.2.1 技术发展趋势

1. 云原生集成：Reactor 与 Kubernetes、Istio 等云原生技术的深度集成

2. Serverless 支持：在无服务器环境中更好地支持反应式编程

3. AI/ML 融合：与深度学习框架的无缝集成，支持实时推理

4. 性能优化：通过 JVM 优化、向量化等技术提升性能

5. 多语言支持：与其他语言（如 Kotlin、Scala）的更好互操作性

7.2.2 职业发展建议

1. 技术深耕：

• 深入理解 Reactive Streams 规范

• 学习其他反应式库（如 RxJava、Akka Streams）

• 掌握函数式编程理论

1. 领域拓展：

• 大数据处理：结合 Reactor 和 Spark、Flink

• 物联网：实时处理传感器数据流

• 金融科技：高频交易和风险控制

• 游戏开发：实时多人游戏服务器

1. 架构设计：

• 学习微服务架构设计

• 掌握事件驱动架构

• 理解分布式系统原理

1. 持续学习：

• 关注 Reactor 官方更新和新特性

• 阅读相关技术论文和博客

• 参与开源社区贡献

• 参加技术会议和分享会

7.3 结语

学习 Reactor 框架的 Flux 和 Mono 不仅仅是掌握两个类的使用，更是掌握一种新的编程范式 —— 反应式编程。这种范式在处理现代应用的复杂性、并发性和实时性方面展现出巨大优势，特别是在 AI 智能体框架这样的前沿领域。

通过本指南的学习路径，你将不仅获得扎实的理论基础，更重要的是具备在实际项目中应用这些知识的能力。记住，反应式编程的精髓在于数据流的抽象和异步操作的组合，而 Reactor 通过 Flux 和 Mono 为我们提供了优雅而强大的工具。

在 AI 时代，掌握反应式编程将成为区分优秀开发者的重要技能。无论是构建智能客服系统、自动驾驶平台，还是金融风控系统，Reactor 都将是你工具箱中不可或缺的利器。

最后建议：不要止步于本指南的内容，要在实践中不断探索和创新。React（推理与行动）模式告诉我们，学习是一个不断迭代的过程。保持好奇心，勇于尝试，你将在反应式编程的世界中发现更多精彩！

参考资料

[1] Reactor 3 Reference Guide(pdf) https://projectreactor.io/docs/core/3.8.3/reference/reactor-core-reference-guide-3.8.3.pdf

[2] Reactor Core changelog https://java.libhunt.com/reactor-core-changelog

[3] Maven Repository: io.projectreactor » reactor-core » 3.8.0-M6 - Used By https://mvnrepository.com/artifact/io.projectreactor/reactor-core/3.8.0-M6/used-by?sort=newest

[4] Reactor https://github.com/reactor

[5] Risk-Informed, Technology-Inclusive Regulatory Framework for Advanced Reactors https://docs.regulations.justia.com/entries/2026-03-30/2026-06048.pdf

[6] GitHub - journeyapps-labs/reactor: Ambitious web application framework designed to provide IDE-like user interface experiences on the web. · GitHub https://github.com/journeyapps-labs/reactor

[7] GitHub - reactor/reactor-core: Non-Blocking Reactive Foundation for the JVM · GitHub https://github.com/reactor/reactor-core

[8] Reactor 3 Reference Guide(pdf) https://projectreactor.io/docs/core/3.2.0.M4/reference/reactor-core-reference-guide-3.2.0.M4.pdf

[9] Reactor中Flux与Mono有何区别?各自适用什么场景? - CSDN文库 https://wenku.csdn.net/answer/6cnx6w2cny

[10] Reactor 3 Reference Guide(pdf) https://projectreactor.io/docs/core/3.5.4/reference/reactor-core-reference-guide-3.5.4.pdf

[11] Reactor响应式编程核心详解:Flux、Mono、背压与线程调度实战 - CSDN文库 https://wenku.csdn.net/doc/86ja8vqffr

[12] Project Reactor의 Mono와 Flux https://velog.io/@duskafka/Project-Reactor%EC%9D%98-Mono%EC%99%80Flux

[13] Reactor 中的 Mono 和 Flux:深入解析与操作符指南_mono flux-CSDN博客 https://blog.csdn.net/chen0613/article/details/148710249

[14] Reactor中的Flux和Mono的区别 - 技术栈 https://jishuzhan.net/article/1899385394286940161

[15] Reactor 3 Reference Guide(pdf) https://projectreactor.io/docs/core/3.7.6/reference/reactor-core-reference-guide-3.7.6.pdf

[16] reactor-core https://central.sonatype.com/artifact/io.projectreactor/reactor-core/3.4.18

[17] reactor-core https://central.sonatype.com/artifact/io.projectreactor/reactor-core/3.3.0.RELEASE

[18] Reactor 3 Reference Guide

Step(pdf) https://docs.spring.io/projectreactor/reactor-core/docs/3.3.x/reference/pdf/reactor-core-reference-guide-3.3.22.RELEASE.pdf

[19] Reactor 3 Reference Guide https://docs.spring.io/projectreactor/reactor-core/docs/3.4.0-M2/reference/html/

[20] (4)Reactor 3快速上手——响应式Spring的道法术器_reactor3-CSDN博客 https://blog.csdn.net/get_set/article/details/79480172

[21] Maven Repository: io.projectreactor » reactor-core » 3.7.9 - Used By https://mvnrepository.com/artifact/io.projectreactor/reactor-core/3.7.9/used-by?p=7

[22] ReactorAI https://apps.apple.com/cr/app/reactorai/id6739567267

[23] Python + Agents: Building AI agents and workflows with Agent Framework https://developer.microsoft.com/it-it/reactor/series/S-1631/

[24] Development of an Autonomous Reactor Operation LLM Agent for Real-Time Detection and Proactive Mitigation https://www.kns.org/files/pre_paper/54/25A-295-%ED%95%9C%EA%B8%B0%ED%97%8C.pdf

[25] Agent–Reactor Integration for Intelligent Wastewater Treatment: Experimental Validation and Interpretability of Reinforcement-Learning-Based Control https://doi.org/10.1021/acs.est.5c15251

[26] REACTOR USAGE MAXIMIZATION GUIDE https://github.com/seanchatmangpt/ai-self-sustaining-system/blob/master/REACTOR-USAGE-MAXIMIZATION.md

[27] Python + Agents: Adding a human in the loop to agentic workflows https://reactor.microsoft.com/ja-jp/reactor/events/26693/

[28] Build an AI agent with Microsoft Agent Framework, PostgreSQL, and API Management https://developer.microsoft.com/ja-jp/reactor/events/26508/

[29] Deployed AI Agents for Industrial Asset Management: CodeReAct Framework for Event Analysis and Work Order Automation(pdf) https://ojs.aaai.org/index.php/AAAI/article/download/41453/45414

[30] llm-react智能体:融合推理与行动的ai框架 https://blog.51cto.com/u_15239532/14531597

[31] 什么是 ReAct 智能体?| IBM https://www.ibm.com/cn-zh/think/topics/react-agent#1287801558

[32] ReAct与Reflection架构驱动Agent智能进化与动态协同 https://www.iesdouyin.com/share/video/7579412238671530853/?region=&mid=7579412217804639016&u_code=0&did=MS4wLjABAAAANwkJuWIRFOzg5uCpDRpMj4OX-QryoDgn-yYlXQnRwQQ&iid=MS4wLjABAAAANwkJuWIRFOzg5uCpDRpMj4OX-QryoDgn-yYlXQnRwQQ&with_sec_did=1&video_share_track_ver=&titleType=title&share_sign=NMA4MgR4XH5DNcmY0kDLkh5mAXedPi65efQEmXbdAyY-&share_version=280700&ts=1775227290&from_aid=1128&from_ssr=1&share_track_info=%7B%22link_description_type%22%3A%22%22%7D

[33] 开源智能体框架——ReAct 原理、架构与代码实现 https://tinyseeking.github.io/p/%E5%BC%80%E6%BA%90%E6%99%BA%E8%83%BD%E4%BD%93%E6%A1%86%E6%9E%B6react-%E5%8E%9F%E7%90%86%E6%9E%B6%E6%9E%84%E4%B8%8E%E4%BB%A3%E7%A0%81%E5%AE%9E%E7%8E%B0/

[34] 智能体分类:从反应式到混合式的架构演进与实践_本体智能体-CSDN博客 https://blog.csdn.net/m290345792/article/details/151904558

[35] Efficient Parallel Reinforcement Learning Framework using the Reactor Model(pdf) https://arxiv.org/pdf/2312.04704.pdf

[36] Qu’est-ce qu’un agent ReAct ? https://www.ibm.com/fr-fr/think/topics/react-agent

[37] 反应式编程与机器学习算法的协同优化-洞察阐释 - 豆丁网 https://www.docin.com/touch_new/preview_new.do?id=4877743404

[38] Python + Agents: Building AI agents and workflows with Agent Framework https://reactor.microsoft.com/ja-jp/reactor/series/s-1631/

[39] An AI-Driven Cyber-Physical Testbed for Small-Scale Advanced Reactors https://www.nrc.gov/docs/ML2507/ML25078A223.pdf

[40] java中的反应式编程:rxjava与projectreactor https://blog.csdn.net/weixin_42567046/article/details/141204237

[41] Java Reactive Programming: A Strategic Guide to High-Throughput Enterprise Systems https://www.developers.dev/tech-talk/java-reactive-programming.html

[42] Сравнение реактивных структур Java https://ask-dev.ru/info/278991/comparison-of-java-reactive-frameworks

[43] Reactor 3 Reference Guide https://projectreactor.io/docs/core/3.6.14/reference/reactor-core-reference-guide-3.6.14.pdf

[44] RxJava のサンプルコードを Reactor-Core で書き直す https://qiita.com/toastkidjp/items/800ecaaa854750d8526d

[45] Reactive Programming in Java with Project Reactor and RxJava https://www.w3computing.com/articles/reactive-programming-java-project-reactor-rxjava/

[46] RxJava vs. Project Reactor: Which is Right for Your Project? https://toxigon.com/comparing-rxjava-and-project-reactor

[47] Reactive https://spring.io/reactive/

[48] 深入解析Spring WebFlux:Reactor与响应式编程的核心原理与应用_reactor-netty reactor.schedulers.defaultpoolsize: -CSDN博客 https://blog.csdn.net/zuiyuelong/article/details/150452806

[49] 天猫采用Reactor技术通过空间折叠优化并发请求性能 https://www.iesdouyin.com/share/video/7580281300150488330/?region=&mid=7580281393893542682&u_code=0&did=MS4wLjABAAAANwkJuWIRFOzg5uCpDRpMj4OX-QryoDgn-yYlXQnRwQQ&iid=MS4wLjABAAAANwkJuWIRFOzg5uCpDRpMj4OX-QryoDgn-yYlXQnRwQQ&with_sec_did=1&video_share_track_ver=&titleType=title&share_sign=bIzAIrwoEDHgEmPxxrqd7LA1I8nunkUY4zbJ.Ca6xVM-&share_version=280700&ts=1775227318&from_aid=1128&from_ssr=1&share_track_info=%7B%22link_description_type%22%3A%22%22%7D

[50] Web on Reactive Stack(pdf) https://docs.spring.io/spring-framework/docs/5.3.23/reference/pdf/web-reactive.pdf

[51] 万字长文:Spring WebFlux + Project Reactor 全栈指南——构建响应式Java云原生应用-腾讯云开发者社区-腾讯云 https://cloud.tencent.com/developer/article/2648739?policyId=1003

[52] 响应式编程_05 Project Reactor 框架_小小工匠的技术博客_51CTO博客 https://blog.51cto.com/u_15239532/14530587

[53] RxJava vs Vert.x vs WebFlux 响应式编程优缺点_vert.x和webflux-CSDN博客 https://blog.csdn.net/u014391334/article/details/147055016

[54] Project Reactor vs RxJava https://stackshare.io/stackups/project-reactor-vs-rxjava

[55] Vert.x RxJava https://vertx.io/docs/5.0.3/vertx-rx/java2/

[56] GitHub - ankushs92/vertx-vs-spring-reactor: A benchmark comparing web services made using Groovy, Vertx and vertx-redis-client vs Groovy, Spring Reactor and lettuce · GitHub https://github.com/ankushs92/vertx-vs-spring-reactor

[57] Reactor 3 Reference Guide https://projectreactor.io/docs/core/3.6.3/reference/reactor-core-reference-guide-3.6.3.pdf

[58] Reactor 3 Reference Guide https://projectreactor.io/docs/core/3.8.0-M4/reference/reactor-core-reference-guide-3.8.0-M4.pdf

[59] Analysing the Performance and Costs of Reactive Programming Libraries in Java(pdf) https://inria.hal.science/hal-03409277/file/paper-author-version.pdf

[60] Simple Ways to Create a Flux or Mono and Subscribe to It :: Reactor Core Reference Guide https://docs.spring.io/projectreactor/reactor-core/docs/current-SNAPSHOT/reference/html/coreFeatures/simple-ways-to-create-a-flux-or-mono-and-subscribe-to-it.html

[61] Reactor 中的 Mono 和 Flux:深入解析与操作符指南_mono flux-CSDN博客 https://blog.csdn.net/chen0613/article/details/148710249

[62] (pdf) https://projectreactor.io/docs/core/3.5.0-RC1/reference/reactor-core-reference-guide-3.5.0-RC1.pdf

[63] Java 教程 - Spring 5 新 功能 - Web flux - 响应 式 编程 （ Reactor ） https://www.iesdouyin.com/share/video/6869549869531401485/?region=&mid=6869550408667269901&u_code=0&did=MS4wLjABAAAANwkJuWIRFOzg5uCpDRpMj4OX-QryoDgn-yYlXQnRwQQ&iid=MS4wLjABAAAANwkJuWIRFOzg5uCpDRpMj4OX-QryoDgn-yYlXQnRwQQ&with_sec_did=1&video_share_track_ver=&titleType=title&share_sign=FT5gJaUSjRi4mMHz4eo07x1cOuy_U9k0a33u8v16GHI-&share_version=280700&ts=1775227351&from_aid=1128&from_ssr=1&share_track_info=%7B%22link_description_type%22%3A%22%22%7D

[64] Reactor框架核心指南:深入解析Flux与Mono异步数据流编程 - CSDN文库 https://wenku.csdn.net/doc/2ejkz8dtd6

[65] 响应式编程(Reactive Programming with Reactor)!_wx62babcbc7c892的技术博客_51CTO博客 https://blog.51cto.com/u_15700799/14505827

[66] 【笔记02】【Reactor 响应式编程】_reactor响应式编程-CSDN博客 https://blog.csdn.net/qq_36882793/article/details/158622045

[67] GitHub - reactor/reactor-core: Non-Blocking Reactive Foundation for the JVM · GitHub https://github.com/reactor/reactor-core

[68] Reactor 3 Reference Guide https://projectreactor.io/docs/core/3.3.0.RELEASE/reference/reactor-core-reference-guide-3.3.0.RELEASE.pdf

[69] Reactor 3 Reference Guide

Step(pdf) https://docs.spring.io/projectreactor/reactor-core/docs/3.5.0-M6/reference/pdf/reactor-core-reference-guide-3.5.0-M6.pdf

[70] React项目核心API文档中英对照版免费下载 - CSDN文库 https://wenku.csdn.net/doc/7x3azw4f2s

[71] Reactor 3 Reference Guide(pdf) https://projectreactor.io/docs/core/3.2.19.RELEASE/reference/reactor-core-reference-guide-3.2.19.RELEASE.pdf

[72] Project Reactor响应式编程简介_projectreactor中文文档-CSDN博客 https://blog.csdn.net/CSDN2497242041/article/details/148596085

[73] Project Reactor 核心发布者:Flux 与 Mono 的区别与特性-java教程-PHP中文网 https://m.php.cn/faq/1947115.html

[74] 响应式编程 Reactor 学习小记_reactor.core.publisher.mono-CSDN博客 https://blog.csdn.net/zhousenshan/article/details/130472356

[75] Flux和Mono详细讲解 - CSDN文库 https://wenku.csdn.net/answer/69xdg48a45

[76] Reactor 3 Reference Guide(pdf) https://projectreactor.io/docs/core/3.5.19/reference/reactor-core-reference-guide-3.5.19.pdf

[77] Reactor-core 响应式编程 spring-boot-starter-webflux-CSDN博客 https://blog.csdn.net/qq_42152032/article/details/159709810

[78] Reactor 中的 Mono 和 Flux:深入解析与操作符指南_mono flux-CSDN博客 https://blog.csdn.net/chen0613/article/details/148710249

[79] 响应式编程框架Reactor【2】_reactor响应式编程-CSDN博客 https://blog.csdn.net/ldcigame/article/details/150996998

[80] 04-流处理操作符 https://gacfox.com/notes/%E8%BD%AF%E4%BB%B6%E5%B7%A5%E7%A8%8B/Java/%E7%AC%AC%E4%B8%89%E6%96%B9%E5%BA%93/reactor-core-%E5%93%8D%E5%BA%94%E5%BC%8F%E7%BC%96%E7%A8%8B/04-%E6%B5%81%E5%A4%84%E7%90%86%E6%93%8D%E4%BD%9C%E7%AC%A6/04-%E6%B5%81%E5%A4%84%E7%90%86%E6%93%8D%E4%BD%9C%E7%AC%A6.md

[81] Java 教程 - Spring 5 新 功能 - Web flux - 响应 式 编程 （ Reactor ） https://www.iesdouyin.com/share/video/6869549869531401485/?region=&mid=6869550408667269901&u_code=0&did=MS4wLjABAAAANwkJuWIRFOzg5uCpDRpMj4OX-QryoDgn-yYlXQnRwQQ&iid=MS4wLjABAAAANwkJuWIRFOzg5uCpDRpMj4OX-QryoDgn-yYlXQnRwQQ&with_sec_did=1&video_share_track_ver=&titleType=title&share_sign=FT5gJaUSjRi4mMHz4eo07x1cOuy_U9k0a33u8v16GHI-&share_version=280700&ts=1775227367&from_aid=1128&from_ssr=1&share_track_info=%7B%22link_description_type%22%3A%22%22%7D

[82] Project Reactor 操作符实战:转换与处理响应式数据流-java教程-PHP中文网 https://m.php.cn/faq/1947169.html

[83] 【响应式编程】Reactor 常用操作符与使用指南_reactor 操作符-CSDN博客 https://blog.csdn.net/hiliang521/article/details/147198031

[84] 万字长文详解Spring WebFlux_spring web flux-CSDN博客 https://blog.csdn.net/weixin_36873225/article/details/142464225

[85] 响应式编程框架Reactor【4】_reactor框架学习-CSDN博客 https://blog.csdn.net/ldcigame/article/details/151027128

[86] Reactor Schedulers_schedulers服务-CSDN博客 https://blog.csdn.net/m0_37607945/article/details/148928739

[87] Reactor 3 Reference Guide(pdf) https://projectreactor.io/docs/core/3.5.5/reference/reactor-core-reference-guide-3.5.5.pdf

[88] 响应式编程框架Reactor【9】 - 技术栈 https://jishuzhan.net/article/1962791451500789762

[89] Java中的反应式编程_java响应式编程-CSDN博客 https://blog.csdn.net/zhousenshan/article/details/129970668

[90] 스프링 리액터 시작하기 (5) Scheduler https://velog.io/@bsj805/%EC%8A%A4%ED%94%84%EB%A7%81-%EB%A6%AC%EC%95%A1%ED%84%B0-%EC%8B%9C%EC%9E%91%ED%95%98%EA%B8%B0-5-Scheduler

[91] Reactor Core 错误处理机制深度解析-CSDN博客 https://blog.csdn.net/gitblog_01111/article/details/148507628

[92] 【笔记02】【Reactor 响应式编程】_reactor响应式编程-CSDN博客 https://kingfish.blog.csdn.net/article/details/158622045

[93] Reactor: Error 2 - Recovery https://velog.io/@zenon8485/Reactor-Error-2-Recovery

[94] Reactor流中“最终”逻辑与错误处理的响应式实践-java教程-PHP中文网 https://m.php.cn/faq/1438422.html

[95] Project Reactor 响应式编程-CSDN博客 https://blog.csdn.net/weixin_43866408/article/details/139169834

[96] Reactor流中的异常处理与资源清理:告别阻塞的finally-java教程-PHP中文网 https://m.php.cn/faq/1438389.html

[97] [Project Reactor] 8. Reactor에서의 Backpressure: 과도한 데이터 흐름을 제어하는 방법 https://velog.io/@yin/Reactive-Programming-Reactor%EC%97%90%EC%84%9C%EC%9D%98-Backpressure-%EA%B3%BC%EB%8F%84%ED%95%9C-%EB%8D%B0%EC%9D%B4%ED%84%B0-%ED%9D%90%EB%A6%84%EC%9D%84-%EC%A0%9C%EC%96%B4%ED%95%98%EB%8A%94-%EB%B0%A9%EB%B2%95

[98] 每日一博 - 背压(Backpressure)的核心原理与实现方式_小小工匠的技术博客_51CTO博客 https://blog.51cto.com/u_15239532/14531523

[99] 背压控制 - CSDN文库 https://wenku.csdn.net/answer/6b592xipfe

[100] 背压阀的作用原理与选型要点解析 https://www.iesdouyin.com/share/video/7560584359342984467/?region=&mid=6674391749772708616&u_code=0&did=MS4wLjABAAAANwkJuWIRFOzg5uCpDRpMj4OX-QryoDgn-yYlXQnRwQQ&iid=MS4wLjABAAAANwkJuWIRFOzg5uCpDRpMj4OX-QryoDgn-yYlXQnRwQQ&with_sec_did=1&video_share_track_ver=&titleType=title&share_sign=Zx3dI_C4Y68Sjb0s3FZaovfFEb_iXXHq62iIPho_f2I-&share_version=280700&ts=1775227377&from_aid=1128&from_ssr=1&share_track_info=%7B%22link_description_type%22%3A%22%22%7D

[101] 软件开发中的背压机制详解-CSDN博客 https://blog.csdn.net/u011487024/article/details/159712288

[102] 每日一博 - Kafka、Reactor、NGINX的背压控制与性能调优_51CTO博客_flink 背压会导致kafka积压吗? https://blog.51cto.com/u_15239532/14531567

[103] Reactor Core 组合操作符终极指南:zip、combineLatest、merge 全面解析-CSDN博客 https://blog.csdn.net/gitblog_01033/article/details/154395188

[104] Spring.WebFlux极简(2)_flux.concatmap-CSDN博客 https://blog.csdn.net/Fmbah/article/details/150118005

[105] 【笔记02】【Reactor 响应式编程】_reactor响应式编程-CSDN博客 https://blog.csdn.net/qq_36882793/article/details/158622045

[106] 响应式编程框架Reactor【2】_reactor响应式编程-CSDN博客 https://blog.csdn.net/ldcigame/article/details/150996998

[107] Java reactor编程详解-CSDN博客 https://blog.csdn.net/onlymscn/article/details/154580089

[108] Flux.zip() 方法详解_mb6295b5d8b4d19的技术博客_51CTO博客 https://blog.51cto.com/u_15668812/13823903

[109] Reactor 指南中文版_V2.0 https://doc.oschina.net/projectreactor?t=44496

[110] Reactor Sinks 全面解析:它解决了什么问题，为什么 WebFlux 项目离不开它_sinks.many-CSDN博客 https://blog.csdn.net/qq_45515182/article/details/156280564

[111] 如何在 Reactor 中向现有 Flux 引入数据并合并流-java教程-PHP中文网 https://m.php.cn/faq/1489806.html

[112] [Project Reactor] 9. Reactor Sinks: 외부 이벤트를 리액티브 스트림에 푸시하는 방법 https://velog.io/@yin/Reactor-Sinks

[113] Java高性能应用开发中的Reactor模式解析与多线程模型应用 https://www.iesdouyin.com/share/video/7436243480797580607/?region=&mid=7436244270471809829&u_code=0&did=MS4wLjABAAAANwkJuWIRFOzg5uCpDRpMj4OX-QryoDgn-yYlXQnRwQQ&iid=MS4wLjABAAAANwkJuWIRFOzg5uCpDRpMj4OX-QryoDgn-yYlXQnRwQQ&with_sec_did=1&video_share_track_ver=&titleType=title&share_sign=bP95j0tL5wq5O05d.qCEBWNxQXPnW2uI3SBul_63LL4-&share_version=280700&ts=1775227377&from_aid=1128&from_ssr=1&share_track_info=%7B%22link_description_type%22%3A%22%22%7D

[114] 리액티브 프로그래밍 시작하기 - Reactor편 https://velog.io/@suhongkim98/%EB%A6%AC%EC%95%A1%ED%8B%B0%EB%B8%8C-%ED%94%84%EB%A1%9C%EA%B7%B8%EB%9E%98%EB%B0%8D-%EC%8B%9C%EC%9E%91%ED%95%98%EA%B8%B0-Reactor%ED%8E%B8-2

[115] Reactor响应式编程中Flux和FluxSink_reactor.io flux sink-CSDN博客 https://blog.csdn.net/ttyy1112/article/details/157470747

[116] 响应式编程_06 使用 Flux 和 Mono 高效构建响应式数据流_51CTO博客_webflux响应式编程 https://blog.51cto.com/u_15239532/14530583

[117] Spring Reactor 实战训练教程-CSDN博客 https://blog.csdn.net/gitblog_00909/article/details/142509237

[118] Java 响应式编程实战:Spring WebFlux+Reactor 构建高并发电商系统_java spring reactive-CSDN博客 https://blog.csdn.net/m0_72256543/article/details/155441899

[119] 【JAVA 进阶】深入探秘Netty之Reactor模型:从理论到实战_reactor-netty实战-CSDN博客 https://blog.csdn.net/weixin_63944437/article/details/155262631

[120] 天猫采用Reactor技术通过空间折叠优化并发请求性能 https://www.iesdouyin.com/share/video/7580281300150488330/?region=&mid=7580281393893542682&u_code=0&did=MS4wLjABAAAANwkJuWIRFOzg5uCpDRpMj4OX-QryoDgn-yYlXQnRwQQ&iid=MS4wLjABAAAANwkJuWIRFOzg5uCpDRpMj4OX-QryoDgn-yYlXQnRwQQ&with_sec_did=1&video_share_track_ver=&titleType=title&share_sign=bIzAIrwoEDHgEmPxxrqd7LA1I8nunkUY4zbJ.Ca6xVM-&share_version=280700&ts=1775227384&from_aid=1128&from_ssr=1&share_track_info=%7B%22link_description_type%22%3A%22%22%7D

[121] 万字长文:Spring WebFlux + Project Reactor 全栈指南——构建响应式Java云原生应用-腾讯云开发者社区-腾讯云 https://cloud.tencent.com/developer/article/2648739

[122] projectreactor响应式编程框架技术详解与实践指南 https://developer.aliyun.com/article/1681936

[123] Web on Reactive Stack(pdf) https://docs.spring.io/spring-framework/docs/5.3.8/reference/pdf/web-reactive.pdf

[124] Reactive Web Applications | Spring Boot3.3.2-SNAPSHOT中文文档|Spring官方文档|SpringBoot 教程|Spring中文网 https://www.spring-doc.cn/spring-boot/3.3.2-SNAPSHOT/reference_web_reactive.html

[125] Spring Boot 集成 Spring WebFlux，一文搞定!-云社区-华为云 https://bbs.huaweicloud.com/blogs/456468

[126] 响应式编程(Reactive Programming with Reactor)!_wx62babcbc7c892的技术博客_51CTO博客 https://blog.51cto.com/u_15700799/14505827

[127] Spring WebFlux:响应式编程-CSDN博客 https://blog.csdn.net/2509_94088974/article/details/155161124

[128] 2026大厂必用|WebFlux实战全解析，彻底分清与Spring MVC的区别_从程序员到架构师 http://m.toutiao.com/group/7603970959619392041/?upstream_biz=doubao

[129] 响应式编程框架Reactor【6】_reactor sinks-CSDN博客 https://blog.csdn.net/ldcigame/article/details/151051441

[130] Reactor Sinks 全面解析:它解决了什么问题，为什么 WebFlux 项目离不开它_sinks.many-CSDN博客 https://blog.csdn.net/qq_45515182/article/details/156280564

[131] Reactor Core 版本升级指南:从 3.3.x 到 3.8.x 的完整教程-CSDN博客 https://blog.csdn.net/gitblog_00755/article/details/154398446

[132] Reactor响应式编程中Sinks.Many_reactor sinks-CSDN博客 https://blog.csdn.net/ttyy1112/article/details/157472111

[133] Reactor Sinks-CSDN博客 https://blog.csdn.net/m0_37607945/article/details/149025277

[134] [Project Reactor] 9. Reactor Sinks: 외부 이벤트를 리액티브 스트림에 푸시하는 방법 https://velog.io/@yin/Reactor-Sinks

[135] Reactor 3 Reference Guide(pdf) https://projectreactor.io/docs/core/3.2.3.RELEASE/reference/reactor-core-reference-guide-3.2.3.RELEASE.pdf

[136] react-agent-framework https://www.npmjs.com/package/react-agent-framework

[137] Main add rocketmqa2a component #990 https://github.com/agentscope-ai/agentscope-java/pull/990/files

[138] An AI-Assisted Thermodynamic Equilibrium Simulator: A Case Study on Steam Methane Reforming in Isothermal and Adiabatic Reactors https://mdpi-res.com/d_attachment/processes/processes-13-02508/article_deploy/processes-13-02508.pdf?version=1754667142

[139] LLM-Based Integrated Control Agent System for Nuclear Reactor https://www.kns.org/files/pre_paper/53/25S-141-%EC%9D%B4%EC%9C%A4%ED%91%9C.pdf

[140] An AI-Driven Cyber-Physical Testbed for Small-Scale Advanced Reactors https://www.nrc.gov/docs/ML2507/ML25078A223.pdf

[141] Performance of AI agents based on reasoning language models on ALD process optimization tasks https://arxiv.org/pdf/2601.09980

[142] An AI-Driven Thermal-Fluid Testbed for Advanced Small Modular Reactors: Integration of Digital Twin and Large Language Models(pdf) https://arxiv.org/pdf/2507.06399

[143] Spring AI Alibaba ： Skills 智能 体 实战 https://www.iesdouyin.com/share/video/7606618902423964968/?region=&mid=7606619260252818226&u_code=0&did=MS4wLjABAAAANwkJuWIRFOzg5uCpDRpMj4OX-QryoDgn-yYlXQnRwQQ&iid=MS4wLjABAAAANwkJuWIRFOzg5uCpDRpMj4OX-QryoDgn-yYlXQnRwQQ&with_sec_did=1&video_share_track_ver=&titleType=title&share_sign=_08TX7Z_hVB.ieo3OpjoLW3y0tcBpX4ZpWyNBWvagpg-&share_version=280700&ts=1775227393&from_aid=1128&from_ssr=1&share_track_info=%7B%22link_description_type%22%3A%22%22%7D

[144] 从 MCP 到生产：用 Azure Functions 构建智能代码片段智能体 https://reactor.microsoft.com/ja-jp/reactor/events/26597/

[145] A Digital Twin Framework for Generation-IV Reactors with Reinforcement Learning-Enabled Health-Aware Supervisory Control(pdf) https://arxiv.org/pdf/2506.17258v1

[146] 基于多智能体强化学习的反应堆功率协调控制方法研究(pdf) http://hdlgc.xml-journal.net//cn/article/pdf/preview/10.13832/j.jnpe.2024.080030.pdf

[147] 技术速递|GitHub Copilot SDK 与云原生的完美融合-CSDN博客 https://blog.csdn.net/MicrosoftReactor/article/details/157737086

[148] What is a ReAct Agent? | IBM https://www.ibm.com/think/topics/react-agent

[149] reactive-agents-ts/README.md at main · tylerjrbuell/reactive-agents-ts · GitHub https://github.com/tylerjrbuell/reactive-agents-ts/blob/main/README.md

[150] ReAct Agent 后端架构解析-CSDN博客 https://blog.csdn.net/Vita_min_C/article/details/156306344

[151] Development of an Autonomous Reactor Operation LLM Agent for Real-Time Detection and Proactive Mitigation https://www.kns.org/files/pre_paper/54/25A-295-%ED%95%9C%EA%B8%B0%ED%97%8C.pdf

[152] Reactive AI Agent Framework https://mcpservers.org/servers/tylerjrbuell/reactive-agents

[153] Was ist ein ReAct-Agent? https://www.ibm.com/de-de/think/topics/react-agent

[154] REACTOR USAGE MAXIMIZATION GUIDE https://github.com/seanchatmangpt/ai-self-sustaining-system/blob/master/REACTOR-USAGE-MAXIMIZATION.md

[155] Write the Spec, Let the Agents Build: A Practical Playbook https://reactor.microsoft.com/ja-jp/reactor/events/26850/

[156] 超越LLM:2025年最强Agent设计范式深度解析，引领AI新潮流_agent 测试新范式-CSDN博客 https://blog.csdn.net/2401_84204207/article/details/154692977

[157] Python + Agents: Orchestrating advanced multi-agent workflows https://reactor.microsoft.com/ja-jp/reactor/events/26692/

[158] Using the ReAct Pattern in AI Agents: Best Practices, Pitfalls & Implementation Tips https://metadesignsolutions.com/using-the-react-pattern-in-ai-agents-best-practices-pitfalls-implementation-tips/

[159] Reactive AI Agent Design Patterns https://www.restack.io/p/agent-architecture-answer-reactive-ai-agent-design-patterns-cat-ai

[160] Was ist ein ReAct-Agent? https://www.ibm.com/de-de/think/topics/react-agent

[161] Build, Scale & Govern AI Agents https://reactor.microsoft.com/ja-jp/reactor/events/26786/

[162] ReACT → Plan & Execute → Multi agent ， 三大 架构 解锁 AI 智能 体 进阶 （ 以 气象 场景 为 例 讲解 ） # 气象 # 大模型 # 学习 # 知识 分析 # 教程 https://www.iesdouyin.com/share/video/7537217586577149193/?region=&mid=7537217641170144051&u_code=0&did=MS4wLjABAAAANwkJuWIRFOzg5uCpDRpMj4OX-QryoDgn-yYlXQnRwQQ&iid=MS4wLjABAAAANwkJuWIRFOzg5uCpDRpMj4OX-QryoDgn-yYlXQnRwQQ&with_sec_did=1&video_share_track_ver=&titleType=title&share_sign=wuxEv0WYbGNInrx1lsS8YVqfDfobg8Ttpz.K9tB9YjM-&share_version=280700&ts=1775227427&from_aid=1128&from_ssr=1&share_track_info=%7B%22link_description_type%22%3A%22%22%7D

[163] 从 MCP 到生产：用 Azure Functions 构建智能代码片段智能体 https://reactor.microsoft.com/ja-jp/reactor/events/26597/

[164] AI智能体(六):架构-36氪 https://m.36kr.com/p/3254946900799233

[165] 构建稳健智能体AI系统的五种基本设计模式_ReAct_循环_评判 https://it.sohu.com/a/992790658_185201

[166] 从0到1开发ReAct智能体:原理、实现与最佳实践_react: synergizing reasoning and acting in languag-CSDN博客 https://blog.csdn.net/Liudef06/article/details/159478070

[167] Complete Agentic AI Design Patterns Catalogue(pdf) https://web3.arxiv.org/src/2601.03624v2/anc/agentic-patterns-catalogue-v1.0.pdf

[168] ReActエージェントとは https://www.ibm.com/jp-ja/think/topics/react-agent

[169] ReAct (Reasoning Acting) https://github.com/joehubert/ai-agent-design-patterns/wiki/ReAct-(Reasoning---Acting)/77dad35f495606cb9340e12f111c744d5b0cb6a3

[170] 收藏级|aiagent架构全解析(含langgraph实战)，程序员小白也能上手大模型应用 https://blog.csdn.net/xxue345678/article/details/157940647

[171] zero2agent/specs/E01-read-and-search/S001-react-basic/deep-dive/01-react-pattern.md at main · alienzhou/zero2agent · GitHub https://github.com/alienzhou/zero2agent/blob/main/specs/E01-read-and-search/S001-react-basic/deep-dive/01-react-pattern.md

[172] What is a ReAct Agent? | IBM https://www.ibm.com/think/topics/react-agent

[173] Reactive Agent Architectures: How Simple AI Models Respond to Dynamic Environments https://smythos.com/developers/agent-development/reactive-agent-architectures/

[174] Light Water Reactor Sustainability Program: A Full-scale Demonstration of Pressurized Water Reactor Core Design Optimization using Multi-Cycle Optimization Methodology(pdf) https://lwrs.inl.gov/content/uploads/11/2024/09/INL-RPT-24-80449_PRLO_September2024.pdf

[175] Virtual models paving the way for advanced nuclear reactors

science https://www.alcf.anl.gov/news/virtual-models-paving-way-advanced-nuclear-reactors

[176] Engineers develop faster, more accurate AI algorithm for improving nuclear reactor performance https://www.purdue.edu/newsroom/releases/2024/Q2/engineers-develop-faster-more-accurate-ai-algorithm-for-improving-nuclear-reactor-performance.html

[177] AI/ML Advanced Reactor https://www.anl.gov/nse/ai-ml/advanced-reactor

[178] ISU Chemical boosts reactor yield prediction accuracy to 99.7% https://www.aveva.com/content/dam/aveva/documents/perspectives/success-stories/SuccessStory_AVEVA_ISUChemical.pdf

[179] 反应工程中人工智能的优化.pdf-原创力文档 https://m.book118.com/html/2025/0808/7113050114010143.shtm

[180] What If AI Ran Leaner? https://www.arc.ai/blogs/what-if-ai-ran-leaner

[181] 每日一博 - Kafka、Reactor、NGINX的背压控制与性能调优_51CTO博客_flink 背压会导致kafka积压吗? https://blog.51cto.com/u_15239532/14531567

[182] 背压策略怎么选?深入对比RxJava、Project Reactor中的6种背压模型-CSDN博客 https://blog.csdn.net/VarIsle/article/details/155573130

[183] Reactor响应式编程系列(二)- 背压策略BackPressure_reactor 背压实现原理-CSDN博客 https://blog.csdn.net/zong_0915/article/details/115048075

[184] reactor3 源码分析_51CTO博客_mob64ca140a59b0的技术博客_51CTO博客 https://blog.51cto.com/u_16213658/14490348

[185] [Project Reactor] 8. Reactor에서의 Backpressure: 과도한 데이터 흐름을 제어하는 방법 https://velog.io/@yin/Reactive-Programming-Reactor%EC%97%90%EC%84%9C%EC%9D%98-Backpressure-%EA%B3%BC%EB%8F%84%ED%95%9C-%EB%8D%B0%EC%9D%B4%ED%84%B0-%ED%9D%90%EB%A6%84%EC%9D%84-%EC%A0%9C%EC%96%B4%ED%95%98%EB%8A%94-%EB%B0%A9%EB%B2%95

[186] Spring AI响应式编程:WebFlux与AI流式处理整合-CSDN博客 https://blog.csdn.net/gitblog_00958/article/details/151315061

[187] Reactive Java apps feeling sluggish? Here’s why https://toxigon.com/reactive-programming-mistakes-that-slow-down-your-java-apps

[188] Performance Optimization of Full-Stack Applications Using Reactive Frontend and Backend Integration(pdf) https://multiarticlesjournal.com/uploads/articles/IJCRM202542132.pdf

[189] Performance Issues In AI Teams https://www.restack.io/p/performance-enhancement-strategies-answer-ai-performance-issues-cat-ai

[190] Design: Reactive Multi-Primitive Data Mesh for AI Agent Cognition #1627 https://github.com/stratalab/strata-core/issues/1627

[191] Software Performance Optimization: The Expert Guide for 2025 https://www.sedai.io/blog/software-performance-optimization-expert-guide

（注：文档部分内容可能由 AI 生成）