020 《深入浅出 Folly Fibers：FiberManager 和 Fiber 权威指南》
🌟🌟🌟本文案由Gemini 2.0 Flash Thinking Experimental 01-21创作，用来辅助学习知识。🌟🌟🌟
书籍大纲
▮▮▮▮ 1. chapter 1： Fiber 基础概念 (Fiber Fundamentals)
▮▮▮▮▮▮▮ 1.1 什么是 Fiber？ (What is Fiber?)
▮▮▮▮▮▮▮ 1.2 Fiber、线程和进程的比较 (Comparison of Fibers, Threads, and Processes)
▮▮▮▮▮▮▮ 1.3 Fiber 的优势与劣势 (Advantages and Disadvantages of Fibers)
▮▮▮▮▮▮▮ 1.4 Fiber 的应用场景 (Use Cases for Fibers)
▮▮▮▮▮▮▮▮▮▮▮ 1.4.1 高性能网络编程 (High-Performance Network Programming)
▮▮▮▮▮▮▮▮▮▮▮ 1.4.2 异步任务处理 (Asynchronous Task Processing)
▮▮▮▮▮▮▮▮▮▮▮ 1.4.3 并发控制 (Concurrency Control)
▮▮▮▮ 2. chapter 2： Folly Fiber 核心原理 (Core Principles of Folly Fibers)
▮▮▮▮▮▮▮ 2.1 Folly 库和 Fiber 模块简介 (Introduction to Folly Library and Fiber Module)
▮▮▮▮▮▮▮ 2.2 Fiber 的生命周期与状态 (Fiber Lifecycle and States)
▮▮▮▮▮▮▮ 2.3 Fiber 的上下文切换 (Fiber Context Switching)
▮▮▮▮▮▮▮ 2.4 协作式多任务处理 (Cooperative Multitasking)
▮▮▮▮▮▮▮ 2.5 Fiber 调度器 (Fiber Scheduler)
▮▮▮▮ 3. chapter 3： FiberManager 详解 (In-depth FiberManager)
▮▮▮▮▮▮▮ 3.1 FiberManager 的架构设计 (FiberManager Architecture Design)
▮▮▮▮▮▮▮ 3.2 FiberManager 的核心功能 (Core Functions of FiberManager)
▮▮▮▮▮▮▮ 3.3 创建和管理 Fiber (Creating and Managing Fibers)
▮▮▮▮▮▮▮ 3.4 Fiber 池化技术 (Fiber Pooling Technology)
▮▮▮▮▮▮▮ 3.5 自定义 Fiber 调度策略 (Custom Fiber Scheduling Policies)
▮▮▮▮▮▮▮ 3.6 FiberManager 的配置与扩展 (Configuration and Extension of FiberManager)
▮▮▮▮ 4. chapter 4： Fiber 类深入剖析 (Deep Dive into Fiber Class)
▮▮▮▮▮▮▮ 4.1 Fiber 类的结构与成员 (Structure and Members of Fiber Class)
▮▮▮▮▮▮▮ 4.2 Fiber 的创建与启动 (Fiber Creation and Startup)
▮▮▮▮▮▮▮ 4.3 Fiber 的控制与同步 (Fiber Control and Synchronization)
▮▮▮▮▮▮▮ 4.4 Fiber 局部存储 (Fiber-Local Storage)
▮▮▮▮▮▮▮ 4.5 Fiber 的取消与超时 (Fiber Cancellation and Timeout)
▮▮▮▮ 5. chapter 5： Folly Fiber 高级应用 (Advanced Applications of Folly Fibers)
▮▮▮▮▮▮▮ 5.1 基于 Fiber 的异步编程模式 (Asynchronous Programming Patterns Based on Fibers)
▮▮▮▮▮▮▮ 5.2 Fiber 在高性能服务器中的应用 (Application of Fibers in High-Performance Servers)
▮▮▮▮▮▮▮ 5.3 Fiber 与协程的结合 (Combination of Fibers and Coroutines)
▮▮▮▮▮▮▮ 5.4 Fiber 的性能优化 (Performance Optimization of Fibers)
▮▮▮▮▮▮▮ 5.5 Fiber 的调试与诊断 (Debugging and Diagnosis of Fibers)
▮▮▮▮ 6. chapter 6： FiberManager.h API 全面解析 (Comprehensive API Analysis of FiberManager.h)
▮▮▮▮▮▮▮ 6.1 类 FiberManager (Class FiberManager)
▮▮▮▮▮▮▮▮▮▮▮ 6.1.1 公有成员函数 (Public Member Functions)
▮▮▮▮▮▮▮▮▮▮▮ 6.1.2 保护成员函数 (Protected Member Functions)
▮▮▮▮▮▮▮▮▮▮▮ 6.1.3 静态成员函数 (Static Member Functions)
▮▮▮▮▮▮▮ 6.2 相关类型定义与枚举 (Related Type Definitions and Enumerations)
▮▮▮▮ 7. chapter 7： Fiber.h API 全面解析 (Comprehensive API Analysis of Fiber.h)
▮▮▮▮▮▮▮ 7.1 类 Fiber (Class Fiber)
▮▮▮▮▮▮▮▮▮▮▮ 7.1.1 公有成员函数 (Public Member Functions)
▮▮▮▮▮▮▮▮▮▮▮ 7.1.2 保护成员函数 (Protected Member Functions)
▮▮▮▮▮▮▮▮▮▮▮ 7.1.3 静态成员函数 (Static Member Functions)
▮▮▮▮▮▮▮ 7.2 相关类型定义与枚举 (Related Type Definitions and Enumerations)
▮▮▮▮ 8. chapter 8： Folly Fiber 实战案例 (Practical Case Studies of Folly Fibers)
▮▮▮▮▮▮▮ 8.1 基于 Fiber 实现的简单 RPC 框架 (A Simple RPC Framework Based on Fibers)
▮▮▮▮▮▮▮ 8.2 使用 Fiber 构建高性能 HTTP 服务器 (Building a High-Performance HTTP Server Using Fibers)
▮▮▮▮▮▮▮ 8.3 Fiber 在流式数据处理中的应用 (Application of Fibers in Streaming Data Processing)
▮▮▮▮ 9. chapter 9： Folly Fiber 最佳实践与常见问题 (Best Practices and Common Issues of Folly Fibers)
▮▮▮▮▮▮▮ 9.1 Fiber 编程的最佳实践 (Best Practices for Fiber Programming)
▮▮▮▮▮▮▮ 9.2 常见 Fiber 编程错误与避免 (Common Fiber Programming Errors and Avoidance)
▮▮▮▮▮▮▮ 9.3 Fiber 性能调优技巧 (Fiber Performance Tuning Techniques)
▮▮▮▮ 10. chapter 10： 总结与展望 (Summary and Future Outlook)
▮▮▮▮▮▮▮ 10.1 Folly Fiber 的优势与局限性总结 (Summary of Advantages and Limitations of Folly Fibers)
▮▮▮▮▮▮▮ 10.2 Fiber 技术的未来发展趋势 (Future Development Trends of Fiber Technology)
▮▮▮▮▮▮▮ 附录 A：术语表 (Glossary)
▮▮▮▮▮▮▮ 附录 B：扩展阅读与参考资料 (Further Reading and References)
1. chapter 1： Fiber 基础概念 (Fiber Fundamentals)
1.1 什么是 Fiber？ (What is Fiber?)
在深入探索 folly/fibers/Fiber.h 和 folly/fibers/FiberManager.h 的奥秘之前，我们首先需要奠定坚实的基础，理解 Fiber 的核心概念。那么，什么是 Fiber (Fiber) 呢？
简单来说，Fiber 是一种轻量级的线程。可以将 Fiber 视为用户态线程，它与操作系统内核线程不同，Fiber 的调度和管理完全由用户程序控制。这种用户态的特性赋予了 Fiber 极高的灵活性和效率，尤其在处理高并发和 I/O 密集型任务时表现出色。
为了更好地理解 Fiber，我们可以将其与我们更熟悉的线程 (Thread) 和 进程 (Process) 进行类比：
⚝ 进程 (Process)：进程是操作系统资源分配的基本单位，每个进程都拥有独立的地址空间、内存空间和系统资源。进程之间的切换开销很大，因为涉及到上下文切换，包括 CPU 寄存器、内存管理信息等。进程是重量级的，创建和销毁进程的成本也相对较高。
⚝ 线程 (Thread)：线程是进程内更小的执行单元，一个进程可以包含多个线程，这些线程共享进程的地址空间和资源。线程的创建、销毁和切换开销比进程小，但仍然需要操作系统内核的参与，属于内核态调度。线程的上下文切换也涉及到寄存器、栈等信息的保存和恢复。
⚝ Fiber (Fiber)：Fiber 则更加轻量级。它运行在线程之上，由用户程序自身进行调度。Fiber 的上下文切换仅仅是几个寄存器和栈的切换，无需操作系统内核的参与，因此开销极小，效率极高。多个 Fiber 可以运行在同一个线程中，共享线程的资源，但彼此之间逻辑上是独立的执行单元。
我们可以用一个形象的比喻来帮助理解：
⚝ 进程 就像一座工厂，拥有独立的厂房和资源。
⚝ 线程 就像工厂里的车间，共享工厂的资源，但可以独立运作。
⚝ Fiber 就像车间里的工人，工人之间协作完成任务，共享车间的资源，但每个工人负责不同的工序。
关键特性总结：
① 轻量级 (Lightweight)：Fiber 比线程更轻量级，创建、销毁和切换的开销都非常小。
② 用户态 (User-level)：Fiber 的调度和管理完全在用户态完成，无需内核参与，效率更高。
③ 协作式 (Cooperative)：Fiber 的切换需要显式地进行，通常由 Fiber 主动让出 CPU 执行权，而不是像线程那样由操作系统抢占式调度。
④ 运行在线程之上 (Runs on top of Threads)：Fiber 必须运行在线程中，多个 Fiber 可以共享同一个线程的资源。
代码示例 (伪代码)：
1
// 假设的 Fiber 创建和切换示例 (伪代码，非 folly/fiber 具体 API)
2
3
Fiber fiber1 = createFiber(task1); // 创建 Fiber 1，执行 task1
4
Fiber fiber2 = createFiber(task2); // 创建 Fiber 2，执行 task2
5
6
switchToFiber(fiber1); // 切换到 Fiber 1 执行
7
// ... 执行 task1 的一部分 ...
8
switchToFiber(fiber2); // 切换到 Fiber 2 执行
9
// ... 执行 task2 的一部分 ...
10
switchToFiber(fiber1); // 再次切换回 Fiber 1
11
// ... 继续执行 task1 ...
在这个伪代码示例中，我们可以看到 Fiber 的创建和切换都是由用户代码显式控制的，这体现了 Fiber 的用户态和协作式特性。
理解 Fiber 的本质是理解后续 Folly Fiber 库的基础。它为我们提供了一种在单个线程内实现高并发和高效任务管理的新思路。
1.2 Fiber、线程和进程的比较 (Comparison of Fibers, Threads, and Processes)
为了更清晰地认识 Fiber 的定位和价值，我们将 Fiber、线程和进程三者进行更深入的对比，从多个维度分析它们的异同。
| 特性 (Feature) | 进程 (Process) | 线程 (Thread) | Fiber (Fiber) |
|---|---|---|---|
| 资源隔离 (Resource Isolation) | 完全隔离 (地址空间、资源) (Complete isolation) | 部分共享 (地址空间、资源) (Partial sharing) | 共享线程资源 (Shares thread resources) |
| 调度 (Scheduling) | 操作系统内核调度 (OS kernel scheduling) | 操作系统内核调度 (OS kernel scheduling) | 用户程序调度 (User-level scheduling) |
| 上下文切换开销 (Context Switching Overhead) | 非常高 (Very high) | 较高 (High) | 极低 (Very low) |
| 并发级别 (Concurrency Level) | 较低 (Lower) | 较高 (Higher) | 极高 (Very high) |
| 创建/销毁开销 (Creation/Destruction Overhead) | 高 (High) | 较高 (High) | 低 (Low) |
| 适用场景 (Use Cases) | 资源隔离、稳定性要求高的应用 (Resource isolation, stability-critical applications) | 并发执行、共享资源的应用 (Concurrent execution, resource-sharing applications) | 高并发、I/O 密集型应用 (High concurrency, I/O-bound applications) |
| 编程模型 (Programming Model) | 多进程编程 (Multi-process programming) | 多线程编程 (Multi-threading programming) | 协程/Fiber 编程 (Coroutine/Fiber programming) |
| 同步机制 (Synchronization Mechanisms) | 进程间通信 (IPC) (Inter-Process Communication) | 线程同步 (Thread synchronization) (Mutex, Semaphore, etc.) | 协作式同步 (Cooperative synchronization) (Yield, Channel, etc.) |
| 错误隔离 (Fault Isolation) | 进程崩溃不影响其他进程 (Process crash isolates faults) | 线程崩溃可能影响整个进程 (Thread crash may affect the entire process) | Fiber 错误处理需要用户程序负责 (Fiber error handling is user-managed) |
对比分析：
① 资源隔离与共享：进程是资源隔离的，线程共享进程资源，而 Fiber 更进一步，多个 Fiber 共享同一个线程的资源。资源隔离性越高，安全性越高，但资源利用率和通信效率相对较低。反之，资源共享性越高，资源利用率和通信效率越高，但需要更谨慎地处理并发安全问题。
② 调度方式：进程和线程的调度都由操作系统内核负责，属于抢占式调度。内核根据优先级、时间片等策略进行调度，保证公平性和响应性。Fiber 的调度则完全由用户程序控制，属于协作式调度。Fiber 何时切换、切换到哪个 Fiber，都由用户程序显式决定。
③ 上下文切换开销：由于进程切换涉及到地址空间切换、页表切换等复杂操作，因此开销最高。线程切换开销相对较低，但仍然需要内核参与，涉及到寄存器、栈等信息的保存和恢复。Fiber 的上下文切换仅仅是几个寄存器和栈的切换，开销极小，接近于函数调用的开销。
④ 并发级别：由于进程和线程的创建和切换开销较大，单个系统能支持的进程和线程数量受到限制。Fiber 由于其轻量级的特性，可以轻松创建和管理成千上万甚至数十万的 Fiber，实现极高的并发级别。
⑤ 适用场景：进程适用于需要强隔离性和稳定性的场景，例如操作系统、大型服务器应用等。线程适用于需要并发执行和共享资源的场景，例如 GUI 程序、多线程服务器等。Fiber 则特别适用于高并发、I/O 密集型应用，例如高性能网络服务器、实时通信系统、游戏服务器等。
⑥ 编程模型：进程编程通常使用 IPC 机制进行进程间通信，线程编程使用线程同步机制保证线程安全，Fiber 编程则通常采用协程或 Fiber 自身的同步机制，例如 yield 操作、通道 (Channel) 等。
⑦ 错误隔离：进程拥有独立的地址空间，一个进程崩溃不会影响其他进程。线程共享进程地址空间，一个线程崩溃可能导致整个进程崩溃。Fiber 的错误处理需要用户程序负责，如果 Fiber 中发生未处理的错误，可能会影响到运行在同一个线程中的其他 Fiber。
总结：
Fiber、线程和进程是不同层次的并发执行单元，它们各有优缺点，适用于不同的场景。Fiber 以其轻量级、高效的特性，在高并发和 I/O 密集型应用中展现出独特的优势。理解它们之间的区别和联系，有助于我们根据实际需求选择合适的并发模型。
1.3 Fiber 的优势与劣势 (Advantages and Disadvantages of Fibers)
Fiber 作为一种轻量级的并发机制，在特定场景下具有显著的优势，但也存在一些局限性。下面我们来详细分析 Fiber 的优势与劣势。
优势 (Advantages)：
① 极高的性能 (Extremely High Performance)：
▮▮▮▮⚝ 低上下文切换开销 (Low Context Switching Overhead)：Fiber 的上下文切换仅需保存和恢复少量寄存器和栈信息，无需内核参与，开销接近于函数调用，远低于线程和进程的上下文切换开销。这使得 Fiber 在频繁切换的场景下性能优势非常明显。
▮▮▮▮⚝ 更高的并发度 (Higher Concurrency)：由于 Fiber 的轻量级特性，可以轻松创建和管理大量的 Fiber，从而实现更高的并发度。在 I/O 密集型应用中，可以创建大量的 Fiber 来处理并发请求，而不会像线程那样受到系统资源限制。
② 更好的资源利用率 (Better Resource Utilization)：
▮▮▮▮⚝ 更小的内存占用 (Smaller Memory Footprint)：每个 Fiber 只需要较小的栈空间，相比线程和进程，Fiber 的内存占用更小，可以更有效地利用系统内存资源。
▮▮▮▮⚝ 减少系统调用 (Reduced System Calls)：Fiber 的调度和管理都在用户态完成，减少了系统调用的次数，降低了内核开销，提高了整体性能。
③ 更灵活的调度 (More Flexible Scheduling)：
▮▮▮▮⚝ 用户态调度 (User-level Scheduling)：Fiber 的调度策略完全由用户程序控制，可以根据应用场景定制更灵活、更高效的调度策略。例如，可以实现优先级调度、公平调度、延迟调度等。
▮▮▮▮⚝ 协作式多任务 (Cooperative Multitasking)：Fiber 采用协作式多任务模型，Fiber 主动让出 CPU 执行权，可以更好地控制任务的执行顺序和资源分配，避免了线程抢占式调度可能带来的竞争和不确定性。
④ 更简洁的异步编程模型 (Simpler Asynchronous Programming Model)：
▮▮▮▮⚝ 顺序式代码风格 (Sequential Code Style)：使用 Fiber 可以将异步操作写成顺序式的代码，避免了传统回调函数或 Promise 带来的代码复杂性和可读性问题，使得异步编程更加直观和易于维护。
▮▮▮▮⚝ 异常处理更方便 (Easier Exception Handling)：Fiber 可以像同步代码一样使用 try-catch 块进行异常处理，简化了异步编程中的错误处理逻辑。
劣势 (Disadvantages)：
① 协作式调度的局限性 (Limitations of Cooperative Scheduling)：
▮▮▮▮⚝ 阻塞操作问题 (Blocking Operations)：如果 Fiber 执行了阻塞式 I/O 操作或长时间计算任务，会导致整个线程阻塞，影响运行在同一个线程中的其他 Fiber。因此，在使用 Fiber 时，必须避免阻塞式操作，或者将阻塞操作放到独立的线程中执行。
▮▮▮▮⚝ 需要显式让出 CPU (Need Explicit Yielding)：Fiber 的切换需要显式地调用 yield 操作或其他让出 CPU 的机制。如果 Fiber 没有主动让出 CPU，可能会导致其他 Fiber 无法执行，甚至造成死锁。
② 单线程 CPU 密集型瓶颈 (Single-Thread CPU-Bound Bottleneck)：
▮▮▮▮⚝ 无法充分利用多核 CPU (Cannot Fully Utilize Multi-core CPUs)：Fiber 通常运行在单个线程中，对于 CPU 密集型任务，即使在多核 CPU 环境下，也无法充分利用多核的并行计算能力。如果需要利用多核 CPU，需要结合多线程或多进程技术。
▮▮▮▮⚝ CPU 密集型任务不适用 (Not Suitable for CPU-Bound Tasks)：Fiber 更适合 I/O 密集型任务，对于 CPU 密集型任务，Fiber 的性能优势并不明显，甚至可能因为额外的调度开销而降低性能。
③ 调试和错误处理的复杂性 (Complexity of Debugging and Error Handling)：
▮▮▮▮⚝ 调试难度增加 (Increased Debugging Difficulty)：Fiber 的执行流程可能比较复杂，涉及到多次切换和协作，调试起来比传统的线程程序更困难。需要使用专门的 Fiber 调试工具或技巧。
▮▮▮▮⚝ 错误传播和隔离 (Error Propagation and Isolation)：Fiber 的错误处理需要用户程序负责，错误可能会在 Fiber 之间传播，甚至影响整个线程。需要仔细设计错误处理机制，保证程序的健壮性。
④ 库的依赖性 (Library Dependency)：
▮▮▮▮⚝ 需要特定的 Fiber 库 (Requires Specific Fiber Library)：Fiber 不是操作系统原生支持的概念，需要使用特定的 Fiber 库 (例如 Folly Fiber) 来实现和管理 Fiber。这增加了代码的依赖性，也可能带来学习成本。
▮▮▮▮⚝ 平台兼容性 (Platform Compatibility)：不同的 Fiber 库可能在不同的平台上具有不同的兼容性和性能表现。需要根据目标平台选择合适的 Fiber 库。
总结：
Fiber 具有高性能、低资源消耗、灵活调度等优势，特别适合 I/O 密集型和高并发场景。然而，Fiber 也存在协作式调度的局限性、单线程 CPU 瓶颈、调试复杂性等劣势。在选择使用 Fiber 时，需要充分权衡其优缺点，并根据具体的应用场景和需求进行选择。在合适的场景下，Fiber 可以成为提升系统性能和简化异步编程的有力工具。
1.4 Fiber 的应用场景 (Use Cases for Fibers)
Fiber 以其独特的优势，在许多领域都找到了应用场景，尤其是在对性能和并发有较高要求的系统中。下面我们重点介绍 Fiber 在高性能网络编程、异步任务处理和并发控制等方面的应用。
1.4.1 高性能网络编程 (High-Performance Network Programming)
高性能网络编程是 Fiber 最为典型的应用场景之一。在网络服务器中，通常需要处理大量的并发连接和请求。传统的线程模型在面对高并发连接时，会因为线程创建、切换和资源消耗过大而导致性能瓶颈。而 Fiber 的轻量级和高效调度特性，使其成为构建高性能网络服务器的理想选择。
应用场景示例：
① Web 服务器 (Web Servers)：
▮▮▮▮⚝ 使用 Fiber 可以构建高吞吐量、低延迟的 Web 服务器，处理大量的 HTTP 请求。每个连接可以分配一个 Fiber 来处理请求和响应，Fiber 之间的切换开销极小，可以轻松应对数万甚至数十万的并发连接。
▮▮▮▮⚝ 例如，可以使用 Fiber 实现非阻塞 I/O 操作，当 Fiber 等待网络数据时，可以主动让出 CPU 执行权，切换到其他 Fiber 处理其他连接，提高服务器的并发处理能力。
② RPC 框架 (RPC Frameworks)：
▮▮▮▮⚝ 在 RPC (Remote Procedure Call) 框架中，客户端需要发送请求并等待服务器响应。使用 Fiber 可以将 RPC 调用封装成同步的函数调用形式，隐藏底层的异步细节，简化客户端编程。
▮▮▮▮⚝ 服务器端可以使用 Fiber 来处理并发的 RPC 请求，提高 RPC 服务的吞吐量和响应速度。
③ 游戏服务器 (Game Servers)：
▮▮▮▮⚝ 游戏服务器需要实时处理大量玩家的连接和操作。Fiber 可以用于构建高并发、低延迟的游戏服务器，处理玩家的实时交互和游戏逻辑。
▮▮▮▮⚝ 例如，可以使用 Fiber 来处理玩家的移动、战斗、聊天等操作，保证游戏的流畅性和实时性。
优势体现：
⚝ 高并发连接处理 (High Concurrent Connection Handling)：Fiber 可以轻松处理数万甚至数十万的并发连接，远超线程模型的并发能力。
⚝ 低延迟响应 (Low Latency Response)：Fiber 的低上下文切换开销，使得网络请求可以快速得到处理和响应，降低了延迟。
⚝ 简化异步编程 (Simplified Asynchronous Programming)：使用 Fiber 可以将网络 I/O 操作写成顺序式的代码，避免了回调地狱，提高了代码的可读性和可维护性。
代码示例 (伪代码)：
1
// 假设的基于 Fiber 的 Web 服务器示例 (伪代码，非 folly/fiber 具体 API)
2
3
void handle_connection(Connection conn) { // 每个连接创建一个 Fiber 执行 handle_connection
4
while (true) {
5
Request req = conn.receive_request(); // 接收请求 (非阻塞 I/O)
6
if (req.is_valid()) {
7
Response resp = process_request(req); // 处理请求
8
conn.send_response(resp); // 发送响应 (非阻塞 I/O)
9
} else {
10
break; // 连接关闭
11
}
12
yield(); // 主动让出 CPU，允许其他 Fiber 执行
13
}
14
conn.close();
15
}
16
17
int main() {
18
ServerSocket server_socket;
19
server_socket.bind(port);
20
server_socket.listen();
21
22
while (true) {
23
Connection conn = server_socket.accept(); // 接受连接 (非阻塞 I/O)
24
createFiber(handle_connection, conn); // 为每个连接创建 Fiber
25
}
26
return 0;
27
}
在这个伪代码示例中，每个连接都由一个独立的 Fiber 处理，handle_connection 函数以顺序式的方式处理请求和响应，并通过 yield() 主动让出 CPU，实现了高并发和高效的网络服务。
1.4.2 异步任务处理 (Asynchronous Task Processing)
异步任务处理是 Fiber 的另一个重要应用场景。在许多应用中，需要执行一些耗时的异步任务，例如文件 I/O、数据库查询、外部服务调用等。使用 Fiber 可以简化异步任务的管理和调度，提高系统的响应性和吞吐量。
应用场景示例：
① 后台任务队列 (Background Task Queues)：
▮▮▮▮⚝ 可以使用 Fiber 实现后台任务队列，将耗时的任务 (例如发送邮件、处理日志、数据分析等) 放入队列中异步执行，避免阻塞主线程，提高应用的响应速度。
▮▮▮▮⚝ 每个任务可以分配一个 Fiber 来执行，Fiber 可以从任务队列中取出任务并执行，执行完成后可以继续处理下一个任务。
② 定时任务调度 (Scheduled Task Scheduling)：
▮▮▮▮⚝ 可以使用 Fiber 实现定时任务调度器，定期执行一些任务 (例如数据备份、缓存清理、统计报表生成等)。
▮▮▮▮⚝ 可以使用 Fiber 的休眠 (sleep) 功能来实现定时任务的触发，当休眠时间到达时，Fiber 会被唤醒并执行相应的任务。
③ 并发数据处理 (Concurrent Data Processing)：
▮▮▮▮⚝ 对于需要处理大量数据的应用 (例如数据导入、数据转换、数据分析等)，可以使用 Fiber 将数据分割成小块，并为每个数据块创建一个 Fiber 来并发处理，提高数据处理速度。
▮▮▮▮⚝ 可以使用 Fiber 的通道 (Channel) 或其他同步机制来协调 Fiber 之间的数据交换和同步。
优势体现：
⚝ 提高系统响应性 (Improved System Responsiveness)：将耗时任务异步化，避免阻塞主线程，提高应用的响应速度和用户体验。
⚝ 简化异步编程模型 (Simplified Asynchronous Programming Model)：使用 Fiber 可以将异步任务写成顺序式的代码，避免了回调地狱，提高了代码的可读性和可维护性。
⚝ 高效的任务调度 (Efficient Task Scheduling)：Fiber 的轻量级和高效调度特性，使得可以高效地管理和调度大量的异步任务。
代码示例 (伪代码)：
1
// 假设的基于 Fiber 的后台任务队列示例 (伪代码，非 folly/fiber 具体 API)
2
3
TaskQueue task_queue; // 任务队列
4
5
void task_worker() { // 任务 worker Fiber
6
while (true) {
7
Task task = task_queue.dequeue(); // 从队列中取出任务 (阻塞式等待)
8
if (task.is_valid()) {
9
process_task(task); // 执行任务
10
} else {
11
break; // 队列关闭
12
}
13
}
14
}
15
16
void enqueue_task(Task task) { // 入队任务
17
task_queue.enqueue(task);
18
}
19
20
int main() {
21
createFiber(task_worker); // 创建任务 worker Fiber
22
23
// ... 主线程 ...
24
enqueue_task(task1); // 入队任务 1
25
enqueue_task(task2); // 入队任务 2
26
// ...
27
return 0;
28
}
在这个伪代码示例中，task_worker Fiber 负责从任务队列中取出任务并执行，主线程可以通过 enqueue_task 函数将任务放入队列，实现了异步任务处理。
1.4.3 并发控制 (Concurrency Control)
Fiber 也可以用于实现更精细的并发控制。在某些场景下，需要对并发执行的任务进行更细粒度的控制，例如限制并发度、实现任务的优先级调度、控制任务的执行顺序等。Fiber 的用户态调度和协作式特性，使其可以灵活地实现各种并发控制策略。
应用场景示例：
① 流量控制 (Traffic Control)：
▮▮▮▮⚝ 在网络服务器或 API 网关中，可以使用 Fiber 实现流量控制，限制单位时间内处理的请求数量，防止系统过载。
▮▮▮▮⚝ 可以使用 Fiber 的信号量 (Semaphore) 或令牌桶 (Token Bucket) 等机制来实现流量控制，当请求数量超过限制时，可以延迟或拒绝请求。
② 资源限制 (Resource Limiting)：
▮▮▮▮⚝ 在需要限制资源使用 (例如 CPU、内存、文件句柄等) 的场景下，可以使用 Fiber 来控制并发任务的数量，避免资源耗尽。
▮▮▮▮⚝ 可以使用 Fiber 池 (Fiber Pool) 来限制并发 Fiber 的数量，当 Fiber 池满时，新的任务需要等待 Fiber 池中有空闲 Fiber 才能执行。
③ 任务优先级调度 (Task Priority Scheduling)：
▮▮▮▮⚝ 在需要根据任务的优先级进行调度的场景下，可以使用 Fiber 实现优先级调度器。
▮▮▮▮⚝ 可以为每个 Fiber 设置优先级，调度器根据 Fiber 的优先级来决定下一个执行的 Fiber。高优先级的 Fiber 可以优先获得 CPU 执行权。
优势体现：
⚝ 细粒度并发控制 (Fine-grained Concurrency Control)：Fiber 提供了更细粒度的并发控制能力，可以根据应用需求定制各种并发控制策略。
⚝ 灵活的调度策略 (Flexible Scheduling Policies)：用户可以自定义 Fiber 的调度策略，实现更复杂的任务调度和资源管理。
⚝ 避免线程竞争 (Avoid Thread Contention)：在单线程 Fiber 模型下，可以避免多线程竞争和锁带来的性能开销和复杂性。
代码示例 (伪代码)：
1
// 假设的基于 Fiber 的流量控制示例 (伪代码，非 folly/fiber 具体 API)
2
3
Semaphore request_semaphore(max_concurrent_requests); // 信号量，限制最大并发请求数
4
5
void handle_request(Request req) {
6
request_semaphore.acquire(); // 获取信号量，限制并发数
7
process_request(req); // 处理请求
8
request_semaphore.release(); // 释放信号量
9
}
10
11
int main() {
12
ServerSocket server_socket;
13
server_socket.bind(port);
14
server_socket.listen();
15
16
while (true) {
17
Connection conn = server_socket.accept();
18
createFiber(handle_request, conn);
19
}
20
return 0;
21
}
在这个伪代码示例中，request_semaphore 信号量限制了最大并发请求数，handle_request Fiber 在处理请求前需要先获取信号量，保证并发请求数不超过限制，实现了流量控制。
总结：
Fiber 在高性能网络编程、异步任务处理和并发控制等领域都展现出强大的应用潜力。其轻量级、高效调度、灵活控制等特性，使其成为构建高性能、高并发系统的有力工具。在后续章节中，我们将深入探讨 Folly Fiber 库的具体实现和应用，帮助读者更好地理解和使用 Fiber 技术。
END_OF_CHAPTER
2. chapter 2： Folly Fiber 核心原理 (Core Principles of Folly Fibers)
2.1 Folly 库和 Fiber 模块简介 (Introduction to Folly Library and Fiber Module)
Folly，全称为 "Facebook Open-source Library"，是由 Facebook 开源的一套 C++ 库。它旨在为 C++11 提供实用的、高性能的、经过良好测试的组件，以解决在构建和维护大规模、高性能服务时遇到的各种挑战。Folly 并非一个单一的、庞大的库，而是一系列独立的、模块化的组件集合，开发者可以根据自身需求选择性地使用其中的部分模块。
Folly 库涵盖了广泛的领域，包括但不限于：
⚝ 字符串处理 (String Manipulation)：提供了高效的字符串操作和格式化工具，例如 fbstring。
⚝ 容器 (Containers)： 实现了多种高性能的容器，例如 fbvector, F14ValueMap 等，针对特定场景进行了优化。
⚝ 并发与异步编程 (Concurrency and Asynchronous Programming)： 这是 Folly 库中非常重要的一个组成部分，提供了诸如 Future/Promise、Executor、EventCount、Baton 以及我们本书重点关注的 Fiber (纤程) 等工具，用于简化和优化并发及异步编程。
⚝ 网络编程 (Network Programming)： 提供了 Socket、AsyncSocket、IOBuf 等网络编程相关的组件，支持构建高性能的网络应用。
⚝ 时间与日期 (Date and Time)： 提供了 DateTime、Duration 等时间日期处理工具。
⚝ 配置与选项解析 (Configuration and Option Parsing)： 提供了 CommandLine、Options 等用于处理命令行参数和配置的工具。
Fiber 模块 是 Folly 库中专注于轻量级并发 (lightweight concurrency) 的一个重要模块。它提供了一种用户态线程 (user-space thread) 的实现，允许开发者在单个操作系统线程 (OS thread) 中创建和管理大量的 纤程 (Fiber)。与传统的操作系统线程相比，Fiber 具有更低的创建和切换开销，因此非常适合构建高性能、高并发的应用，尤其是在 I/O 密集型场景下。
Folly Fiber 模块的设计目标是：
⚝ 高性能 (High Performance)： 提供高效的上下文切换和调度机制，降低并发的开销。
⚝ 易用性 (Ease of Use)： 提供简洁易用的 API，方便开发者创建、管理和同步 Fiber。
⚝ 灵活性 (Flexibility)： 支持自定义调度策略，以适应不同的应用场景需求。
⚝ 与 Folly 库的良好集成 (Good Integration with Folly Library)： 与 Folly 库的其他组件（如 Future/Promise、Executor）无缝集成，构建完整的异步编程解决方案。
使用 Folly Fiber 模块的主要优势包括：
⚝ 降低并发开销 (Reduced Concurrency Overhead)： Fiber 的创建和切换开销远小于线程，可以显著提高并发性能。
⚝ 提高资源利用率 (Improved Resource Utilization)： 在相同的硬件资源下，Fiber 可以支持更高的并发度，提高资源利用率。
⚝ 简化异步编程 (Simplified Asynchronous Programming)： Fiber 提供的协作式多任务处理模型，可以使异步编程逻辑更接近同步编程，降低开发复杂性。
⚝ 适用于高性能 I/O 密集型应用 (Suitable for High-Performance I/O-Intensive Applications)： Fiber 特别适合处理大量的并发 I/O 操作，例如网络服务器、消息队列等。
总而言之，Folly 库是一个功能强大且全面的 C++ 工具库，而 Fiber 模块则是其在并发编程领域的重要组成部分。通过深入理解和掌握 Folly Fiber 的核心原理，开发者可以构建出更加高效、可扩展的并发应用。在接下来的章节中，我们将逐步深入 Folly Fiber 的各个方面，帮助读者全面掌握这一强大的工具。
2.2 Fiber 的生命周期与状态 (Fiber Lifecycle and States)
如同进程和线程一样，纤程 (Fiber) 也具有自己的 生命周期 (Lifecycle) 和 状态 (States)。理解 Fiber 的生命周期和状态对于正确地使用和管理 Fiber 至关重要。Folly Fiber 的生命周期相对简洁，主要包含以下几个核心状态：
- 新建 (Created)： 当一个
Fiber对象被创建时，它处于 新建 (Created) 状态。此时，Fiber 仅仅是一个对象实例，尚未与任何执行上下文关联，也没有开始执行任何代码。
1
#include <folly/fibers/Fiber.h>
2
3
folly::fibers::Fiber myFiber; // Fiber 对象被创建，处于 Created 状态
- 就绪 (Ready)： 当 Fiber 被添加到 Fiber 管理器 (FiberManager) 的 就绪队列 (Ready Queue) 中，并等待被调度执行时，它进入 就绪 (Ready) 状态。处于就绪状态的 Fiber 已经准备好运行，但尚未获得 CPU 执行权。
1
#include <folly/fibers/FiberManager.h>
2
#include <folly/fibers/Fiber.h>
3
4
folly::fibers::FiberManager fm;
5
folly::fibers::Fiber myFiber;
6
7
fm.add(&myFiber, []{
8
// Fiber 的执行体
9
}); // myFiber 进入 Ready 状态，等待调度
- 运行 (Running)： 当 Fiber 调度器 (Fiber Scheduler) 从就绪队列中选择一个 Fiber 并将其调度到 执行单元 (Execution Unit) (通常是一个操作系统线程) 上运行时，Fiber 进入 运行 (Running) 状态。在运行状态下，Fiber 执行其关联的任务函数。
1
// 假设 myFiber 被调度器选中并开始运行
2
// ... Fiber 执行体代码 ...
- 挂起 (Suspended)： 在 Fiber 运行过程中，可能会因为某些原因暂停执行，例如：
▮▮▮▮⚝ 显式挂起 (Explicit Suspension)： Fiber 主动调用 folly::fibers::Fiber::yield() 或其他挂起操作，例如等待 folly::fibers::Baton 或 folly::futures::Future。
▮▮▮▮⚝ 隐式挂起 (Implicit Suspension)： Fiber 执行了阻塞 I/O 操作 (虽然 Fiber 旨在避免阻塞 I/O，但在某些情况下可能会发生)。
1
当 Fiber 暂停执行时，它进入 **挂起 (Suspended)** 状态。挂起的 Fiber 会让出 CPU 执行权，允许调度器调度其他就绪的 Fiber 运行。
1
#include <folly/fibers/Fiber.h>
2
3
void fiberFunc() {
4
// ... 一些代码 ...
5
folly::fibers::Fiber::yield(); // Fiber 显式挂起
6
// ... 挂起后恢复执行的代码 ...
7
}
- 恢复 (Resumed)： 当一个挂起的 Fiber 所等待的条件满足时 (例如，
Baton被 signal，Future就绪)，或者被显式地唤醒时，它会从挂起状态转换为 恢复 (Resumed) 状态，并被重新放回 就绪队列 (Ready Queue)，等待调度器再次调度执行。
1
#include <folly/fibers/Baton.h>
2
#include <folly/fibers/Fiber.h>
3
4
folly::fibers::Baton baton;
5
6
void fiberFunc() {
7
// ... 一些代码 ...
8
baton.wait(); // Fiber 挂起等待 baton 被 signal
9
// ... baton 被 signal 后恢复执行的代码 ...
10
}
11
12
void anotherFunc() {
13
// ... 一些代码 ...
14
baton.post(); // Signal baton，唤醒等待的 Fiber
15
}
- 完成 (Finished)： 当 Fiber 的执行体函数执行完毕，或者 Fiber 被显式地取消 (canceled) 时，Fiber 进入 完成 (Finished) 状态。处于完成状态的 Fiber 不再参与调度，其生命周期结束。Fiber 对象本身仍然存在，但其执行上下文和关联资源可能会被释放。
1
void fiberFunc() {
2
// ... Fiber 执行体代码 ...
3
// 函数执行完毕，Fiber 进入 Finished 状态
4
}
可以用一个简单的状态转换图来概括 Fiber 的生命周期：
1
stateDiagram-v2
2
[*] --> Created
3
Created --> Ready : add to FiberManager
4
Ready --> Running : Scheduler dispatches
5
Running --> Suspended : yield(), wait(), block I/O
6
Suspended --> Ready : resume, signal, I/O completion
7
Running --> Finished : Function returns, canceled
8
Ready --> Finished : FiberManager shutdown
9
Suspended --> Finished : FiberManager shutdown, cancel
10
Finished --> [*]
状态转换总结:
⚝ Fiber 从 Created 状态开始，通过 FiberManager::add() 进入 Ready 状态。
⚝ Fiber Scheduler 负责将 Ready 状态的 Fiber 调度到 Running 状态。
⚝ Fiber 在 Running 状态下可以主动 Suspended，或者等待某些事件。
⚝ Suspended 的 Fiber 在条件满足后会 Resumed，重新回到 Ready 状态等待调度。
⚝ Fiber 执行完成后进入 Finished 状态，生命周期结束。
⚝ 在 FiberManager 关闭或 Fiber 被取消的情况下，Fiber 可以从 Ready 或 Suspended 状态直接进入 Finished 状态。
理解 Fiber 的生命周期和状态对于编写正确的 Fiber 程序至关重要。例如，需要注意避免在 Fiber 中执行长时间的同步阻塞操作，以免影响其他 Fiber 的执行。合理地使用 Fiber 的挂起和恢复机制，可以构建高效的并发程序。在后续章节中，我们将结合具体的 API 和代码示例，进一步深入探讨 Fiber 的生命周期管理和状态控制。
2.3 Fiber 的上下文切换 (Fiber Context Switching)
上下文切换 (Context Switching) 是操作系统和并发编程中的一个核心概念。它指的是在多个任务之间快速切换执行权，使得用户感觉好像多个任务在同时进行。对于 纤程 (Fiber) 而言，Fiber 上下文切换 (Fiber Context Switching) 是实现轻量级并发的关键机制。
什么是 Fiber 上下文？ (What is Fiber Context?)
在深入了解 Fiber 上下文切换之前，我们需要先理解什么是 Fiber 的上下文。简单来说，Fiber 的上下文包含了 Fiber 执行所需的所有 运行时环境 (Runtime Environment) 信息，主要包括：
⚝ 栈 (Stack)： 每个 Fiber 都有自己的栈空间，用于存储局部变量、函数调用信息等。Fiber 的栈通常比线程的栈小得多，这也是 Fiber 轻量级的一个重要体现。
⚝ 寄存器 (Registers)： 包括程序计数器 (Program Counter, PC)、栈指针 (Stack Pointer, SP)、通用寄存器等。这些寄存器保存了 Fiber 当前的执行状态。
⚝ Fiber 局部存储 (Fiber-Local Storage, FLS)： 用于存储 Fiber 特有的数据，类似于线程局部存储 (Thread-Local Storage, TLS)，但作用域更小，仅限于 Fiber 内部。
⚝ 调度器状态 (Scheduler State)： Fiber 在调度器中的状态信息，例如 Fiber 的优先级、状态 (Ready, Running, Suspended 等) 等。
Fiber 上下文切换的过程 (Process of Fiber Context Switching)
Fiber 上下文切换是指将当前正在运行的 Fiber 的上下文保存起来，然后加载另一个 Fiber 的上下文，使得 CPU 可以继续执行另一个 Fiber 的过程。Folly Fiber 的上下文切换过程通常由 Fiber 调度器 (Fiber Scheduler) 负责，大致步骤如下：
- 保存当前 Fiber 的上下文 (Save Current Fiber Context)： 当需要切换 Fiber 时 (例如，当前 Fiber 调用
folly::fibers::Fiber::yield()或等待某个事件)，调度器首先会将当前正在运行的 Fiber 的上下文 (栈、寄存器等) 保存到内存中。 - 选择下一个要运行的 Fiber (Select Next Fiber to Run)： 调度器根据一定的调度策略 (例如，FIFO, 优先级等) 从 就绪队列 (Ready Queue) 中选择下一个要运行的 Fiber。
- 加载下一个 Fiber 的上下文 (Load Next Fiber Context)： 调度器将选定的 Fiber 的上下文 (之前保存的栈、寄存器等) 从内存中加载到 CPU 的寄存器中。
- 恢复执行 (Resume Execution)： CPU 从程序计数器 (PC) 指向的位置开始执行新的 Fiber 的代码。
Fiber 上下文切换与线程上下文切换的比较 (Comparison with Thread Context Switching)
Fiber 上下文切换与线程上下文切换虽然都是任务切换，但它们在实现机制和开销上存在显著差异：
| 特性 (Feature) | Fiber 上下文切换 (Fiber Context Switching) | 线程上下文切换 (Thread Context Switching) |
|---|---|---|
| 切换主体 (Switching Entity) | 用户态 (User-space) 库 (Folly Fiber 库) | 操作系统内核 (Operating System Kernel) |
| 切换时机 (Switching Trigger) | 通常由 Fiber 主动 yield() 或等待操作触发 (协作式) | 由操作系统调度器根据时间片轮转、优先级等策略抢占式触发 (抢占式) |
| 上下文保存与加载 (Context Save/Load) | 仅需保存和加载 Fiber 的栈、寄存器等少量信息，开销较小 | 需要保存和加载线程的完整上下文，包括寄存器、栈、内存页表等，开销较大 |
| 切换开销 (Switching Overhead) | 非常低，通常在微秒级甚至纳秒级 | 相对较高，通常在微秒级到毫秒级 |
| 资源消耗 (Resource Consumption) | 每个 Fiber 栈空间较小，资源消耗低 | 每个线程栈空间较大，资源消耗相对较高 |
| 并发度 (Concurrency Level) | 在单个线程中可以创建和管理数以万计的 Fiber，支持非常高的并发度 | 操作系统线程数量受限，过多的线程会导致系统开销增大，并发度相对较低 |
| 同步与通信 (Synchronization & Communication) | 同步和通信机制通常在用户态实现，例如 Baton，开销更低 | 同步和通信可能需要系统调用，例如互斥锁、信号量等，开销相对较高 |
总结 (Summary)
Fiber 上下文切换是一种轻量级的任务切换机制，其核心优势在于 低开销 (Low Overhead)。由于 Fiber 上下文切换完全在用户态完成，无需操作系统内核参与，因此避免了昂贵的系统调用开销。这使得 Fiber 能够实现非常快速的上下文切换，从而支持高并发和高性能的应用。
理解 Fiber 上下文切换的原理和优势，有助于我们更好地利用 Folly Fiber 构建高效的并发程序。在后续章节中，我们将结合代码示例，进一步探讨 Fiber 上下文切换的具体实现和应用场景。
2.4 协作式多任务处理 (Cooperative Multitasking)
多任务处理 (Multitasking) 是指在一个计算机系统中同时执行多个任务的能力。多任务处理可以分为 抢占式多任务处理 (Preemptive Multitasking) 和 协作式多任务处理 (Cooperative Multitasking) 两种主要模式。纤程 (Fiber) 通常采用 协作式多任务处理 (Cooperative Multitasking) 模型。
什么是协作式多任务处理？ (What is Cooperative Multitasking?)
在 协作式多任务处理 (Cooperative Multitasking) 中，任务 (例如 Fiber) 主动放弃 CPU 执行权，将控制权交还给调度器，调度器再选择下一个要运行的任务。任务何时让出 CPU 完全由任务自身决定。如果一个任务一直占用 CPU 而不主动让出，那么其他任务就无法得到执行。
Fiber 的协作式多任务处理机制 (Cooperative Multitasking Mechanism of Fibers)
Folly Fiber 基于 协作式多任务处理 (Cooperative Multitasking) 模型。这意味着：
⚝ Fiber 主动让出 CPU (Fiber Yields CPU Voluntarily)： Fiber 在执行过程中，需要显式地调用某些操作来让出 CPU 执行权，例如：
▮▮▮▮⚝ folly::fibers::Fiber::yield()： Fiber 主动放弃 CPU，允许调度器调度其他 Fiber 运行。
▮▮▮▮⚝ 等待操作 (Waiting Operations)： 例如 folly::fibers::Baton::wait()、folly::futures::Future::wait() 等，当 Fiber 等待某个事件发生时，它会挂起自身并让出 CPU。
▮▮▮▮⚝ 非阻塞 I/O 操作 (Non-blocking I/O Operations)： Fiber 应该尽量使用非阻塞 I/O 操作，当 I/O 操作未完成时，Fiber 可以挂起等待 I/O 事件，而不是阻塞线程。
⚝ 调度器被动调度 (Scheduler Dispatches Passively)： Fiber 调度器 (Fiber Scheduler) 只有在当前运行的 Fiber 主动让出 CPU 时，才会介入调度，选择下一个要运行的 Fiber。调度器本身不会强制抢占正在运行的 Fiber 的 CPU 执行权。
协作式多任务处理的特点 (Characteristics of Cooperative Multitasking)
⚝ 简单性 (Simplicity)： 协作式多任务处理的实现相对简单，调度逻辑也比较清晰。
⚝ 低开销 (Low Overhead)： 由于任务切换由任务自身控制，避免了抢占式调度带来的额外开销，上下文切换效率高。
⚝ 可预测性 (Predictability)： 任务的执行顺序和时间相对可预测，因为任务何时让出 CPU 是确定的。
⚝ 依赖任务的协作 (Reliance on Task Cooperation)： 协作式多任务处理的正确运行依赖于所有任务的良好协作。如果某个任务拒绝让出 CPU，或者执行了阻塞操作，可能会导致整个系统停顿或响应缓慢。
协作式多任务处理与抢占式多任务处理的比较 (Comparison with Preemptive Multitasking)
| 特性 (Feature) | 协作式多任务处理 (Cooperative Multitasking) | 抢占式多任务处理 (Preemptive Multitasking) |
|---|---|---|
| 任务切换控制 (Task Switching Control) | 任务主动让出 CPU | 操作系统调度器抢占式调度 |
| 调度器介入 (Scheduler Intervention) | 被动调度，仅在任务主动让出 CPU 时介入 | 主动调度，周期性或根据优先级抢占 CPU |
| 任务协作 (Task Cooperation) | 依赖任务的良好协作，任务必须主动让出 CPU | 任务之间无需显式协作，操作系统保证公平调度 |
| 鲁棒性 (Robustness) | 鲁棒性较差，单个任务的错误行为可能影响整个系统 | 鲁棒性较好，单个任务的错误行为通常不会影响其他任务 |
| 实时性 (Real-time Performance) | 实时性较差，难以保证任务的及时响应 | 实时性较好，可以根据优先级和调度策略保证高优先级任务的及时响应 |
| 实现复杂度 (Implementation Complexity) | 实现相对简单 | 实现相对复杂，需要操作系统内核支持 |
| 适用场景 (Suitable Scenarios) | I/O 密集型、高并发、对任务协作性要求较高的场景，例如网络服务器、游戏服务器等 | CPU 密集型、多进程、需要保证公平性和鲁棒性的场景，例如桌面应用、通用操作系统等 |
Folly Fiber 为什么选择协作式多任务处理？ (Why Cooperative Multitasking for Folly Fibers?)
Folly Fiber 选择 协作式多任务处理 (Cooperative Multitasking)，主要是因为：
⚝ 追求极致性能 (Pursuit of Extreme Performance)： 协作式多任务处理的上下文切换开销极低，可以最大程度地提高并发性能，这与 Folly Fiber 的设计目标一致。
⚝ 简化异步编程 (Simplified Asynchronous Programming)： 协作式模型更符合人类的思维习惯，可以将异步逻辑写得更像同步代码，降低异步编程的复杂性。
⚝ 适用于特定场景 (Suitable for Specific Scenarios)： Folly Fiber 主要应用于高性能网络编程、异步任务处理等 I/O 密集型场景，这些场景通常对性能要求极高，且任务之间具有一定的协作性。
编程注意事项 (Programming Considerations)
在使用 Folly Fiber 进行协作式多任务编程时，需要注意以下几点：
⚝ 避免长时间阻塞操作 (Avoid Long-Blocking Operations)： 在 Fiber 中应尽量避免执行长时间的同步阻塞操作，例如阻塞 I/O、长时间计算等。如果必须进行 I/O 操作，应使用非阻塞 I/O，并配合 Fiber 的挂起和恢复机制。
⚝ 主动让出 CPU (Yield CPU Voluntarily)： 在适当的时候调用 folly::fibers::Fiber::yield() 让出 CPU，避免某个 Fiber 长时间占用 CPU 导致其他 Fiber 无法执行。
⚝ 设计良好的协作机制 (Design Good Cooperation Mechanisms)： 在多个 Fiber 协同工作时，需要设计良好的协作机制，例如使用 Baton、Future/Promise 等同步原语，确保 Fiber 之间的正确同步和通信。
总而言之，协作式多任务处理 (Cooperative Multitasking) 是 Folly Fiber 的核心特性之一。理解协作式模型的原理和特点，并遵循相关的编程注意事项，可以帮助我们充分发挥 Folly Fiber 的性能优势，构建高效、稳定的并发应用。
2.5 Fiber 调度器 (Fiber Scheduler)
Fiber 调度器 (Fiber Scheduler) 是 纤程 (Fiber) 运行时环境的核心组件，负责管理和调度 Fiber 的执行。它决定了哪些 Fiber 应该在何时、何地 (在哪个 执行单元 (Execution Unit) 上) 运行。Folly Fiber 的调度器设计灵活且可配置，允许开发者根据不同的应用场景选择合适的调度策略。
Fiber 调度器的角色与职责 (Role and Responsibilities of Fiber Scheduler)
Fiber 调度器的主要角色和职责包括：
- 管理 Fiber 就绪队列 (Manage Fiber Ready Queue)： 维护一个或多个 就绪队列 (Ready Queue)，用于存放处于 就绪 (Ready) 状态的 Fiber。当 Fiber 被创建、恢复或从挂起状态变为就绪状态时，调度器将其添加到就绪队列中。
- 选择下一个要运行的 Fiber (Select Next Fiber to Run)： 根据一定的 调度策略 (Scheduling Policy)，从就绪队列中选择下一个要运行的 Fiber。常见的调度策略包括 FIFO (先进先出)、优先级调度、轮询调度等。
- 将 Fiber 调度到执行单元 (Dispatch Fiber to Execution Unit)： 将选定的 Fiber 调度到一个 执行单元 (Execution Unit) 上运行。在 Folly Fiber 中，执行单元通常是 线程池 (Thread Pool) 中的线程。调度器负责将 Fiber 的上下文加载到线程的上下文中，并启动 Fiber 的执行。
- 处理 Fiber 的挂起与恢复 (Handle Fiber Suspension and Resumption)： 当 Fiber 调用挂起操作 (例如
yield(),wait()) 时，调度器负责将 Fiber 从运行状态转换为挂起状态，并将其从执行单元上移除。当挂起条件满足时，调度器负责将 Fiber 恢复为就绪状态，并重新加入就绪队列等待调度。 - 资源管理 (Resource Management)： 调度器可能还负责一些资源管理工作，例如 Fiber 栈的分配和回收、执行单元的管理等。
- 调度策略配置 (Scheduling Policy Configuration)： 提供配置接口，允许用户自定义或选择不同的调度策略，以适应不同的应用场景需求。
Folly Fiber 调度器的架构 (Architecture of Folly Fiber Scheduler)
Folly Fiber 的调度器架构相对灵活，主要组件包括：
⚝ FiberManager (Fiber 管理器)： FiberManager 是 Fiber 的管理中心，负责创建、管理和调度 Fiber。每个 FiberManager 实例都关联一个 Fiber 调度器。
⚝ Ready Queue (就绪队列)： 用于存放处于就绪状态的 Fiber。Folly Fiber 允许配置不同的就绪队列实现，例如单队列、多队列等。
⚝ Execution Unit (执行单元)： 执行 Fiber 代码的实体，通常是线程池中的线程。FiberManager 内部维护一个线程池，用于执行调度的 Fiber。
⚝ Scheduling Policy (调度策略)： 决定调度器如何选择下一个要运行的 Fiber 的算法。Folly Fiber 提供了默认的调度策略，也允许用户自定义调度策略。
Folly Fiber 的默认调度策略 (Default Scheduling Policy of Folly Fiber)
Folly Fiber 默认采用一种基于 工作窃取 (Work-Stealing) 的调度策略。其核心思想是：
⚝ 多就绪队列 (Multiple Ready Queues)： 每个执行单元 (线程) 都有自己的本地就绪队列 (Local Ready Queue)。
⚝ 本地调度优先 (Local Dispatching Priority)： 调度器优先从当前执行单元的本地就绪队列中选择 Fiber 运行，以提高缓存局部性，减少跨线程的竞争。
⚝ 工作窃取 (Work Stealing)： 当某个执行单元的本地就绪队列为空时，它可以从其他执行单元的就绪队列中 "窃取" Fiber 来执行，以实现负载均衡，充分利用多核 CPU 的性能。
自定义 Fiber 调度策略 (Custom Fiber Scheduling Policies)
Folly Fiber 允许用户自定义 Fiber 调度策略，以满足特定的应用需求。用户可以通过继承 folly::fibers::Scheduler 类，并实现自定义的调度算法，然后将自定义的调度器配置给 FiberManager 使用。
自定义调度策略可以用于实现各种高级调度特性，例如：
⚝ 优先级调度 (Priority Scheduling)： 根据 Fiber 的优先级进行调度，保证高优先级 Fiber 优先执行。
⚝ 公平调度 (Fair Scheduling)： 保证所有 Fiber 都能公平地获得 CPU 执行时间。
⚝ 实时调度 (Real-time Scheduling)： 针对实时性要求较高的应用，实现基于截止时间的调度策略。
⚝ 资源感知调度 (Resource-Aware Scheduling)： 根据 Fiber 的资源需求和系统资源状况进行调度，优化资源利用率。
Fiber 调度器与 FiberManager 的关系 (Relationship between Fiber Scheduler and FiberManager)
FiberScheduler 和 FiberManager 在 Folly Fiber 中紧密协作，共同完成 Fiber 的管理和调度：
⚝ FiberManager 是 Fiber 的管理入口，负责创建、添加、启动、停止 Fiber，以及配置 Fiber 运行时环境 (例如调度器、执行单元等)。
⚝ FiberScheduler 是 FiberManager 的内部组件，负责具体的 Fiber 调度算法和执行策略。FiberManager 通过调用 FiberScheduler 的接口来完成 Fiber 的调度操作。
⚝ 一个 FiberManager 实例通常关联一个 FiberScheduler 实例。用户可以通过配置 FiberManager 来选择或自定义 FiberScheduler。
总结 (Summary)
Fiber 调度器 (Fiber Scheduler) 是 Folly Fiber 框架的核心组件，负责 Fiber 的调度和执行管理。Folly Fiber 提供了灵活可配置的调度器架构，默认采用基于 工作窃取 (Work-Stealing) 的高性能调度策略，同时也支持用户自定义调度策略，以满足各种应用场景的需求。理解 Fiber 调度器的工作原理和配置方式，对于深入掌握 Folly Fiber 并构建高性能并发应用至关重要。在后续章节中，我们将结合 API 详解和实战案例，进一步探讨 Fiber 调度器的使用和高级应用。
END_OF_CHAPTER
3. chapter 3： FiberManager 详解 (In-depth FiberManager)
3.1 FiberManager 的架构设计 (FiberManager Architecture Design)
FiberManager 是 Folly Fiber 库中的核心组件，它负责管理和调度 Fiber 的执行。理解 FiberManager 的架构设计对于深入掌握 Folly Fiber 的运作机制至关重要。FiberManager 的设计目标是提供一个高效、灵活且可扩展的 Fiber 管理框架，以支持各种高性能并发应用场景。
FiberManager 的架构可以概括为以下几个核心组成部分：
① Fiber 调度器 (Fiber Scheduler)：这是 FiberManager 的大脑，负责决定哪个 Fiber 应该在何时运行。Folly Fiber 提供了多种调度器实现，包括单线程调度器、多线程调度器以及自定义调度器。调度器的选择直接影响 Fiber 的并发性能和资源利用率。
② 就绪队列 (Ready Queue)：用于存放等待被调度的 Fiber。当一个 Fiber 准备好运行时，它会被加入到就绪队列中。调度器会从就绪队列中选择 Fiber 进行调度执行。
③ 休眠队列 (Sleep Queue)：用于存放暂时休眠的 Fiber。当 Fiber 执行 fiber::sleep() 等操作时，会被放入休眠队列。FiberManager 会定期检查休眠队列，将到期的 Fiber 移回就绪队列。
④ Fiber 上下文 (Fiber Context)：每个 Fiber 都有自己的上下文，包括栈空间、寄存器状态等。FiberManager 负责管理 Fiber 上下文的创建、销毁和切换。
⑤ Fiber 池 (Fiber Pool) (可选)：为了提高 Fiber 创建和销毁的效率，FiberManager 可以使用 Fiber 池来复用 Fiber 对象。Fiber 池可以减少内存分配和释放的开销，特别是在需要频繁创建和销毁 Fiber 的场景下。
⑥ Hook 机制 (Hook Mechanism)：FiberManager 提供了 Hook 机制，允许用户在 Fiber 的生命周期关键点（如创建、启动、切换、结束等）插入自定义逻辑。这为监控、调试和扩展 Fiber 功能提供了便利。
架构图示
为了更直观地理解 FiberManager 的架构，可以将其简化为一个流程图：
1
graph LR
2
A[Fiber 创建] --> B(FiberManager);
3
B --> C{调度器选择};
4
C -- 就绪 --> D[就绪队列];
5
C -- 休眠 --> E[休眠队列];
6
D --> F[Fiber 调度];
7
F --> G{Fiber 执行};
8
G -- yield/sleep --> C;
9
G -- 完成 --> H[Fiber 销毁/池化];
10
E --> I[定时唤醒];
11
I --> D;
关键设计考量
在 FiberManager 的架构设计中，有几个关键的考量因素：
⚝ 性能 (Performance)：FiberManager 必须高效地管理和调度 Fiber，尽可能减少上下文切换的开销，并充分利用系统资源。
⚝ 可扩展性 (Scalability)：FiberManager 应该能够支持大规模 Fiber 并发，并能够方便地扩展新的调度策略和功能。
⚝ 灵活性 (Flexibility)：FiberManager 应该提供足够的灵活性，以适应不同的应用场景和用户需求，例如支持自定义调度器、Hook 机制等。
⚝ 易用性 (Usability)：FiberManager 的 API 应该简洁易用，方便开发者快速上手并构建基于 Fiber 的应用。
总而言之，FiberManager 的架构设计围绕着高效的 Fiber 管理和调度展开，旨在为开发者提供一个强大而灵活的并发编程工具。通过理解其内部架构，开发者可以更好地利用 Folly Fiber 构建高性能、高并发的应用。
3.2 FiberManager 的核心功能 (Core Functions of FiberManager)
FiberManager 作为 Folly Fiber 的核心组件，提供了一系列关键功能，用于 Fiber 的生命周期管理、调度执行以及资源控制。这些核心功能共同协作，使得开发者能够方便、高效地使用 Fiber 进行并发编程。
FiberManager 的核心功能可以归纳为以下几个方面：
① Fiber 创建与销毁 (Fiber Creation and Destruction)：
▮▮▮▮⚝ FiberManager 提供了创建 Fiber 的接口，例如 FiberManager::start() 等方法。这些方法允许用户指定 Fiber 的执行体 (entry point function)、栈大小、优先级等属性。
▮▮▮▮⚝ FiberManager 负责 Fiber 对象的生命周期管理，包括分配 Fiber 上下文、初始化 Fiber 状态、以及在 Fiber 执行结束后回收资源。
▮▮▮▮⚝ 为了提高效率，FiberManager 可以选择使用 Fiber 池来复用 Fiber 对象，避免频繁的内存分配和释放。
② Fiber 调度与执行 (Fiber Scheduling and Execution)：
▮▮▮▮⚝ FiberManager 内置了 Fiber 调度器，负责从就绪队列中选择 Fiber 进行调度执行。
▮▮▮▮⚝ 调度器根据预定的调度策略（例如 FIFO、优先级调度等）来决定 Fiber 的执行顺序。
▮▮▮▮⚝ FiberManager 负责 Fiber 的上下文切换，保存当前 Fiber 的状态，恢复下一个 Fiber 的状态，并切换 CPU 执行流。
▮▮▮▮⚝ FiberManager 提供了 yield() 和 sleep() 等操作，允许 Fiber 主动让出 CPU 执行权，实现协作式多任务处理。
③ Fiber 同步与通信 (Fiber Synchronization and Communication)：
▮▮▮▮⚝ FiberManager 及其相关的 Fiber 类提供了多种同步机制，例如互斥锁 (mutex)、条件变量 (condition variable)、信号量 (semaphore) 等，用于 Fiber 之间的同步和互斥访问共享资源。
▮▮▮▮⚝ Folly Fiber 还提供了 Baton 等轻量级的同步原语，方便 Fiber 之间的事件通知和等待。
▮▮▮▮⚝ 通过这些同步机制，可以构建复杂的并发逻辑，保证数据一致性和程序正确性。
④ Fiber 局部存储 (Fiber-Local Storage, FLS)：
▮▮▮▮⚝ FiberManager 提供了 Fiber 局部存储 (FLS) 的功能，允许每个 Fiber 拥有独立的、线程安全的局部变量。
▮▮▮▮⚝ FLS 可以避免在 Fiber 之间传递上下文参数，简化代码，并提高性能。
▮▮▮▮⚝ FiberManager 负责 FLS 的分配、初始化和销毁，确保 FLS 的生命周期与 Fiber 的生命周期一致。
⑤ Fiber 监控与调试 (Fiber Monitoring and Debugging)：
▮▮▮▮⚝ FiberManager 提供了 Hook 机制，允许用户在 Fiber 的生命周期关键点插入自定义逻辑，用于监控 Fiber 的运行状态、性能指标等。
▮▮▮▮⚝ 通过 Hook 机制，可以实现 Fiber 的性能分析、资源监控、错误诊断等功能。
▮▮▮▮⚝ FiberManager 还可以与调试工具集成，方便开发者进行 Fiber 程序的调试。
⑥ 资源管理与控制 (Resource Management and Control)：
▮▮▮▮⚝ FiberManager 负责管理 Fiber 运行所需的系统资源，例如栈空间、CPU 时间片等。
▮▮▮▮⚝ FiberManager 可以限制 Fiber 的数量、栈大小等资源使用，防止资源耗尽。
▮▮▮▮⚝ 通过配置 FiberManager 的参数，可以调整 Fiber 的资源分配策略，以适应不同的应用场景。
综上所述，FiberManager 的核心功能涵盖了 Fiber 生命周期的各个阶段，从创建到销毁，从调度到同步，从监控到资源管理。这些功能相互配合，为开发者提供了一个完善的 Fiber 并发编程平台。掌握 FiberManager 的核心功能是深入理解和应用 Folly Fiber 的关键。
3.3 创建和管理 Fiber (Creating and Managing Fibers)
FiberManager 的主要职责之一是创建和管理 Fiber。本节将详细介绍如何使用 FiberManager 创建 Fiber，以及如何对 Fiber 进行有效的管理，包括启动、停止、等待等操作。
Fiber 的创建
创建 Fiber 的核心方法是使用 FiberManager::start() 函数。start() 函数有多个重载版本，可以接受不同类型的 Fiber 执行体 (Fiber routine) 和参数。
最常用的 start() 函数原型如下：
1
template <typename Func, typename... Args>
2
Fiber& start(Func&& func, Args&&... args);
这个函数接受一个函数对象 func 和一组参数 args，返回一个 Fiber 对象的引用。func 就是 Fiber 要执行的任务，args 是传递给 func 的参数。
代码示例：创建一个简单的 Fiber
1
#include <folly/fibers/FiberManager.h>
2
#include <folly/fibers/Fiber.h>
3
#include <iostream>
4
5
using namespace folly;
6
using namespace fibers;
7
8
void fiber_task(int id) {
9
std::cout << "Fiber " << id << " started" << std::endl;
10
fiber::sleep(std::chrono::milliseconds(100)); // 模拟 Fiber 执行任务
11
std::cout << "Fiber " << id << " finished" << std::endl;
12
}
13
14
int main() {
15
FiberManager fm;
16
fm.start(fiber_task, 1); // 创建并启动 Fiber 1
17
fm.start(fiber_task, 2); // 创建并启动 Fiber 2
18
fm.start(fiber_task, 3); // 创建并启动 Fiber 3
19
fm.join(); // 等待所有 Fiber 执行完成
20
return 0;
21
}
代码解释：
⚝ 首先，创建了一个 FiberManager 对象 fm。
⚝ 然后，使用 fm.start(fiber_task, id) 创建并启动了三个 Fiber，分别执行 fiber_task 函数，并传递不同的 ID 参数。
⚝ 最后，调用 fm.join() 等待所有 Fiber 执行完成。join() 函数会阻塞当前线程，直到 FiberManager 管理的所有 Fiber 都执行结束。
Fiber 的启动
FiberManager::start() 函数在创建 Fiber 的同时，也会立即启动 Fiber 的执行。Fiber 的执行体函数 fiber_task 会在 Fiber 的上下文中被调用。
Fiber 的管理
FiberManager 提供了一些方法来管理 Fiber 的生命周期和状态：
⚝ join(): 等待 FiberManager 管理的所有 Fiber 执行完成。这是一个阻塞操作，会暂停当前线程的执行，直到所有 Fiber 都结束。
⚝ join_fiber(Fiber& fiber): 等待指定的 Fiber 对象 fiber 执行完成。也是一个阻塞操作，只等待特定的 Fiber 结束。
⚝ stop(): 停止 FiberManager 的调度器，并尝试停止所有正在运行的 Fiber。这是一个异步操作，不会立即停止 Fiber 的执行，而是向 Fiber 发送停止信号。Fiber 需要自行检查停止信号并做出响应。
⚝ isStopped(): 检查 FiberManager 是否已经停止。
⚝ activeFiberCount(): 获取当前 FiberManager 中活跃的 Fiber 数量（包括正在运行和就绪的 Fiber）。
Fiber 的等待
FiberManager::join() 和 FiberManager::join_fiber() 函数用于等待 Fiber 执行完成。join() 等待所有 Fiber，而 join_fiber() 只等待指定的 Fiber。
代码示例：使用 join_fiber() 等待特定 Fiber
1
#include <folly/fibers/FiberManager.h>
2
#include <folly/fibers/Fiber.h>
3
#include <iostream>
4
5
using namespace folly;
6
using namespace fibers;
7
8
void fiber_task_long(int id) {
9
std::cout << "Long Fiber " << id << " started" << std::endl;
10
fiber::sleep(std::chrono::seconds(5)); // 模拟长时间任务
11
std::cout << "Long Fiber " << id << " finished" << std::endl;
12
}
13
14
void fiber_task_short(int id) {
15
std::cout << "Short Fiber " << id << " started" << std::endl;
16
fiber::sleep(std::chrono::milliseconds(100)); // 模拟短时间任务
17
std::cout << "Short Fiber " << id << " finished" << std::endl;
18
}
19
20
int main() {
21
FiberManager fm;
22
Fiber& long_fiber = fm.start(fiber_task_long, 1); // 创建并启动长时间 Fiber
23
fm.start(fiber_task_short, 2); // 创建并启动短时间 Fiber
24
fm.start(fiber_task_short, 3); // 创建并启动短时间 Fiber
25
26
fm.join_fiber(long_fiber); // 只等待长时间 Fiber 执行完成
27
std::cout << "Long Fiber joined, but short fibers may still be running." << std::endl;
28
fm.join(); // 等待剩余的所有 Fiber 执行完成
29
return 0;
30
}
代码解释：
⚝ 创建了一个长时间运行的 Fiber long_fiber 和两个短时间运行的 Fiber。
⚝ 使用 fm.join_fiber(long_fiber) 只等待 long_fiber 执行完成。
⚝ 之后，即使短时间 Fiber 可能还在运行，程序也会继续执行。
⚝ 最后，调用 fm.join() 确保所有 Fiber 都执行完成。
Fiber 的停止
FiberManager::stop() 函数用于停止 FiberManager 的调度器和 Fiber 的执行。但是，Fiber 的停止是协作式的，Fiber 需要主动检查停止信号并做出响应。
代码示例：协作式停止 Fiber
1
#include <folly/fibers/FiberManager.h>
2
#include <folly/fibers/Fiber.h>
3
#include <iostream>
4
5
using namespace folly;
6
using namespace fibers;
7
8
void fiber_task_cancellable(int id) {
9
std::cout << "Cancellable Fiber " << id << " started" << std::endl;
10
for (int i = 0; i < 10; ++i) {
11
if (fiber::isCancelled()) { // 检查 Fiber 是否被取消
12
std::cout << "Cancellable Fiber " << id << " cancelled after " << i << " iterations." << std::endl;
13
return; // 响应取消信号，提前退出
14
}
15
std::cout << "Cancellable Fiber " << id << " iteration " << i << std::endl;
16
fiber::sleep(std::chrono::milliseconds(500));
17
}
18
std::cout << "Cancellable Fiber " << id << " finished normally." << std::endl;
19
}
20
21
int main() {
22
FiberManager fm;
23
fm.start(fiber_task_cancellable, 1); // 创建并启动可取消 Fiber
24
25
std::this_thread::sleep_for(std::chrono::seconds(2)); // 等待一段时间
26
fm.stop(); // 发送停止信号
27
28
fm.join(); // 等待所有 Fiber 执行完成 (包括被取消的 Fiber)
29
std::cout << "FiberManager stopped." << std::endl;
30
return 0;
31
}
代码解释：
⚝ fiber_task_cancellable 函数在循环中定期检查 fiber::isCancelled() 函数，判断 Fiber 是否被取消。
⚝ 在 main 函数中，启动一个可取消的 Fiber 后，等待 2 秒，然后调用 fm.stop() 发送停止信号。
⚝ Fiber 在下次循环迭代时会检测到取消信号，并提前退出。
总结
FiberManager 提供了丰富的 API 来创建和管理 Fiber。开发者可以使用 start() 创建并启动 Fiber，使用 join() 和 join_fiber() 等待 Fiber 完成，使用 stop() 停止 Fiber 的执行。理解这些 API 的用法，可以有效地控制 Fiber 的生命周期，构建复杂的并发应用。
3.4 Fiber 池化技术 (Fiber Pooling Technology)
在高性能并发应用中，频繁地创建和销毁 Fiber 可能会带来显著的性能开销，尤其是在 Fiber 执行的任务非常轻量级的情况下。为了解决这个问题，FiberManager 引入了 Fiber 池化 (Fiber Pooling) 技术。
什么是 Fiber 池化？
Fiber 池化是一种对象池 (Object Pool) 模式的应用，它预先创建一组 Fiber 对象，并将这些对象保存在一个池中。当需要执行新的 Fiber 任务时，FiberManager 从池中获取一个空闲的 Fiber 对象，分配任务给它执行，而不是每次都重新创建 Fiber。当 Fiber 任务执行完成后，Fiber 对象不会被立即销毁，而是返回到池中，等待下次复用。
Fiber 池化的优势
① 减少对象创建和销毁开销：Fiber 的创建和销毁涉及到内存分配、栈空间分配、上下文初始化等操作，这些操作都有一定的开销。Fiber 池化通过复用 Fiber 对象，避免了频繁的创建和销毁，从而降低了开销，提高了性能。
② 提高响应速度：从池中获取 Fiber 对象通常比重新创建 Fiber 对象更快。这可以减少任务的启动延迟，提高系统的响应速度，尤其是在高并发、低延迟的应用场景中。
③ 平滑资源使用：Fiber 池预先分配一定数量的 Fiber 对象，可以平滑系统的资源使用，避免在高峰期突然出现大量的 Fiber 创建请求，导致系统资源紧张。
Fiber 池化的实现
FiberManager 的 Fiber 池化实现通常包括以下几个关键组件：
⚝ Fiber 池 (Fiber Pool)：用于存储空闲 Fiber 对象的容器，通常使用队列 (queue) 或栈 (stack) 等数据结构实现。
⚝ Fiber 对象：预先创建的 Fiber 对象，包含 Fiber 上下文、栈空间等资源。
⚝ Fiber 分配器 (Fiber Allocator)：负责从 Fiber 池中获取空闲 Fiber 对象，并在池为空时创建新的 Fiber 对象。
⚝ Fiber 回收器 (Fiber Reclaimer)：负责在 Fiber 任务执行完成后，将 Fiber 对象返回到 Fiber 池中。
Folly Fiber 中的 Fiber 池化
Folly Fiber 的 FiberManager 默认情况下并不启用 Fiber 池化。但是，可以通过自定义 FiberManager 的配置来启用 Fiber 池化。
配置 Fiber 池化
可以通过 FiberManager::Options 来配置 Fiber 池化相关的参数，例如：
⚝ fiberPoolSize: 设置 Fiber 池的初始大小和最大大小。
⚝ fiberStackSize: 设置 Fiber 的栈大小。
⚝ enableFiberPool: 启用或禁用 Fiber 池化。
代码示例：启用 Fiber 池化的 FiberManager
1
#include <folly/fibers/FiberManager.h>
2
#include <folly/fibers/Fiber.h>
3
#include <iostream>
4
5
using namespace folly;
6
using namespace fibers;
7
8
void fiber_task_pool(int id) {
9
std::cout << "Pooled Fiber " << id << " started" << std::endl;
10
fiber::sleep(std::chrono::milliseconds(50)); // 模拟轻量级任务
11
std::cout << "Pooled Fiber " << id << " finished" << std::endl;
12
}
13
14
int main() {
15
FiberManager::Options options;
16
options.enableFiberPool = true; // 启用 Fiber 池化
17
options.fiberPoolSize = 10; // 设置 Fiber 池大小为 10
18
19
FiberManager fm(options); // 使用配置选项创建 FiberManager
20
21
for (int i = 0; i < 20; ++i) { // 创建 20 个 Fiber 任务
22
fm.start(fiber_task_pool, i);
23
}
24
fm.join();
25
return 0;
26
}
代码解释：
⚝ 创建 FiberManager::Options 对象 options，并设置 enableFiberPool = true 和 fiberPoolSize = 10，启用 Fiber 池化，并将池大小设置为 10。
⚝ 使用配置选项 options 创建 FiberManager 对象 fm。
⚝ 循环创建 20 个 Fiber 任务，由于启用了 Fiber 池化，FiberManager 会尝试从池中获取 Fiber 对象复用，而不是每次都重新创建。
Fiber 池化的适用场景
Fiber 池化技术特别适用于以下场景：
⚝ 任务轻量级，创建频繁：当 Fiber 执行的任务非常轻量级，但创建频率很高时，Fiber 创建和销毁的开销会成为性能瓶颈。Fiber 池化可以有效缓解这个问题。
⚝ 高并发，低延迟：在需要快速响应请求的高并发系统中，减少任务启动延迟至关重要。Fiber 池化可以提高任务的启动速度，降低延迟。
⚝ 资源敏感型应用：对于资源受限的系统，预先分配 Fiber 池可以更好地控制资源使用，避免资源耗尽。
Fiber 池化的局限性
Fiber 池化并非万能的，它也有一些局限性：
⚝ 内存占用：Fiber 池会预先分配一定数量的 Fiber 对象，即使在低负载时也会占用一定的内存。如果 Fiber 池设置过大，可能会造成内存浪费。
⚝ 复杂性增加：引入 Fiber 池化会增加 FiberManager 的复杂性，需要考虑池的维护、对象的分配和回收等问题。
⚝ 不适用所有场景：对于 Fiber 任务执行时间较长，或者 Fiber 创建频率不高的情况，Fiber 池化的收益可能不明显，甚至可能因为池的维护开销而降低性能。
总结
Fiber 池化是一种有效的性能优化技术，可以减少 Fiber 创建和销毁的开销，提高系统的响应速度和资源利用率。在 Folly Fiber 中，可以通过配置 FiberManager::Options 来启用和配置 Fiber 池化。开发者需要根据具体的应用场景，权衡 Fiber 池化的优势和局限性，选择是否使用 Fiber 池化技术。
3.5 自定义 Fiber 调度策略 (Custom Fiber Scheduling Policies)
FiberManager 的核心功能之一是 Fiber 调度。默认情况下，FiberManager 使用基于 FIFO (First-In, First-Out) 的简单调度策略。然而，在某些复杂的应用场景中，可能需要更精细的调度策略，例如优先级调度、公平调度、实时调度等。FiberManager 提供了自定义调度策略的机制，允许开发者根据需求定制 Fiber 的调度行为。
为什么需要自定义调度策略？
默认的 FIFO 调度策略虽然简单高效，但在某些情况下可能无法满足需求：
⚝ 优先级需求：某些 Fiber 任务可能比其他任务更重要，需要优先执行。例如，在实时系统中，需要优先调度处理实时事件的 Fiber。
⚝ 公平性需求：在多用户或多任务系统中，可能需要保证每个 Fiber 任务都能获得公平的 CPU 时间片，避免某些任务长时间饥饿。
⚝ 资源限制：某些任务可能需要限制其 CPU 使用率，避免过度占用资源，影响其他任务的执行。
⚝ 特殊调度算法：某些应用可能需要特定的调度算法，例如最短作业优先 (Shortest Job First, SJF)、轮询调度 (Round Robin) 等。
自定义调度器的接口
要实现自定义的 Fiber 调度策略，需要创建一个自定义的调度器类，并实现 FiberScheduler 接口。FiberScheduler 是一个抽象基类，定义了 Fiber 调度器需要实现的方法。
FiberScheduler 接口 (简化版) 主要包含以下方法：
1
class FiberScheduler {
2
public:
3
virtual ~FiberScheduler() = default;
4
5
virtual void schedule(Fiber& fiber) = 0; // 调度 Fiber 到就绪队列
6
7
virtual Fiber* next() = 0; // 从就绪队列中选择下一个要执行的 Fiber
8
9
virtual void preempt() = 0; // 强制当前 Fiber 让出 CPU
10
11
virtual void onFiberExit(Fiber& fiber) = 0; // Fiber 执行结束回调
12
13
// ... 其他方法 ...
14
};
关键方法解释：
⚝ schedule(Fiber& fiber): 将 Fiber 加入到调度器的就绪队列中，等待调度执行。
⚝ next(): 从调度器的就绪队列中选择下一个要执行的 Fiber。调度器根据自身的调度策略来决定选择哪个 Fiber。如果就绪队列为空，则返回 nullptr。
⚝ preempt(): 强制当前正在运行的 Fiber 让出 CPU 执行权，调度器可以重新选择下一个要执行的 Fiber。
⚝ onFiberExit(Fiber& fiber): 当 Fiber 执行结束后，FiberManager 会调用此方法通知调度器。调度器可以在此方法中进行一些清理工作。
实现自定义调度器
要实现自定义调度器，需要继承 FiberScheduler 类，并实现上述接口方法。
代码示例：一个简单的优先级调度器
1
#include <folly/fibers/FiberScheduler.h>
2
#include <folly/fibers/Fiber.h>
3
#include <queue>
4
#include <iostream>
5
6
using namespace folly;
7
using namespace fibers;
8
9
class PriorityScheduler : public FiberScheduler {
10
public:
11
PriorityScheduler() = default;
12
~PriorityScheduler() override = default;
13
14
void schedule(Fiber& fiber) override {
15
ready_queue_.push(fiber.get()); // 将 Fiber 加入优先级队列
16
}
17
18
Fiber* next() override {
19
if (ready_queue_.empty()) {
20
return nullptr;
21
}
22
Fiber* fiber = ready_queue_.top(); // 获取优先级最高的 Fiber
23
ready_queue_.pop();
24
return fiber;
25
}
26
27
void preempt() override {
28
// 优先级调度器通常不需要 preempt 操作，因为 Fiber 会主动 yield
29
}
30
31
void onFiberExit(Fiber& fiber) override {
32
// Fiber 退出回调，可以进行清理工作
33
}
34
35
private:
36
std::priority_queue<Fiber*, std::vector<Fiber*>, [](Fiber* a, Fiber* b) {
37
return a->priority() > b->priority(); // 优先级队列，优先级高的 Fiber 在队首
38
}> ready_queue_;
39
};
代码解释：
⚝ PriorityScheduler 继承自 FiberScheduler。
⚝ 使用 std::priority_queue 作为就绪队列，存储 Fiber 指针。优先级队列根据 Fiber 的优先级 (假设 Fiber 类有 priority() 方法) 进行排序，优先级高的 Fiber 在队首。
⚝ schedule() 方法将 Fiber 加入优先级队列。
⚝ next() 方法从优先级队列中取出队首元素 (优先级最高的 Fiber)。
⚝ preempt() 方法在优先级调度器中通常不需要实现，因为 Fiber 的切换通常由 Fiber 主动 yield 或阻塞操作触发。
使用自定义调度器
要使用自定义调度器，需要在创建 FiberManager 时，将自定义调度器对象传递给 FiberManager 的构造函数。
代码示例：使用优先级调度器的 FiberManager
1
#include <folly/fibers/FiberManager.h>
2
#include <folly/fibers/Fiber.h>
3
#include <iostream>
4
5
// ... (PriorityScheduler 的定义，同上例) ...
6
7
using namespace folly;
8
using namespace fibers;
9
10
void fiber_task_priority(int id, int priority) {
11
fiber::setCurrentFiberPriority(priority); // 设置 Fiber 优先级
12
std::cout << "Priority Fiber " << id << " started with priority " << priority << std::endl;
13
fiber::sleep(std::chrono::milliseconds(100));
14
std::cout << "Priority Fiber " << id << " finished" << std::endl;
15
}
16
17
int main() {
18
PriorityScheduler scheduler; // 创建优先级调度器
19
FiberManager fm(&scheduler); // 使用优先级调度器创建 FiberManager
20
21
fm.start(fiber_task_priority, 1, 1); // 创建优先级为 1 的 Fiber
22
fm.start(fiber_task_priority, 2, 3); // 创建优先级为 3 的 Fiber (更高优先级)
23
fm.start(fiber_task_priority, 3, 2); // 创建优先级为 2 的 Fiber
24
25
fm.join();
26
return 0;
27
}
代码解释：
⚝ 创建 PriorityScheduler 对象 scheduler。
⚝ 在创建 FiberManager 对象 fm 时，将 &scheduler 作为参数传递给构造函数，指定 fm 使用优先级调度器。
⚝ 在 fiber_task_priority 函数中，使用 fiber::setCurrentFiberPriority() 设置 Fiber 的优先级。
⚝ 创建了三个 Fiber，优先级分别为 1、3、2。由于使用了优先级调度器，优先级更高的 Fiber (Fiber 2) 会被优先调度执行。
自定义调度策略的注意事项
⚝ 性能：自定义调度器需要高效地实现调度逻辑，避免成为性能瓶颈。
⚝ 正确性：调度策略需要保证 Fiber 的正确调度和执行，避免死锁、饥饿等问题。
⚝ 复杂性：自定义调度器可能会增加系统的复杂性，需要仔细设计和测试。
⚝ 与 Folly Fiber 库的兼容性：自定义调度器需要与 Folly Fiber 库的其他组件（例如 Fiber 类、同步原语等）良好地协同工作。
总结
FiberManager 提供了自定义 Fiber 调度策略的机制，允许开发者根据应用需求定制 Fiber 的调度行为。通过实现 FiberScheduler 接口，并将其传递给 FiberManager，可以灵活地替换默认的 FIFO 调度策略。自定义调度策略可以满足各种复杂的调度需求，例如优先级调度、公平调度、实时调度等，从而更好地优化 Fiber 应用的性能和资源利用率。
3.6 FiberManager 的配置与扩展 (Configuration and Extension of FiberManager)
FiberManager 不仅提供了核心的 Fiber 管理和调度功能，还提供了丰富的配置选项和扩展机制，允许开发者根据具体的应用场景进行定制和优化。本节将介绍 FiberManager 的配置选项和扩展方式。
FiberManager 的配置选项
FiberManager 的配置选项主要通过 FiberManager::Options 结构体来设置。在创建 FiberManager 对象时，可以将 Options 对象作为参数传递给构造函数。
FiberManager::Options 结构体包含以下常用的配置选项：
① 调度器配置 (Scheduler Options)：
⚝ scheduler: 指定使用的 Fiber 调度器。可以设置为 nullptr 使用默认的 FIFO 调度器，或者设置为自定义的 FiberScheduler 对象指针。
⚝ numThreads: 设置多线程调度器使用的线程数量。仅当使用多线程调度器时有效。默认为 0，表示使用默认线程数（通常等于 CPU 核心数）。
② Fiber 池配置 (Fiber Pool Options)：
⚝ enableFiberPool: 启用或禁用 Fiber 池化。默认为 false (禁用)。
⚝ fiberPoolSize: 设置 Fiber 池的初始大小和最大大小。默认为 0，表示不限制池大小。
⚝ fiberStackSize: 设置 Fiber 的栈大小。默认为 kDefaultStackSize (通常为 2MB)。
③ Hook 机制配置 (Hook Options)：
⚝ fiberHooks: 设置 Fiber Hook 对象。可以设置为自定义的 FiberHooks 对象指针，用于在 Fiber 生命周期关键点插入自定义逻辑。
④ 其他配置 (Other Options)：
⚝ name: 设置 FiberManager 的名称，用于调试和监控。
⚝ enableCooperativeYield: 启用或禁用协作式 Yield。默认为 true (启用)。
⚝ enablePreemptiveYield: 启用或禁用抢占式 Yield (仅在某些调度器中支持)。默认为 false (禁用)。
代码示例：配置 FiberManager 的选项
1
#include <folly/fibers/FiberManager.h>
2
#include <folly/fibers/Fiber.h>
3
#include <iostream>
4
5
using namespace folly;
6
using namespace fibers;
7
8
int main() {
9
FiberManager::Options options;
10
options.enableFiberPool = true; // 启用 Fiber 池化
11
options.fiberPoolSize = 20; // 设置 Fiber 池大小为 20
12
options.fiberStackSize = 1024 * 128; // 设置 Fiber 栈大小为 128KB
13
options.numThreads = 4; // 设置多线程调度器线程数为 4
14
options.name = "MyFiberManager"; // 设置 FiberManager 名称
15
16
FiberManager fm(options); // 使用配置选项创建 FiberManager
17
18
// ... 使用 fm 创建和管理 Fiber ...
19
20
fm.join();
21
return 0;
22
}
FiberManager 的扩展机制
除了配置选项，FiberManager 还提供了扩展机制，允许开发者更深入地定制 FiberManager 的行为。主要的扩展机制包括：
① 自定义 Fiber 调度器 (Custom Fiber Scheduler)：如 3.5 节所述，可以通过实现 FiberScheduler 接口来创建自定义的 Fiber 调度器，并将其配置到 FiberManager 中。
② Fiber Hook 机制 (Fiber Hook Mechanism)：FiberManager 提供了 Hook 机制，允许用户在 Fiber 的生命周期关键点（如创建、启动、切换、结束等）插入自定义逻辑。通过实现 FiberHooks 接口，可以创建自定义的 Hook 对象，并将其配置到 FiberManager 中。
FiberHooks 接口 (简化版) 主要包含以下方法：
1
class FiberHooks {
2
public:
3
virtual ~FiberHooks() = default;
4
5
virtual void preFiberCreate(FiberManager& fm, Fiber& fiber) {} // Fiber 创建前 Hook
6
virtual void postFiberCreate(FiberManager& fm, Fiber& fiber) {} // Fiber 创建后 Hook
7
8
virtual void preFiberRun(FiberManager& fm, Fiber& fiber) {} // Fiber 运行前 Hook
9
virtual void postFiberRun(FiberManager& fm, Fiber& fiber) {} // Fiber 运行后 Hook
10
11
virtual void preFiberYield(FiberManager& fm, Fiber& fiber) {} // Fiber Yield 前 Hook
12
virtual void postFiberYield(FiberManager& fm, Fiber& fiber) {} // Fiber Yield 后 Hook
13
14
virtual void preFiberExit(FiberManager& fm, Fiber& fiber) {} // Fiber 退出前 Hook
15
virtual void postFiberExit(FiberManager& fm, Fiber& fiber) {} // Fiber 退出后 Hook
16
17
// ... 其他 Hook 方法 ...
18
};
代码示例：自定义 Fiber Hook
1
#include <folly/fibers/FiberManager.h>
2
#include <folly/fibers/Fiber.h>
3
#include <iostream>
4
5
using namespace folly;
6
using namespace fibers;
7
8
class MyFiberHooks : public FiberHooks {
9
public:
10
void preFiberCreate(FiberManager& fm, Fiber& fiber) override {
11
std::cout << "Hook: Fiber creating..." << std::endl;
12
}
13
14
void postFiberCreate(FiberManager& fm, Fiber& fiber) override {
15
std::cout << "Hook: Fiber created." << std::endl;
16
}
17
18
void preFiberRun(FiberManager& fm, Fiber& fiber) override {
19
std::cout << "Hook: Fiber running..." << std::endl;
20
}
21
22
void postFiberRun(FiberManager& fm, Fiber& fiber) override {
23
std::cout << "Hook: Fiber finished running." << std::endl;
24
}
25
};
26
27
void fiber_task_hook(int id) {
28
std::cout << "Fiber " << id << " task executing." << std::endl;
29
fiber::sleep(std::chrono::milliseconds(50));
30
}
31
32
int main() {
33
MyFiberHooks hooks; // 创建自定义 Hook 对象
34
FiberManager::Options options;
35
options.fiberHooks = &hooks; // 设置 Fiber Hook
36
37
FiberManager fm(options); // 使用配置选项创建 FiberManager
38
39
fm.start(fiber_task_hook, 1);
40
fm.join();
41
return 0;
42
}
代码解释：
⚝ MyFiberHooks 继承自 FiberHooks，并重写了 preFiberCreate、postFiberCreate、preFiberRun、postFiberRun 等 Hook 方法，在这些方法中输出日志信息。
⚝ 创建 MyFiberHooks 对象 hooks，并将其地址 &hooks 赋值给 options.fiberHooks，配置 FiberManager 使用自定义 Hook。
⚝ 运行程序，可以看到在 Fiber 的创建和运行前后，Hook 方法被调用，并输出了相应的日志信息。
③ 自定义 Fiber 上下文 (Custom Fiber Context) (高级)：在更高级的场景下，开发者甚至可以自定义 Fiber 的上下文结构，例如自定义栈分配、寄存器保存等。但这通常需要深入理解 Fiber 的底层实现，并且需要谨慎操作，以避免破坏 Fiber 的正常运行。
配置与扩展的应用场景
FiberManager 的配置和扩展机制可以应用于各种场景：
⚝ 性能优化：通过配置 Fiber 池化、调整栈大小、选择合适的调度器等，可以优化 Fiber 应用的性能。
⚝ 监控与调试：通过 Fiber Hook 机制，可以监控 Fiber 的运行状态、性能指标，方便调试和性能分析。
⚝ 资源管理：通过配置 Fiber 池大小、限制 Fiber 数量等，可以更好地管理 Fiber 应用的资源使用。
⚝ 定制化调度：通过自定义 Fiber 调度器，可以实现各种复杂的调度策略，满足特定的应用需求。
总结
FiberManager 提供了丰富的配置选项和灵活的扩展机制，使得开发者可以根据具体的应用场景进行定制和优化。通过配置 FiberManager::Options，可以调整调度器、Fiber 池、栈大小等参数。通过实现 FiberScheduler 和 FiberHooks 接口，可以自定义 Fiber 调度策略和 Hook 逻辑。这些配置和扩展机制使得 FiberManager 成为一个强大而灵活的 Fiber 管理框架，可以满足各种复杂并发应用的需求。
END_OF_CHAPTER
4. chapter 4： Fiber 类深入剖析 (Deep Dive into Fiber Class)
4.1 Fiber 类的结构与成员 (Structure and Members of Fiber Class)
folly::Fiber 类是 Folly Fiber 库的核心组件之一，它代表了轻量级协程（lightweight coroutine）的抽象。理解 Fiber 类的结构和成员对于深入掌握 Folly Fiber 的工作原理至关重要。本节将详细剖析 Fiber 类的内部结构，包括其关键成员变量、嵌套类以及它们在 Fiber 生命周期中所扮演的角色。
Fiber 类的设计目标是提供一个高效、灵活且易于使用的协程抽象，使其能够方便地集成到各种异步编程场景中。为了实现这一目标，Fiber 类封装了协程执行所需的关键信息和操作，例如：执行上下文（execution context）、栈空间（stack space）、状态管理（state management）以及调度控制（scheduling control）。
下面我们从概念层面和代码结构层面，逐步深入了解 Fiber 类的结构与成员。
概念层面：Fiber 的核心组成
一个 Fiber 实例，在概念上，主要由以下几个核心部分组成：
① 执行体（Body）：Fiber 真正要执行的代码逻辑，通常是一个函数或者一个可调用对象（Callable Object）。当 Fiber 被调度执行时，会从其指定的执行体开始运行。
② 栈空间（Stack Space）：每个 Fiber 都有自己独立的栈空间，用于存储局部变量、函数调用信息等。与线程相比，Fiber 的栈空间通常更小，且可以动态分配和回收，从而更有效地利用内存资源。
③ 执行上下文（Execution Context）：保存 Fiber 执行时的 CPU 寄存器状态、指令指针等信息。上下文切换（Context Switching）的核心就是保存和恢复不同 Fiber 的执行上下文。
④ 状态（State）：Fiber 在其生命周期中会经历不同的状态，例如：就绪（Ready）、运行中（Running）、阻塞（Blocked）、完成（Finished）等。状态管理是 Fiber 调度和控制的基础。
⑤ 局部存储（Local Storage）：Fiber 局部存储允许在同一个 Fiber 的不同执行阶段之间，以及在异步操作的回调函数中，安全地访问和修改数据，而无需显式地传递参数。
代码结构层面：Fiber 类的成员
虽然具体的 folly::Fiber 类的成员细节可能会随着 Folly 库版本的更新而有所调整，但通常来说，一个典型的 Fiber 类会包含以下类型的成员：
⚝ 私有成员变量 (Private Member Variables)：
⚝ 栈管理 (Stack Management)：
▮▮▮▮⚝ stack_: 用于存储 Fiber 栈空间的指针或智能指针。
▮▮▮▮⚝ stackSize_: Fiber 栈空间的大小。
⚝ 上下文 (Context)：
▮▮▮▮⚝ context_: 用于保存 Fiber 执行上下文的数据结构，类型可能是平台相关的，例如 ucontext_t (POSIX 系统) 或 Windows Fiber Context。
⚝ 状态管理 (State Management)：
▮▮▮▮⚝ state_: 枚举类型变量，表示 Fiber 当前的状态（例如：READY, RUNNING, BLOCKED, FINISHED）。
▮▮▮▮⚝ waitQueue_: 等待在该 Fiber 上的其他 Fiber 的队列，用于实现 Fiber 的同步和阻塞操作。
⚝ 执行体 (Body)：
▮▮▮▮⚝ entryPoint_: 指向 Fiber 执行入口点函数或可调用对象的指针或函数对象。
⚝ Fiber 管理器 (Fiber Manager)：
▮▮▮▮⚝ fiberManager_: 指向管理该 Fiber 的 FiberManager 实例的指针。
⚝ Fiber 局部存储 (Fiber-Local Storage)：
▮▮▮▮⚝ fiberLocalStorage_: 用于存储 Fiber 局部数据的容器，通常是一个关联数组或哈希表。
⚝ 取消标志 (Cancellation Flag)：
▮▮▮▮⚝ cancellationRequested_: 布尔标志，指示是否已请求取消该 Fiber 的执行。
⚝ 超时信息 (Timeout Information)：
▮▮▮▮⚝ timeoutTime_: 时间点，表示 Fiber 的超时时间。
⚝ 公有成员函数 (Public Member Functions)：
⚝ 构造函数与析构函数 (Constructor and Destructor)：
▮▮▮▮⚝ Fiber(FiberManager& manager, /* ... */): 构造函数，用于创建 Fiber 实例。通常需要指定所属的 FiberManager 以及 Fiber 的执行体。
▮▮▮▮⚝ ~Fiber(): 析构函数，负责释放 Fiber 占用的资源，例如栈空间。
⚝ 状态查询 (State Query)：
▮▮▮▮⚝ getState(): 获取 Fiber 的当前状态。
▮▮▮▮⚝ isRunnable(): 检查 Fiber 是否处于可运行状态（例如：READY 或 RUNNING）。
▮▮▮▮⚝ isFinished(): 检查 Fiber 是否已执行完成。
⚝ 控制操作 (Control Operations)：
▮▮▮▮⚝ start(): 启动 Fiber 的执行。
▮▮▮▮⚝ run(): 立即执行 Fiber (通常由调度器调用)。
▮▮▮▮⚝ yield(): 主动让出 CPU 执行权，允许其他 Fiber 运行。
▮▮▮▮⚝ join(): 等待 Fiber 执行完成。
▮▮▮▮⚝ cancel(): 请求取消 Fiber 的执行。
⚝ Fiber 局部存储 (Fiber-Local Storage)：
▮▮▮▮⚝ getLocalStorage(): 获取 Fiber 的局部存储对象。
⚝ 其他 (Others)：
▮▮▮▮⚝ getId(): 获取 Fiber 的唯一标识符。
⚝ 保护成员函数 (Protected Member Functions)：
⚝ 通常包含一些供 FiberManager 或派生类使用的辅助函数，例如：
▮▮▮▮⚝ setState(FiberState newState): 设置 Fiber 的状态。
▮▮▮▮⚝ switchContext(): 执行上下文切换操作。
▮▮▮▮⚝ onFiberStart(): 在 Fiber 开始执行时调用的钩子函数。
▮▮▮▮⚝ onFiberExit(): 在 Fiber 执行结束时调用的钩子函数。
⚝ 静态成员函数 (Static Member Functions)：
⚝ getCurrentFiber(): 获取当前正在运行的 Fiber 的指针。这通常是通过线程局部存储（Thread-Local Storage, TLS）实现的。
示例代码框架 (Conceptual C++ Code Snippet)
为了更具体地展示 Fiber 类的结构，以下是一个简化的概念性 C++ 代码框架，请注意，这并非真实的 folly::Fiber 类的代码，仅用于说明结构和成员:
1
namespace folly {
2
3
enum class FiberState {
4
READY,
5
RUNNING,
6
BLOCKED,
7
FINISHED,
8
CANCELED
9
};
10
11
class FiberManager; // Forward declaration
12
13
class Fiber {
14
private:
15
FiberState state_;
16
FiberManager* fiberManager_;
17
std::unique_ptr<char[]> stack_; // 栈空间
18
size_t stackSize_;
19
// ... (Context related members, platform-dependent)
20
std::function<void()> entryPoint_; // Fiber 执行体
21
// ... (Fiber-local storage, wait queue, etc.)
22
23
protected:
24
void setState(FiberState newState);
25
// ... (Protected helper functions)
26
27
public:
28
Fiber(FiberManager& manager, std::function<void()> entry);
29
~Fiber();
30
31
FiberState getState() const;
32
bool isRunnable() const;
33
bool isFinished() const;
34
35
void start();
36
void run(); // Internal run, called by scheduler
37
void yield();
38
void join();
39
void cancel();
40
41
// Fiber-local storage access
42
// ...
43
44
static Fiber* getCurrentFiber();
45
46
// ... (Other public methods)
47
};
48
49
} // namespace folly
总结
folly::Fiber 类通过封装执行体、栈空间、执行上下文、状态管理等关键要素，提供了一个强大而灵活的协程抽象。理解 Fiber 类的结构和成员是深入学习 Folly Fiber 的基础。在后续章节中，我们将进一步探讨 Fiber 类的创建、启动、控制、同步、局部存储以及取消与超时等高级特性，并结合实际代码示例，帮助读者全面掌握 folly::Fiber 的使用方法和最佳实践。
4.2 Fiber 的创建与启动 (Fiber Creation and Startup)
Fiber 的创建和启动是使用 Folly Fiber 的首要步骤。本节将详细介绍如何创建 folly::Fiber 对象，以及如何启动 Fiber 的执行。我们将涵盖 Fiber 对象的构造过程、启动方式，并结合代码示例进行说明。
Fiber 的创建
在 Folly Fiber 中，Fiber 对象通常由 FiberManager 负责创建和管理。创建 Fiber 的基本步骤包括：
① 获取 FiberManager 实例：Fiber 总是运行在某个 FiberManager 的管理之下。你需要先获取一个 FiberManager 的实例。通常情况下，你可以使用全局默认的 FiberManager，或者创建自定义的 FiberManager 实例。关于 FiberManager 的详细介绍，请参考 chapter 3： FiberManager 详解 (In-depth FiberManager)。
② 构造 Fiber 对象：使用 Fiber 类的构造函数来创建 Fiber 对象。Fiber 的构造函数通常需要以下参数：
▮▮▮▮⚝ FiberManager& manager: 对 FiberManager 实例的引用，指定该 Fiber 由哪个 FiberManager 管理。
▮▮▮▮⚝ std::function<void()> 或 Callable Object: Fiber 的执行体，即 Fiber 启动后要执行的代码。这可以是一个 Lambda 表达式、函数指针、函数对象等。
▮▮▮▮⚝ 可选参数: 例如，可以指定 Fiber 的栈大小、名称等。
示例代码：创建 Fiber
以下代码示例展示了如何创建一个简单的 Fiber 对象。
1
#include <folly/fibers/FiberManager.h>
2
#include <folly/fibers/Fiber.h>
3
#include <iostream>
4
5
using namespace folly;
6
7
int main() {
8
FiberManager fm; // 获取默认 FiberManager 实例
9
10
// 定义 Fiber 的执行体 (Lambda 表达式)
11
auto fiberFunc = []() {
12
std::cout << "Hello from Fiber!" << std::endl;
13
};
14
15
// 创建 Fiber 对象
16
Fiber myFiber(fm, fiberFunc);
17
18
std::cout << "Fiber created." << std::endl;
19
20
return 0;
21
}
在上述代码中，我们首先创建了一个默认的 FiberManager 实例 fm。然后，我们定义了一个 Lambda 表达式 fiberFunc 作为 Fiber 的执行体，该 Lambda 表达式的功能是打印 "Hello from Fiber!"。最后，我们使用 Fiber 的构造函数，传入 FiberManager 实例 fm 和执行体 fiberFunc，创建了一个 Fiber 对象 myFiber。
Fiber 的启动
创建 Fiber 对象后，Fiber 并没有立即开始执行。我们需要显式地调用 Fiber 对象的 start() 方法来启动 Fiber 的执行。start() 方法会将 Fiber 加入到 FiberManager 的就绪队列中，等待调度器调度执行。
示例代码：启动 Fiber
在上述创建 Fiber 的代码基础上，我们添加启动 Fiber 的代码。
1
#include <folly/fibers/FiberManager.h>
2
#include <folly/fibers/Fiber.h>
3
#include <iostream>
4
5
using namespace folly;
6
7
int main() {
8
FiberManager fm; // 获取默认 FiberManager 实例
9
10
// 定义 Fiber 的执行体 (Lambda 表达式)
11
auto fiberFunc = []() {
12
std::cout << "Hello from Fiber!" << std::endl;
13
};
14
15
// 创建 Fiber 对象
16
Fiber myFiber(fm, fiberFunc);
17
18
std::cout << "Fiber created." << std::endl;
19
20
// 启动 Fiber
21
myFiber.start();
22
23
fm.run(); // 运行 FiberManager 的调度器，调度 Fiber 执行
24
25
std::cout << "Fiber started and potentially finished." << std::endl;
26
27
return 0;
28
}
在上述代码中，我们在创建 Fiber 对象 myFiber 后，调用了 myFiber.start() 方法来启动 Fiber。为了让 FiberManager 调度并执行 myFiber，我们还需要调用 fm.run() 方法来运行 FiberManager 的调度器。fm.run() 会阻塞当前线程，直到所有 Fiber 执行完成或 FiberManager 被停止。
Fiber::start() 方法详解
Fiber::start() 方法的主要作用是将 Fiber 的状态设置为就绪（READY），并将其添加到 FiberManager 的就绪队列中。当 FiberManager 的调度器运行时，会从就绪队列中取出 Fiber 并调度执行。
Fiber::start() 方法通常执行以下操作：
① 检查 Fiber 状态：确保 Fiber 处于可以启动的状态（例如，未启动或已完成）。
② 设置 Fiber 状态为 READY：将 Fiber 的状态标记为就绪，表示可以被调度执行。
③ 添加到就绪队列：将 Fiber 添加到 FiberManager 的就绪队列中。
④ 唤醒调度器（可选）：如果调度器当前处于空闲状态，start() 方法可能会唤醒调度器，使其开始调度新的 Fiber。
FiberManager::run() 方法详解
FiberManager::run() 方法是启动 FiberManager 调度器的关键。调用 run() 方法会使 FiberManager 进入调度循环，不断地从就绪队列中取出 Fiber 并调度执行，直到满足退出条件。
FiberManager::run() 方法通常执行以下操作：
① 进入调度循环：开始一个无限循环，不断进行 Fiber 调度。
② 从就绪队列获取 Fiber：从就绪队列中获取一个处于就绪状态的 Fiber。具体的调度策略由 FiberManager 的配置决定，例如可以是 FIFO、优先级调度等。
③ 执行 Fiber：调用 Fiber 对象的 run() 方法，实际执行 Fiber 的执行体。Fiber::run() 方法会负责进行上下文切换，开始执行 Fiber 的代码。
④ 处理 Fiber 状态：Fiber 执行完成后，FiberManager 会根据 Fiber 的状态进行相应的处理，例如，将完成的 Fiber 移除，或者将阻塞的 Fiber 放入等待队列。
⑤ 检查退出条件：FiberManager 会定期检查是否满足退出条件，例如，所有 Fiber 都已完成，或者收到停止信号。如果满足退出条件，则退出调度循环。
总结
Fiber 的创建和启动是使用 Folly Fiber 的基础。通过 Fiber 的构造函数创建 Fiber 对象，并使用 start() 方法启动 Fiber 的执行。FiberManager::run() 方法负责运行调度器，调度和执行就绪的 Fiber。理解 Fiber 的创建和启动过程，是进一步学习 Fiber 控制、同步和高级应用的前提。在后续章节中，我们将继续深入探讨 Fiber 的控制与同步等主题。
4.3 Fiber 的控制与同步 (Fiber Control and Synchronization)
Fiber 的控制与同步是构建复杂并发应用的关键。Folly Fiber 提供了丰富的机制来控制 Fiber 的执行流程，以及实现 Fiber 之间的同步。本节将详细介绍 Fiber 的控制操作，例如 yield()、join()，以及常用的同步原语，例如互斥锁（Mutex）、条件变量（Condition Variable）等在 Fiber 环境下的使用。
Fiber 的控制操作
Fiber 类提供了一些方法来控制自身的执行流程，以及与其他 Fiber 的交互。常用的控制操作包括：
① Fiber::yield()：让出执行权
▮▮▮▮⚝ yield() 方法允许当前正在运行的 Fiber 主动让出 CPU 执行权，将 CPU 交给其他就绪的 Fiber 运行。
▮▮▮▮⚝ yield() 是实现协作式多任务处理的关键。当一个 Fiber 执行到可能阻塞的操作（例如，等待 I/O 完成）时，可以调用 yield() 让出 CPU，避免阻塞整个线程，提高系统的并发性能。
▮▮▮▮⚝ 调用 yield() 后，当前 Fiber 的状态会变为就绪（READY），并被重新加入到 FiberManager 的就绪队列中，等待下次调度执行。
② Fiber::join()：等待 Fiber 完成
▮▮▮▮⚝ join() 方法允许一个 Fiber 等待另一个 Fiber 执行完成。
▮▮▮▮⚝ 当一个 Fiber 需要等待另一个 Fiber 的结果时，可以调用被等待 Fiber 的 join() 方法。调用 join() 的 Fiber 会被阻塞，直到被等待的 Fiber 执行完成。
▮▮▮▮⚝ join() 方法类似于线程的 join() 操作，用于实现 Fiber 之间的同步。
③ Fiber::cancel()：请求取消 Fiber
▮▮▮▮⚝ cancel() 方法用于请求取消一个 Fiber 的执行。
▮▮▮▮⚝ 调用 cancel() 方法会设置被取消 Fiber 的取消标志。被取消的 Fiber 需要在代码中显式地检查取消标志，并做出相应的处理，例如，提前结束执行。
▮▮▮▮⚝ 取消操作是异步的，cancel() 方法调用后，被取消的 Fiber 不会立即停止执行，而是需要在其执行过程中检查取消标志并主动退出。
示例代码：Fiber 控制操作
以下代码示例展示了 yield() 和 join() 的使用。
1
#include <folly/fibers/FiberManager.h>
2
#include <folly/fibers/Fiber.h>
3
#include <iostream>
4
#include <chrono>
5
#include <thread>
6
7
using namespace folly;
8
9
int main() {
10
FiberManager fm;
11
12
auto fiberFunc1 = []() {
13
std::cout << "Fiber 1 started." << std::endl;
14
for (int i = 0; i < 5; ++i) {
15
std::cout << "Fiber 1: count = " << i << std::endl;
16
Fiber::yield(); // 主动让出执行权
17
std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 模拟耗时操作
18
}
19
std::cout << "Fiber 1 finished." << std::endl;
20
};
21
22
auto fiberFunc2 = []() {
23
std::cout << "Fiber 2 started." << std::endl;
24
std::cout << "Fiber 2: doing some work..." << std::endl;
25
std::this_thread::sleep_for(std::chrono::milliseconds(500)); // 模拟耗时操作
26
std::cout << "Fiber 2 finished." << std::endl;
27
};
28
29
Fiber fiber1(fm, fiberFunc1);
30
Fiber fiber2(fm, fiberFunc2);
31
32
fiber1.start();
33
fiber2.start();
34
35
fiber1.join(); // 等待 fiber1 执行完成
36
fiber2.join(); // 等待 fiber2 执行完成
37
38
fm.run();
39
40
std::cout << "All fibers finished." << std::endl;
41
42
return 0;
43
}
在上述代码中，fiberFunc1 和 fiberFunc2 分别是两个 Fiber 的执行体。fiberFunc1 在循环中调用 Fiber::yield() 主动让出执行权，使得 fiberFunc2 能够有机会执行。主线程通过 fiber1.join() 和 fiber2.join() 等待两个 Fiber 执行完成。
Fiber 同步原语
虽然 Fiber 是轻量级的协程，但在并发编程中，仍然需要同步机制来保护共享资源，避免数据竞争等问题。Folly Fiber 可以与线程同步原语结合使用，例如互斥锁（Mutex）、条件变量（Condition Variable）、信号量（Semaphore）等。
互斥锁 (Mutex)
互斥锁用于保护临界区（Critical Section），保证在同一时刻只有一个 Fiber 可以访问共享资源。在 Fiber 环境下使用互斥锁与线程环境类似，但需要注意避免长时间持有锁，以免影响其他 Fiber 的执行。
条件变量 (Condition Variable)
条件变量用于实现 Fiber 之间的条件同步。一个 Fiber 可以等待某个条件成立，当条件成立时，另一个 Fiber 可以通知等待的 Fiber 继续执行。条件变量通常与互斥锁一起使用，以避免竞争条件。
信号量 (Semaphore)
信号量用于控制对共享资源的并发访问数量。例如，可以使用信号量来限制同时访问数据库连接池的 Fiber 数量。
Fiber 同步的注意事项
① 避免阻塞线程：在 Fiber 环境下，同步操作应该尽可能避免阻塞底层的线程。长时间的线程阻塞会降低系统的并发性能，抵消 Fiber 的优势。Folly Fiber 提供了基于 Fiber 的同步原语，例如 FiberMutex、FiberConditionVariable 等，这些原语在 Fiber 级别进行阻塞，而不会阻塞底层线程。
② 死锁 (Deadlock) 避免：与线程编程类似，Fiber 编程也需要注意死锁问题。死锁通常发生在多个 Fiber 互相等待对方释放资源时。避免死锁的关键是合理地设计资源访问顺序，以及使用超时机制。
③ 活锁 (Livelock) 与饥饿 (Starvation)：活锁是指多个 Fiber 为了响应彼此的状态而持续改变自身状态，但没有实际进展的情况。饥饿是指某个 Fiber 长时间无法获得执行机会。在 Fiber 调度和同步设计中，需要考虑活锁和饥饿问题，保证系统的公平性和效率。
总结
Fiber 的控制与同步是构建复杂并发应用的重要组成部分。Fiber::yield()、join() 和 cancel() 等方法提供了基本的 Fiber 控制能力。结合互斥锁、条件变量等同步原语，可以实现 Fiber 之间的复杂同步和协作。在 Fiber 编程中，需要注意避免阻塞线程，以及处理死锁、活锁和饥饿等并发问题，以充分发挥 Fiber 的优势，构建高效、可靠的并发系统。在后续章节中，我们将继续探讨 Fiber 局部存储、取消与超时等高级特性，以及 Fiber 在实际应用场景中的最佳实践。
4.4 Fiber 局部存储 (Fiber-Local Storage)
Fiber 局部存储（Fiber-Local Storage, FLS）是一种在 Fiber 级别提供数据隔离的机制。它允许在同一个 Fiber 的不同执行阶段之间，以及在异步操作的回调函数中，安全地访问和修改数据，而无需显式地传递参数。FLS 在 Fiber 并发编程中扮演着重要的角色，尤其是在处理上下文相关的数据时。
FLS 的概念与作用
在多线程编程中，线程局部存储（Thread-Local Storage, TLS）允许每个线程拥有自己独立的变量副本，从而避免线程之间的数据竞争。Fiber 局部存储的概念与之类似，但作用范围限定在 Fiber 级别。
FLS 的主要作用包括：
① 数据隔离：每个 Fiber 拥有独立的 FLS 数据副本，Fiber 之间的数据互不干扰，避免了并发访问共享数据时的数据竞争问题。
② 隐式上下文传递：FLS 允许在 Fiber 的不同执行阶段之间隐式地传递上下文信息，无需显式地通过函数参数传递。这简化了代码，提高了可读性。例如，在处理请求上下文、事务 ID、用户身份验证信息等场景中，FLS 非常有用。
③ 异步操作上下文保持：在异步编程中，回调函数通常在不同的 Fiber 或线程中执行。FLS 可以确保在异步操作的回调函数中仍然可以访问到发起异步操作时的上下文信息。
Folly Fiber 中的 FLS 实现
Folly Fiber 提供了 FLS 的支持，具体的 API 细节可能需要查阅 folly/fibers/Fiber.h 的文档。通常来说，Folly Fiber 的 FLS 实现会提供以下功能：
① FLS 变量的定义：提供宏或模板类，用于定义 Fiber 局部存储变量。例如，可能提供类似 FOLLY_FIBER_LOCAL(type, name) 的宏，用于定义一个类型为 type，名称为 name 的 FLS 变量。
② FLS 变量的访问：提供 API 用于访问和修改 FLS 变量的值。通常可以直接像访问普通变量一样访问 FLS 变量。
③ FLS 变量的生命周期管理：FLS 变量的生命周期与 Fiber 的生命周期一致。当 Fiber 创建时，FLS 变量被初始化；当 Fiber 结束时，FLS 变量被销毁。
示例代码：使用 FLS
以下是一个概念性的示例代码，展示了如何使用 FLS (请注意，具体的 API 可能需要参考 Folly Fiber 的文档)。
1
#include <folly/fibers/FiberManager.h>
2
#include <folly/fibers/Fiber.h>
3
#include <iostream>
4
5
using namespace folly;
6
7
// 假设 Folly Fiber 提供了 FOLLY_FIBER_LOCAL 宏来定义 FLS 变量
8
FOLLY_FIBER_LOCAL(int, requestId); // 定义一个名为 requestId 的 Fiber 局部存储变量
9
10
void processRequest() {
11
std::cout << "Processing request with ID: " << requestId << std::endl;
12
// ... (业务逻辑) ...
13
}
14
15
auto requestHandler = [](int reqId) {
16
requestId = reqId; // 设置当前 Fiber 的 requestId FLS 变量
17
std::cout << "Request handler started for request ID: " << requestId << std::endl;
18
processRequest();
19
std::cout << "Request handler finished for request ID: " << requestId << std::endl;
20
};
21
22
int main() {
23
FiberManager fm;
24
25
Fiber fiber1(fm, std::bind(requestHandler, 1001));
26
Fiber fiber2(fm, std::bind(requestHandler, 1002));
27
28
fiber1.start();
29
fiber2.start();
30
31
fm.run();
32
33
return 0;
34
}
在上述代码中，我们使用 FOLLY_FIBER_LOCAL(int, requestId) 定义了一个名为 requestId 的 Fiber 局部存储变量。在 requestHandler Lambda 表达式中，我们首先设置了当前 Fiber 的 requestId FLS 变量的值，然后在 processRequest 函数中直接访问 requestId 变量，而无需显式地传递请求 ID 参数。每个 Fiber 都有自己独立的 requestId 副本，因此 fiber1 和 fiber2 处理的请求 ID 互不干扰。
FLS 的实现原理
FLS 的实现通常依赖于底层 Fiber 库的上下文切换机制。当进行 Fiber 上下文切换时，FLS 的数据也需要被保存和恢复。常见的 FLS 实现方式包括：
① 基于 Fiber 对象的存储：在 Fiber 对象内部维护一个用于存储 FLS 数据的容器（例如，哈希表或关联数组）。当访问 FLS 变量时，实际上是访问当前 Fiber 对象内部的 FLS 容器。
② 基于线程局部存储 (TLS) 的模拟：利用线程局部存储 (TLS) 来模拟 Fiber 局部存储。每个线程维护一个 FLS 数据结构，当 Fiber 切换时，更新当前线程的 FLS 数据结构，使其与当前 Fiber 关联。这种方式可能需要额外的管理开销。
FLS 的最佳实践与注意事项
① 适度使用 FLS：FLS 提供了便利的上下文传递机制，但过度使用 FLS 可能会降低代码的可读性和可维护性。应该权衡使用 FLS 的利弊，避免滥用。
② 注意 FLS 变量的初始化和销毁：确保 FLS 变量在使用前被正确初始化，并在 Fiber 结束时被正确销毁，避免资源泄漏或未定义行为。
③ 性能考虑：FLS 的访问可能会有一定的性能开销，尤其是在频繁访问 FLS 变量的场景下。在性能敏感的应用中，需要评估 FLS 的性能影响，并考虑是否可以使用其他更高效的上下文传递方式。
总结
Fiber 局部存储 (FLS) 是一种在 Fiber 级别提供数据隔离和隐式上下文传递的机制。它简化了 Fiber 并发编程，提高了代码的可读性和可维护性。Folly Fiber 提供了 FLS 的支持，具体 API 需要参考官方文档。合理地使用 FLS 可以提高 Fiber 应用的开发效率和性能。在后续章节中，我们将继续探讨 Fiber 的取消与超时、高级应用以及最佳实践等主题。
4.5 Fiber 的取消与超时 (Fiber Cancellation and Timeout)
在并发编程中，任务的取消（Cancellation）和超时（Timeout）处理是非常重要的。Fiber 作为一种轻量级并发单元，也需要提供有效的取消和超时机制，以保证系统的健壮性和资源利用率。本节将详细介绍 Folly Fiber 中 Fiber 的取消和超时处理机制，包括如何请求取消 Fiber 的执行，以及如何设置 Fiber 操作的超时时间。
Fiber 的取消 (Cancellation)
Fiber 的取消是指在 Fiber 执行过程中，外部可以请求终止其执行。取消操作通常用于处理以下场景：
① 用户取消操作：例如，用户在 Web 界面上点击 "取消" 按钮，需要终止正在执行的后台任务。
② 资源限制：当系统资源紧张时，需要取消一些优先级较低的任务，以保证高优先级任务的执行。
③ 错误处理：当检测到错误或异常情况时，需要取消相关的 Fiber，避免资源浪费或系统状态异常。
Folly Fiber 的取消机制
Folly Fiber 提供了 Fiber::cancel() 方法来请求取消 Fiber 的执行。取消机制是协作式的，这意味着被取消的 Fiber 需要在代码中显式地检查取消状态，并主动做出响应。
Fiber 的取消流程通常如下：
① 请求取消：外部代码调用 fiber.cancel() 方法，请求取消 Fiber 的执行。cancel() 方法会设置 Fiber 对象的内部取消标志。
② 检查取消状态：在 Fiber 的执行体代码中，需要定期检查取消状态。Folly Fiber 可能会提供 Fiber::isCancelled() 方法或类似的 API 来检查当前 Fiber 是否已被请求取消。
③ 响应取消：当 Fiber 检测到取消状态为真时，应该立即停止执行当前任务，进行清理工作（例如，释放资源），并尽快退出。
示例代码：Fiber 取消
以下代码示例展示了如何使用 Fiber::cancel() 和 Fiber::isCancelled() 实现 Fiber 的取消。
1
#include <folly/fibers/FiberManager.h>
2
#include <folly/fibers/Fiber.h>
3
#include <iostream>
4
#include <chrono>
5
#include <thread>
6
7
using namespace folly;
8
9
auto cancellableFiberFunc = [](Fiber* fiber) {
10
std::cout << "Cancellable Fiber started." << std::endl;
11
for (int i = 0; i < 10; ++i) {
12
if (fiber->isCancelled()) { // 检查取消状态
13
std::cout << "Fiber cancelled at count = " << i << std::endl;
14
break; // 响应取消，退出循环
15
}
16
std::cout << "Cancellable Fiber: count = " << i << std::endl;
17
std::this_thread::sleep_for(std::chrono::milliseconds(200)); // 模拟耗时操作
18
}
19
std::cout << "Cancellable Fiber finished (or cancelled)." << std::endl;
20
};
21
22
int main() {
23
FiberManager fm;
24
25
Fiber myFiber(fm, std::bind(cancellableFiberFunc, std::placeholders::_1)); // 传递 Fiber 指针
26
27
myFiber.start();
28
29
std::this_thread::sleep_for(std::chrono::milliseconds(500)); // 等待一段时间后取消 Fiber
30
31
std::cout << "Requesting fiber cancellation..." << std::endl;
32
myFiber.cancel(); // 请求取消 Fiber
33
34
fm.run();
35
36
std::cout << "Main thread finished." << std::endl;
37
38
return 0;
39
}
在上述代码中，cancellableFiberFunc 是一个可取消的 Fiber 执行体。在循环中，它定期调用 fiber->isCancelled() 检查取消状态。如果检测到取消状态为真，则打印取消信息并 break 退出循环，响应取消请求。在 main 函数中，主线程在启动 myFiber 后，等待一段时间，然后调用 myFiber.cancel() 请求取消 myFiber 的执行。
Fiber 的超时 (Timeout)
超时机制用于限制 Fiber 操作的执行时间。当 Fiber 操作执行时间超过预设的超时时间时，系统会采取相应的处理措施，例如，终止操作、返回错误或执行备选方案。超时机制可以防止 Fiber 操作无限期地阻塞，保证系统的响应性和可用性。
Folly Fiber 的超时处理
Folly Fiber 可能会提供 API 来设置 Fiber 操作的超时时间。具体的超时处理方式可能取决于不同的操作类型。例如，对于某些异步操作，可以设置超时时间；对于 Fiber::join() 操作，也可以设置超时时间。
示例代码：Fiber 超时 (概念性示例)
以下是一个概念性的示例代码，展示了如何使用超时机制 (请注意，具体的 API 可能需要参考 Folly Fiber 的文档)。
1
#include <folly/fibers/FiberManager.h>
2
#include <folly/fibers/Fiber.h>
3
#include <iostream>
4
#include <chrono>
5
#include <stdexcept>
6
7
using namespace folly;
8
9
auto timeoutFiberFunc = []() {
10
std::cout << "Timeout Fiber started." << std::endl;
11
std::this_thread::sleep_for(std::chrono::seconds(2)); // 模拟耗时操作
12
std::cout << "Timeout Fiber finished." << std::endl;
13
};
14
15
int main() {
16
FiberManager fm;
17
18
Fiber myFiber(fm, timeoutFiberFunc);
19
20
myFiber.start();
21
22
bool joined = false;
23
try {
24
// 假设 Fiber::join() 方法支持超时参数
25
joined = myFiber.join(std::chrono::milliseconds(1000)); // 设置 1 秒超时
26
} catch (const std::runtime_error& e) {
27
std::cerr << "Join timeout: " << e.what() << std::endl;
28
joined = false;
29
}
30
31
if (joined) {
32
std::cout << "Fiber joined successfully." << std::endl;
33
} else {
34
std::cout << "Fiber join timed out or failed." << std::endl;
35
myFiber.cancel(); // 超时后可以考虑取消 Fiber
36
}
37
38
fm.run();
39
40
std::cout << "Main thread finished." << std::endl;
41
42
return 0;
43
}
在上述代码中，我们尝试使用 myFiber.join(std::chrono::milliseconds(1000)) 设置 1 秒的超时时间来等待 myFiber 执行完成。如果 join() 操作在 1 秒内没有完成，可能会抛出超时异常，或者返回表示超时的状态。在超时处理逻辑中，我们可以选择取消 Fiber 的执行，释放资源。
取消与超时的最佳实践与注意事项
① 及时响应取消：在 Fiber 的执行体代码中，应该定期检查取消状态，并及时响应取消请求，避免长时间的资源占用。
② 资源清理：在 Fiber 响应取消或超时时，需要进行必要的资源清理工作，例如，释放内存、关闭文件句柄、回滚事务等，保证系统的状态一致性。
③ 超时时间设置：合理地设置超时时间非常重要。超时时间设置过短可能会导致操作频繁超时，影响系统的正常功能；超时时间设置过长则可能无法及时发现和处理问题。超时时间的设置需要根据具体的应用场景和性能需求进行权衡。
④ 异常处理：在超时处理中，需要注意异常处理。例如，当 Fiber::join() 操作超时抛出异常时，需要捕获异常并进行相应的处理。
总结
Fiber 的取消与超时是保证 Fiber 应用健壮性和资源利用率的重要机制。Folly Fiber 提供了 Fiber::cancel() 方法来请求取消 Fiber 的执行，以及可能提供超时处理 API (具体细节需要参考官方文档)。在 Fiber 编程中，需要合理地使用取消和超时机制，及时响应取消请求，进行资源清理，并合理设置超时时间，以构建可靠、高效的并发系统。在后续章节中，我们将继续深入探讨 Folly Fiber 的高级应用、最佳实践以及 API 全面解析等主题。
END_OF_CHAPTER
5. chapter 5： Folly Fiber 高级应用 (Advanced Applications of Folly Fibers)
5.1 基于 Fiber 的异步编程模式 (Asynchronous Programming Patterns Based on Fibers)
异步编程 (Asynchronous Programming) 是现代高性能应用开发中的关键技术。它允许程序在执行 I/O 操作或其他耗时任务时，无需阻塞主线程，从而提高程序的并发性和响应速度。Fiber 作为一种轻量级线程，非常适合构建各种异步编程模式。本节将深入探讨基于 Folly Fiber 实现的几种常见的异步编程模式，并结合代码示例进行详细解析。
5.1.1 回调模式 (Callback Pattern)
回调模式 (Callback Pattern) 是一种经典的异步编程模式。其核心思想是将一个函数（回调函数）作为参数传递给异步操作，当异步操作完成时，回调函数会被执行。在 Fiber 环境中，回调模式依然适用，并且可以与 Fiber 的协作式调度机制良好地结合。
示例代码：基于 Fiber 的回调模式
1
#include <folly/fibers/FiberManager.h>
2
#include <folly/fibers/Fiber.h>
3
#include <iostream>
4
#include <functional>
5
6
using namespace folly::fibers;
7
8
void asyncTask(std::function<void(int)> callback) {
9
FiberManager::get()->schedule([callback]() {
10
// 模拟耗时操作
11
std::this_thread::sleep_for(std::chrono::seconds(1));
12
int result = 42;
13
callback(result); // 执行回调函数
14
});
15
}
16
17
int main() {
18
FiberManager fm;
19
fm.start();
20
21
std::cout << "开始异步任务..." << std::endl;
22
23
asyncTask([](int result) {
24
std::cout << "异步任务完成，结果: " << result << std::endl;
25
});
26
27
fm.join();
28
std::cout << "程序结束。" << std::endl;
29
return 0;
30
}
代码解析：
① asyncTask 函数模拟一个异步任务，它接受一个 std::function<void(int)> 类型的回调函数 callback 作为参数。
② 在 asyncTask 函数内部，使用 FiberManager::get()->schedule 创建一个新的 Fiber 来执行异步操作。
③ 异步操作中，std::this_thread::sleep_for 模拟耗时操作，然后计算结果 result。
④ 异步操作完成后，调用 callback(result) 执行回调函数，并将结果传递给回调函数。
⑤ 在 main 函数中，创建 FiberManager 并启动。
⑥ 调用 asyncTask 函数，并传递一个 lambda 表达式作为回调函数，该 lambda 表达式负责打印异步任务的结果。
⑦ 最后，调用 fm.join() 等待所有 Fiber 执行完成，程序结束。
优点：
⚝ 简单直观，易于理解和实现。
⚝ 适用于简单的异步场景。
缺点：
⚝ 当异步操作嵌套较多时，容易形成“回调地狱 (Callback Hell)”，代码可读性和维护性降低。
⚝ 错误处理较为分散，不易集中管理。
5.1.2 Promise/Future 模式 (Promise/Future Pattern)
Promise/Future 模式 (Promise/Future Pattern) 是一种更高级的异步编程模式，它通过引入 Promise 和 Future 两个概念来更好地管理异步操作的结果和状态。Promise 代表异步操作的承诺，Future 代表异步操作的未来结果。
示例代码：基于 Fiber 的 Promise/Future 模式
1
#include <folly/fibers/FiberManager.h>
2
#include <folly/fibers/Fiber.h>
3
#include <folly/futures/Promise.h>
4
#include <folly/futures/Future.h>
5
#include <iostream>
6
7
using namespace folly::fibers;
8
using namespace folly::futures;
9
10
Future<int> asyncTaskPromise() {
11
Promise<int> promise;
12
FiberManager::get()->schedule([promise]() mutable {
13
// 模拟耗时操作
14
std::this_thread::sleep_for(std::chrono::seconds(1));
15
int result = 42;
16
promise.setValue(result); // 设置 Promise 的值，完成 Future
17
});
18
return promise.getFuture(); // 返回 Future
19
}
20
21
int main() {
22
FiberManager fm;
23
fm.start();
24
25
std::cout << "开始异步任务 (Promise/Future)..." << std::endl;
26
27
Future<int> future = asyncTaskPromise();
28
future.thenValue([](int result) {
29
std::cout << "异步任务完成，结果: " << result << std::endl;
30
});
31
32
fm.join();
33
std::cout << "程序结束。" << std::endl;
34
return 0;
35
}
代码解析：
① asyncTaskPromise 函数返回一个 Future<int> 对象。
② 在函数内部，创建一个 Promise<int> 对象 promise。
③ 使用 FiberManager::get()->schedule 创建一个新的 Fiber 执行异步操作。
④ 异步操作完成后，调用 promise.setValue(result) 设置 Promise 的值，这会自动完成与该 Promise 关联的 Future。
⑤ asyncTaskPromise 函数返回 promise.getFuture()，即与 Promise 关联的 Future 对象。
⑥ 在 main 函数中，调用 asyncTaskPromise 获取 Future 对象。
⑦ 使用 future.thenValue 注册一个回调函数，当 Future 完成时，该回调函数会被执行，并接收 Future 的值作为参数。
优点：
⚝ 更好地管理异步操作的状态和结果。
⚝ 可以链式调用 then 方法，避免回调地狱。
⚝ 错误处理更加集中和方便。
缺点：
⚝ 相比回调模式，概念稍复杂，学习曲线较陡峭。
⚝ 需要引入 Promise 和 Future 相关的库。
5.1.3 Generator/Yield 模式 (Generator/Yield Pattern)
Generator/Yield 模式 (Generator/Yield Pattern) 是一种更加高级和优雅的异步编程模式，它允许将异步操作写成看似同步的代码，提高代码的可读性和可维护性。虽然 C++ 标准库中没有直接的 Generator/Yield 支持，但可以通过 Fiber 和一些技巧来模拟实现类似的效果。Folly Fiber 本身并没有直接提供 Generator/Yield 的语法糖，但其协作式调度的特性使得手动实现 Generator/Yield 模式成为可能。
概念解释：
⚝ Generator (生成器): 一种可以暂停和恢复执行的函数。
⚝ Yield (让步): Generator 函数中的关键字，用于暂停函数执行，并返回一个值。下次恢复执行时，从 yield 语句之后继续执行。
在 Fiber 中模拟 Generator/Yield 模式的思路：
① 使用 Fiber 来表示 Generator 函数的执行上下文。
② 使用某种机制（例如 std::promise 和 std::future）来暂停 Fiber 的执行，并等待异步操作完成。
③ 当异步操作完成时，恢复 Fiber 的执行。
示例代码：基于 Fiber 模拟的 Generator/Yield 模式 (简化示例)
1
#include <folly/fibers/FiberManager.h>
2
#include <folly/fibers/Fiber.h>
3
#include <folly/futures/Promise.h>
4
#include <folly/futures/Future.h>
5
#include <iostream>
6
7
using namespace folly::fibers;
8
using namespace folly::futures;
9
10
Future<int> asyncOperation() {
11
Promise<int> promise;
12
FiberManager::get()->schedule([promise]() mutable {
13
std::this_thread::sleep_for(std::chrono::seconds(1));
14
promise.setValue(100);
15
});
16
return promise.getFuture();
17
}
18
19
Fiber::Func generatorFunction() {
20
return []() {
21
std::cout << "Generator 开始执行..." << std::endl;
22
23
// 模拟 yield 等待异步操作
24
Future<int> future1 = asyncOperation();
25
int result1 = future1.get(); // 阻塞 Fiber 等待 Future 完成
26
std::cout << "异步操作 1 完成，结果: " << result1 << std::endl;
27
28
Future<int> future2 = asyncOperation();
29
int result2 = future2.get(); // 再次阻塞 Fiber 等待 Future 完成
30
std::cout << "异步操作 2 完成，结果: " << result2 << std::endl;
31
32
std::cout << "Generator 执行结束。" << std::endl;
33
};
34
}
35
36
int main() {
37
FiberManager fm;
38
fm.start();
39
40
FiberManager::get()->schedule(generatorFunction());
41
42
fm.join();
43
std::cout << "程序结束。" << std::endl;
44
return 0;
45
}
代码解析：
① asyncOperation 函数返回一个 Future<int>，模拟一个异步操作。
② generatorFunction 返回一个 Fiber::Func，表示一个 Fiber 函数，模拟 Generator 函数。
③ 在 generatorFunction 中，使用 future.get() 阻塞 Fiber 的执行，等待 Future 完成。这模拟了 yield 的效果，暂停 Generator 的执行，直到异步操作完成。
④ 当 future.get() 返回时，Fiber 恢复执行，继续处理异步操作的结果。
优点：
⚝ 代码逻辑更清晰，更接近同步代码的写法，易于理解和维护。
⚝ 避免了回调地狱，提高了代码的可读性。
缺点：
⚝ 手动模拟 Generator/Yield 模式较为复杂，需要对 Fiber 和 Future 有深入的理解。
⚝ 错误处理和异常传播需要仔细设计。
⚝ 性能方面，频繁的 Fiber 阻塞和恢复可能会带来一定的开销。
总结：
基于 Fiber 可以实现多种异步编程模式，选择合适的模式取决于具体的应用场景和需求。回调模式简单直接，适用于简单的异步场景；Promise/Future 模式更加结构化，适合管理复杂的异步流程；Generator/Yield 模式则更加优雅，提高了代码的可读性和可维护性，但实现较为复杂。在实际应用中，可以根据项目的具体情况选择合适的异步编程模式，或者将多种模式结合使用，以达到最佳的开发效率和程序性能。
5.2 Fiber 在高性能服务器中的应用 (Application of Fibers in High-Performance Servers)
高性能服务器 (High-Performance Servers) 是 Fiber 最重要的应用场景之一。在服务器领域，处理高并发连接和请求是核心挑战。传统的线程模型在面对大规模并发时，会因为线程上下文切换的开销过大而导致性能瓶颈。Fiber 作为轻量级线程，可以有效地解决这个问题。本节将深入探讨 Fiber 在高性能服务器中的应用，并分析其优势和实现策略。
5.2.1 高并发与线程模型的瓶颈 (High Concurrency and Bottlenecks of Thread Model)
在高并发服务器场景下，服务器需要同时处理大量的客户端连接和请求。传统的线程模型，为每个连接或请求创建一个线程，虽然可以实现并发，但当连接数达到一定规模时，线程模型的瓶颈就会显现出来：
① 线程创建和销毁开销大 (High Overhead of Thread Creation and Destruction)：创建和销毁线程需要操作系统进行资源分配和回收，当连接数频繁变化时，线程的创建和销毁开销会显著增加。
② 线程上下文切换开销大 (High Overhead of Thread Context Switching)：线程上下文切换需要保存和恢复线程的寄存器、堆栈等信息，当线程数过多时，上下文切换的开销会占据大量的 CPU 时间，降低程序的整体性能。
③ 内存占用高 (High Memory Consumption)：每个线程都需要独立的堆栈空间，当线程数过多时，内存占用会显著增加，甚至导致内存耗尽。
这些瓶颈限制了传统线程模型在高并发服务器中的扩展能力。为了解决这些问题，轻量级线程（如 Fiber）应运而生。
5.2.2 Fiber 的优势：轻量级与高效调度 (Advantages of Fibers: Lightweight and Efficient Scheduling)
Fiber 作为用户态的轻量级线程，相比内核线程具有以下优势，使其非常适合用于构建高性能服务器：
① 轻量级 (Lightweight)：Fiber 的创建、销毁和上下文切换都由用户态程序控制，无需操作系统内核参与，开销非常小。Fiber 的上下文通常只包含少量的寄存器和堆栈信息，远小于内核线程。
② 高效调度 (Efficient Scheduling)：Fiber 的调度由用户态的 Fiber 调度器 (Fiber Scheduler) 负责，调度策略可以根据应用场景进行定制和优化。协作式调度避免了抢占式调度带来的上下文切换开销，提高了调度效率。
③ 内存占用低 (Low Memory Consumption)：Fiber 的堆栈空间可以根据需要动态调整，通常比内核线程的堆栈空间小得多，从而降低了内存占用。
这些优势使得 Fiber 能够有效地解决传统线程模型在高并发场景下的瓶颈，提高服务器的并发处理能力和资源利用率。
5.2.3 基于 Fiber 的服务器架构 (Server Architecture Based on Fibers)
基于 Fiber 构建高性能服务器，通常采用以下架构模式：
单线程 + Fiber 调度器 (Single Thread + Fiber Scheduler)
在这种架构中，服务器的主线程负责事件循环 (Event Loop) 和 Fiber 调度。每个客户端连接或请求都由一个 Fiber 处理。当 Fiber 执行 I/O 操作时，它会主动让出 CPU，Fiber 调度器会选择另一个就绪的 Fiber 继续执行。当 I/O 操作完成时，相关的 Fiber 会被重新调度执行。
架构特点：
⚝ 单线程事件循环 (Single-Threaded Event Loop)：使用单线程处理所有事件和 Fiber 调度，避免了多线程同步和锁的开销。
⚝ 协作式调度 (Cooperative Scheduling)：Fiber 之间通过协作的方式进行调度，避免了抢占式调度的上下文切换开销。
⚝ 非阻塞 I/O (Non-blocking I/O)：Fiber 通常与非阻塞 I/O 结合使用，当 Fiber 执行 I/O 操作时，不会阻塞线程，而是将 I/O 事件注册到事件循环中，等待 I/O 事件就绪。
示例：基于 Folly Fiber 的简单 HTTP 服务器框架 (伪代码)
1
#include <folly/fibers/FiberManager.h>
2
#include <folly/fibers/Fiber.h>
3
#include <folly/io/async/EventBase.h>
4
#include <folly/io/async/AsyncServerSocket.h>
5
#include <folly/io/async/AsyncSocket.h>
6
#include <iostream>
7
8
using namespace folly::fibers;
9
using namespace folly::io::async;
10
11
void handleConnection(std::shared_ptr<AsyncSocket> socket) {
12
FiberManager::get()->schedule([socket]() {
13
// Fiber 函数处理客户端连接
14
while (true) {
15
// 接收客户端请求 (非阻塞 I/O)
16
auto requestData = socket->recv();
17
if (requestData.empty()) {
18
break; // 连接关闭
19
}
20
21
// 处理请求
22
std::string response = processRequest(requestData);
23
24
// 发送响应 (非阻塞 I/O)
25
socket->write(response);
26
}
27
socket->close();
28
});
29
}
30
31
int main() {
32
FiberManager fm;
33
fm.start();
34
EventBase evb;
35
AsyncServerSocket serverSocket(&evb);
36
37
serverSocket.bind(nullptr, 8080);
38
serverSocket.listen(1024);
39
serverSocket.setAcceptCallback([&](std::shared_ptr<AsyncSocket> socket) {
40
std::cout << "接受新的连接: " << socket->getPeerAddress() << std::endl;
41
handleConnection(socket); // 为每个连接创建一个 Fiber 处理
42
});
43
44
evb.loopForever(); // 启动事件循环
45
fm.stop();
46
fm.join();
47
return 0;
48
}
代码框架解析：
① 使用 folly::io::async::EventBase 创建事件循环。
② 使用 folly::io::async::AsyncServerSocket 创建异步服务器 Socket。
③ serverSocket.setAcceptCallback 设置连接接受回调函数，当有新的连接到达时，回调函数会被调用。
④ 在连接接受回调函数 handleConnection 中，为每个新的连接创建一个 Fiber，并使用 FiberManager::get()->schedule 调度执行。
⑤ Fiber 函数负责处理客户端连接的请求和响应，使用非阻塞 I/O 进行数据接收和发送。
⑥ evb.loopForever() 启动事件循环，服务器开始监听和处理连接。
多线程 + Fiber 调度器 (Multi-Thread + Fiber Scheduler)
为了进一步提高服务器的性能，可以将 Fiber 调度器与多线程结合使用。在这种架构中，可以使用多个线程，每个线程运行一个 Fiber 调度器。不同的 Fiber 可以分布在不同的线程上执行，从而充分利用多核 CPU 的性能。
架构特点：
⚝ 多线程事件循环 (Multi-Threaded Event Loop)：可以使用多个线程，每个线程运行一个事件循环和 Fiber 调度器。
⚝ 并行处理 (Parallel Processing)：不同的 Fiber 可以并行地在不同的线程上执行，提高并发处理能力。
⚝ 负载均衡 (Load Balancing)：Fiber 调度器可以根据负载情况，将 Fiber 分配到不同的线程上执行，实现负载均衡。
Folly Fiber 对多线程 Fiber 调度器的支持：
Folly Fiber 的 FiberManager 可以配置为多线程模式，通过设置 FiberManager::Options::threads 参数来指定 Fiber 调度器使用的线程数。在多线程模式下，FiberManager 会创建多个工作线程，并将 Fiber 分配到这些线程上执行，实现并行处理。
总结：
Fiber 在高性能服务器中具有广泛的应用前景。基于 Fiber 的服务器架构可以有效地解决传统线程模型的瓶颈，提高服务器的并发处理能力和资源利用率。单线程 + Fiber 调度器架构适用于 I/O 密集型应用，多线程 + Fiber 调度器架构则可以进一步提高 CPU 密集型应用的性能。在实际应用中，可以根据服务器的具体需求和负载特点，选择合适的 Fiber 服务器架构，并结合 Folly Fiber 提供的丰富功能和 API，构建高性能、高可靠的服务器系统。
5.3 Fiber 与协程的结合 (Combination of Fibers and Coroutines)
协程 (Coroutines) 和 Fiber 都是轻量级并发编程技术，它们都旨在提高程序的并发性和响应速度，并降低线程上下文切换的开销。虽然 Fiber 和协程在概念上有相似之处，但它们在实现机制和应用场景上存在一些差异。本节将探讨 Fiber 与协程的关系，以及它们如何结合使用，以发挥各自的优势。
5.3.1 协程的概念与发展 (Concept and Development of Coroutines)
协程 (Coroutines) 是一种比线程更轻量级的并发编程模型。协程允许程序在执行过程中暂停和恢复，并在暂停时保存执行状态，以便稍后恢复执行。协程的调度由用户程序控制，无需操作系统内核参与，因此具有较低的开销。
协程的发展历程：
① 早期协程 (Early Coroutines)：协程的概念最早可以追溯到 1950 年代，用于简化复杂的控制流和并发编程。早期的协程通常通过手工编写状态机或使用汇编语言实现。
② 语言内置协程 (Language-Integrated Coroutines)：随着编程语言的发展，越来越多的语言开始内置协程支持，例如 Python 的 async/await，Go 的 goroutine，C# 的 async/await，Kotlin 的 coroutines 等。这些语言提供的协程通常具有更简洁的语法和更强大的功能。
③ C++ 协程 (C++ Coroutines)：C++20 标准正式引入了协程 (Coroutines) 特性，通过 co_await, co_yield, co_return 等关键字，C++ 也具备了原生协程支持。C++ 协程的设计目标是零开销抽象 (Zero-overhead Abstraction)，力求在提供高层抽象的同时，保持与原生代码相近的性能。
5.3.2 Fiber 与协程的异同 (Similarities and Differences between Fibers and Coroutines)
Fiber 和协程都是轻量级并发编程技术，它们都具有以下相似之处：
① 轻量级 (Lightweight)：Fiber 和协程的创建和切换开销都比线程小得多。
② 用户态调度 (User-space Scheduling)：Fiber 和协程的调度都由用户程序控制，无需操作系统内核参与。
③ 协作式多任务处理 (Cooperative Multitasking)：Fiber 和协程通常采用协作式调度，即一个 Fiber 或协程主动让出 CPU，调度器才会选择另一个 Fiber 或协程执行。
然而，Fiber 和协程也存在一些关键的区别：
① 实现机制 (Implementation Mechanism)：Fiber 通常通过保存和恢复执行上下文（寄存器、堆栈等）来实现上下文切换，而协程的实现机制更加多样，可以基于状态机、闭包、生成器等技术。C++20 协程的实现基于 promise 对象和状态机转换。
② 调度方式 (Scheduling Approach)：Fiber 的调度通常由专门的 Fiber 调度器 (Fiber Scheduler) 负责，而协程的调度可能更加灵活，可以由语言运行时、库或用户程序控制。C++20 协程的调度由 awaitable 对象的 await_suspend 方法控制。
③ 应用场景 (Application Scenarios)：Fiber 更侧重于 I/O 密集型应用，例如高性能服务器、网络编程等，而协程的应用场景更加广泛，可以用于各种并发编程任务，例如 GUI 编程、游戏开发、异步算法等。C++20 协程旨在提供一种通用的、零开销的异步编程抽象。
5.3.3 Folly Fiber 与 C++20 协程的结合 (Combination of Folly Fibers and C++20 Coroutines)
Folly Fiber 和 C++20 协程可以结合使用，以发挥各自的优势。Folly Fiber 提供了高效的 Fiber 管理和调度机制，而 C++20 协程提供了简洁的异步编程语法。
结合方式：
① 在 Fiber 中使用 C++20 协程 (Using C++20 Coroutines in Fibers)：可以在 Fiber 函数中调用 C++20 协程，利用 C++20 协程的 co_await 关键字进行异步等待，同时利用 Fiber 的轻量级和高效调度特性。
示例代码：在 Fiber 中使用 C++20 协程 (伪代码)
1
#include <folly/fibers/FiberManager.h>
2
#include <folly/fibers/Fiber.h>
3
#include <iostream>
4
#include <coroutine> // C++20 协程头文件
5
6
using namespace folly::fibers;
7
8
// 模拟异步操作的 awaitable 对象 (简化示例)
9
struct AsyncOperationAwaitable {
10
bool await_ready() noexcept { return false; } // 总是挂起
11
void await_suspend(std::coroutine_handle<> h) noexcept {
12
FiberManager::get()->schedule([h]() {
13
std::this_thread::sleep_for(std::chrono::seconds(1));
14
h.resume(); // 恢复协程执行
15
});
16
}
17
void await_resume() noexcept {}
18
};
19
20
AsyncOperationAwaitable asyncOperation() { return {}; }
21
22
// C++20 协程函数
23
std::coroutine_handle<> coroutineFunction() {
24
std::cout << "协程开始执行..." << std::endl;
25
co_await asyncOperation(); // 挂起协程，等待异步操作完成
26
std::cout << "异步操作完成，协程继续执行..." << std::endl;
27
co_return;
28
}
29
30
Fiber::Func fiberFunction() {
31
return []() {
32
std::cout << "Fiber 开始执行..." << std::endl;
33
coroutineFunction(); // 在 Fiber 中调用协程
34
std::cout << "Fiber 执行结束。" << std::endl;
35
};
36
}
37
38
int main() {
39
FiberManager fm;
40
fm.start();
41
42
FiberManager::get()->schedule(fiberFunction());
43
44
fm.join();
45
std::cout << "程序结束。" << std::endl;
46
return 0;
47
}
代码框架解析：
① 定义 AsyncOperationAwaitable 结构体，模拟一个异步操作的 awaitable 对象。await_suspend 方法中使用 FiberManager::get()->schedule 将协程的恢复操作调度到 Fiber 调度器中执行。
② asyncOperation 函数返回 AsyncOperationAwaitable 对象。
③ coroutineFunction 是一个 C++20 协程函数，使用 co_await asyncOperation() 挂起协程，等待异步操作完成。
④ fiberFunction 返回一个 Fiber 函数，在 Fiber 函数中调用 coroutineFunction()。
⑤ 在 main 函数中，创建 FiberManager 并启动，然后调度 fiberFunction 执行。
结合优势：
⚝ 语法简洁 (Concise Syntax)：C++20 协程提供了 co_await 等关键字，使得异步代码的编写更加简洁和直观。
⚝ 高效调度 (Efficient Scheduling)：Folly Fiber 提供了高效的 Fiber 调度器，可以有效地管理和调度 Fiber 和协程。
⚝ 灵活性 (Flexibility)：可以将 Fiber 和协程灵活地组合使用，根据具体的应用场景选择合适的并发编程模型。
总结：
Fiber 和协程都是强大的并发编程工具，它们可以结合使用，以构建更加高效、灵活和易于维护的并发程序。Folly Fiber 提供了成熟的 Fiber 基础设施，C++20 协程提供了现代化的异步编程语法，将两者结合起来，可以充分发挥各自的优势，为高性能应用开发提供更强大的支持。在实际应用中，可以根据项目的具体需求和技术栈，选择合适的 Fiber 和协程组合方案，以达到最佳的开发效率和程序性能。
5.4 Fiber 的性能优化 (Performance Optimization of Fibers)
Fiber 作为轻量级线程，在高性能应用中扮演着重要的角色。然而，不合理的 Fiber 使用方式也可能导致性能问题。本节将深入探讨 Fiber 性能优化的关键方面，包括上下文切换开销、调度策略、内存管理等方面，并提供实用的性能优化技巧。
5.4.1 降低上下文切换开销 (Reducing Context Switching Overhead)
Fiber 的上下文切换开销远小于线程，但仍然需要尽量减少不必要的上下文切换，以提高程序性能。
优化策略：
① 减少主动让步 (Minimize Voluntary Yielding)：避免在 Fiber 中频繁地调用 Fiber::yield() 或其他主动让步的操作。只有在真正需要等待 I/O 操作或其他耗时任务时，才进行让步。
② 批量处理任务 (Batch Processing Tasks)：将多个小任务合并成一个大任务，减少 Fiber 切换的次数。例如，在网络编程中，可以批量接收和发送数据，而不是每次只处理少量数据。
③ 避免不必要的同步 (Avoid Unnecessary Synchronization)：减少 Fiber 之间的同步操作，例如锁、条件变量等。过多的同步操作会导致 Fiber 频繁地阻塞和唤醒，增加上下文切换开销。
④ 合理设置 Fiber 堆栈大小 (Reasonable Fiber Stack Size)：Fiber 的堆栈大小会影响上下文切换的开销和内存占用。过小的堆栈可能导致堆栈溢出，过大的堆栈会浪费内存。根据 Fiber 执行的任务类型，合理设置 Fiber 堆栈大小，可以使用 FiberManager::Options::stackSize 参数进行配置。
5.4.2 优化 Fiber 调度策略 (Optimizing Fiber Scheduling Policies)
Fiber 调度器的调度策略直接影响 Fiber 的执行效率和程序的整体性能。Folly Fiber 提供了多种调度策略，可以根据应用场景进行选择和定制。
调度策略选择：
① 默认调度策略 (Default Scheduling Policy)：Folly Fiber 默认使用基于工作窃取 (Work-Stealing) 的调度策略，适用于大多数通用场景。
② FIFO 调度策略 (FIFO Scheduling Policy)：先进先出 (First-In-First-Out) 调度策略，按照 Fiber 创建的顺序进行调度。适用于需要保证任务执行顺序的场景。
③ 优先级调度策略 (Priority Scheduling Policy)：根据 Fiber 的优先级进行调度，优先级高的 Fiber 优先执行。适用于需要区分任务重要性的场景。
④ 自定义调度策略 (Custom Scheduling Policy)：Folly Fiber 允许用户自定义调度策略，通过实现 FiberScheduler 接口，可以根据具体的应用需求定制调度策略。
调度策略优化技巧：
⚝ 根据任务类型选择合适的调度策略：例如，对于 I/O 密集型任务，可以使用默认的基于工作窃取的调度策略；对于 CPU 密集型任务，可以考虑使用优先级调度策略，将高优先级任务优先调度到 CPU 上执行。
⚝ 调整调度器参数：Folly Fiber 调度器提供了一些参数可以调整，例如工作窃取的粒度、线程数等。根据实际的负载情况，调整这些参数可以优化调度器的性能。
⚝ 避免饥饿 (Starvation)：在优先级调度策略中，需要注意避免低优先级 Fiber 长时间得不到执行，导致饥饿现象。可以使用一些公平调度算法，例如时间片轮转 (Round-Robin) 调度，来保证所有 Fiber 都有机会执行。
5.4.3 Fiber 内存管理优化 (Fiber Memory Management Optimization)
Fiber 的内存管理主要涉及 Fiber 堆栈的分配和回收。合理的内存管理策略可以降低内存占用，提高程序性能。
内存管理策略：
① 堆栈池化 (Stack Pooling)：Folly Fiber 提供了堆栈池化技术，可以重用 Fiber 的堆栈空间，避免频繁地分配和回收堆栈内存。通过 FiberManager::Options::stackPoolSize 参数可以配置堆栈池的大小。
② 动态堆栈调整 (Dynamic Stack Adjustment)：一些 Fiber 实现支持动态调整堆栈大小，根据 Fiber 的实际堆栈使用情况，动态地增加或减少堆栈空间。Folly Fiber 默认使用固定大小的堆栈，但可以通过自定义 Fiber 实现动态堆栈调整。
③ 避免堆栈溢出 (Avoid Stack Overflow)：堆栈溢出是 Fiber 编程中常见的错误。要避免堆栈溢出，需要合理估计 Fiber 的堆栈需求，并设置足够大的堆栈大小。可以使用工具 (例如 Valgrind) 检测堆栈溢出错误。
④ 及时释放资源 (Release Resources Timely)：在 Fiber 执行完成后，及时释放 Fiber 占用的资源，例如堆栈内存、文件句柄、网络连接等。可以使用 RAII (Resource Acquisition Is Initialization) 技术，确保资源在 Fiber 生命周期结束时被正确释放。
5.4.4 性能分析与调优工具 (Performance Analysis and Tuning Tools)
性能分析和调优工具是 Fiber 性能优化的重要辅助手段。通过使用这些工具，可以深入了解 Fiber 程序的性能瓶颈，并进行有针对性的优化。
常用工具：
① 性能分析器 (Profilers)：例如 gprof, perf, Valgrind 等。性能分析器可以收集 Fiber 程序的性能数据，例如 CPU 使用率、内存占用、函数调用次数、上下文切换次数等，帮助识别性能瓶颈。
② 火焰图 (Flame Graphs)：火焰图是一种可视化性能分析结果的工具，可以将函数调用栈以火焰的形式展示出来，直观地显示程序的 CPU 耗时分布。
③ Folly Fiber 提供的诊断工具 (Folly Fiber Diagnostic Tools)：Folly Fiber 提供了一些内置的诊断工具，例如 FiberManager::dumpStats() 方法，可以输出 Fiber 调度器的统计信息，帮助了解 Fiber 的调度情况。
④ 自定义性能监控 (Custom Performance Monitoring)：可以根据具体的应用需求，自定义性能监控指标，例如 Fiber 的平均执行时间、吞吐量、延迟等，并使用监控工具 (例如 Prometheus, Grafana) 进行可视化展示和分析。
性能调优流程：
① 性能测试 (Performance Testing)：在真实或模拟的负载环境下，对 Fiber 程序进行性能测试，收集性能数据。
② 性能分析 (Performance Analysis)：使用性能分析工具分析性能数据，识别性能瓶颈。
③ 性能优化 (Performance Optimization)：根据性能分析结果，采取相应的优化策略，例如降低上下文切换开销、优化调度策略、改进内存管理等。
④ 性能验证 (Performance Verification)：优化后，重新进行性能测试，验证优化效果。如果性能仍然不理想，重复步骤 ②-④，直到达到性能目标。
总结：
Fiber 性能优化是一个持续迭代的过程，需要结合具体的应用场景和性能数据，不断地进行分析、优化和验证。通过深入理解 Fiber 的工作原理，掌握性能优化的关键技巧，并善用性能分析和调优工具，可以构建出高性能、高效率的 Fiber 应用。
5.5 Fiber 的调试与诊断 (Debugging and Diagnosis of Fibers)
Fiber 编程虽然具有诸多优势，但也带来了一些新的调试和诊断挑战。由于 Fiber 的用户态调度和协作式多任务处理特性，传统的线程调试工具可能无法直接适用。本节将深入探讨 Fiber 调试与诊断的关键问题，并介绍实用的调试技巧和工具。
5.5.1 Fiber 调试的挑战 (Challenges of Fiber Debugging)
Fiber 调试相比线程调试，面临以下挑战：
① 用户态调度 (User-space Scheduling)：Fiber 的调度由用户态程序控制，操作系统内核对 Fiber 的执行情况感知较少，传统的内核级调试器 (例如 gdb) 在 Fiber 调试方面可能功能受限。
② 协作式多任务处理 (Cooperative Multitasking)：Fiber 之间的切换是协作式的，一个 Fiber 的错误可能导致整个 Fiber 调度器或程序崩溃，错误传播路径可能比较复杂，难以定位。
③ 上下文切换频繁 (Frequent Context Switching)：Fiber 的上下文切换非常频繁，单步调试时容易跳入调度器代码，干扰调试流程。
④ 缺乏成熟的调试工具 (Lack of Mature Debugging Tools)：相比线程调试，Fiber 调试工具相对较少，功能也可能不够完善。
5.5.2 常用的 Fiber 调试技巧 (Common Fiber Debugging Techniques)
虽然 Fiber 调试存在一些挑战，但仍然可以使用一些有效的调试技巧来定位和解决 Fiber 程序中的问题。
① 日志 (Logging)：在 Fiber 程序中添加详细的日志输出，记录 Fiber 的执行状态、关键变量的值、错误信息等。通过分析日志，可以了解 Fiber 的执行流程，定位错误发生的位置。
② 断言 (Assertions)：在代码中添加断言，检查程序的状态是否符合预期。当断言失败时，程序会终止并输出错误信息，帮助快速发现错误。
③ 单元测试 (Unit Testing)：编写单元测试用例，对 Fiber 程序的各个模块进行测试。通过单元测试，可以尽早发现和修复错误，提高代码质量。
④ 简化问题 (Problem Simplification)：当遇到复杂的 Fiber 调试问题时，尝试将问题简化，例如缩小问题范围、减少并发 Fiber 数量、隔离错误代码等。通过简化问题，可以更容易地定位错误根源。
⑤ 使用 Fiber 调度器提供的诊断信息 (Using Diagnostic Information Provided by Fiber Scheduler)：Folly Fiber 的 FiberManager 提供了一些诊断方法，例如 dumpStats()，可以输出 Fiber 调度器的统计信息，帮助了解 Fiber 的调度情况。
5.5.3 借助调试工具进行 Fiber 诊断 (Using Debugging Tools for Fiber Diagnosis)
除了传统的调试技巧，还可以借助一些专门的调试工具来辅助 Fiber 诊断。
① gdb 线程调试功能 (gdb Thread Debugging Features)：虽然 gdb 对 Fiber 的支持有限，但 gdb 的线程调试功能仍然可以用于 Fiber 调试。可以使用 gdb 的线程命令 (例如 info threads, thread <id>, break <location> thread <id>) 来查看和控制 Fiber 所在的线程，设置断点，单步调试等。
② Valgrind (内存错误检测工具)：Valgrind 是一款强大的内存错误检测工具，可以检测 Fiber 程序中的内存泄漏、非法内存访问、堆栈溢出等错误。Valgrind 对 Fiber 程序同样适用，可以帮助发现 Fiber 相关的内存问题。
③ 自定义 Fiber 调试器 (Custom Fiber Debugger)：对于复杂的 Fiber 调试需求，可以考虑自定义 Fiber 调试器。自定义 Fiber 调试器可以根据具体的 Fiber 实现和调度机制，提供更精细化的调试功能，例如 Fiber 状态查看、Fiber 切换跟踪、Fiber 堆栈检查等。
5.5.4 常见 Fiber 编程错误与诊断 (Common Fiber Programming Errors and Diagnosis)
了解常见的 Fiber 编程错误，可以帮助更快地定位和解决 Fiber 程序中的问题。
① 堆栈溢出 (Stack Overflow)：Fiber 堆栈空间有限，如果 Fiber 执行的任务需要过多的堆栈空间，就可能导致堆栈溢出。堆栈溢出通常会导致程序崩溃或产生未定义行为。诊断方法：使用 Valgrind 等内存错误检测工具，或者增大 Fiber 堆栈大小。
② 死锁 (Deadlock)：Fiber 之间可能因为资源竞争而发生死锁。死锁会导致程序卡死，无法继续执行。诊断方法：分析 Fiber 之间的同步关系，检查是否存在循环等待资源的情况。可以使用日志或调试器跟踪 Fiber 的执行状态，定位死锁发生的位置。
③ 竞态条件 (Race Condition)：多个 Fiber 访问共享资源时，如果没有进行正确的同步，就可能发生竞态条件。竞态条件会导致程序行为不确定，结果错误。诊断方法：使用线程安全的数据结构和同步机制，例如互斥锁、条件变量等，保护共享资源的访问。可以使用 Valgrind 的 Helgrind 工具检测竞态条件。
④ Fiber 泄漏 (Fiber Leak)：如果 Fiber 创建后没有被正确地销毁，就可能发生 Fiber 泄漏。Fiber 泄漏会导致资源占用不断增加，最终可能导致内存耗尽。诊断方法：检查 Fiber 的生命周期管理，确保 Fiber 在执行完成后被正确地销毁。可以使用性能分析工具监控 Fiber 的数量，检测是否存在 Fiber 泄漏。
⑤ 协作式调度问题 (Cooperative Scheduling Issues)：如果 Fiber 中存在长时间运行的 CPU 密集型任务，或者 Fiber 没有及时让出 CPU，就可能导致其他 Fiber 无法得到执行，影响程序的并发性和响应速度。诊断方法：分析 Fiber 的执行逻辑，将 CPU 密集型任务分解成小任务，或者在适当的时候主动让出 CPU。可以使用性能分析工具监控 Fiber 的执行时间，检测是否存在调度问题。
总结：
Fiber 调试与诊断是一个需要经验和技巧的过程。通过掌握常用的调试技巧和工具，了解常见的 Fiber 编程错误，并结合实际的调试案例进行练习，可以逐步提高 Fiber 调试能力，构建更加健壮和可靠的 Fiber 应用。在实际开发中，应该重视代码质量，编写清晰、简洁、易于理解和调试的 Fiber 代码，并进行充分的测试和验证，以减少调试的难度和成本。
END_OF_CHAPTER
6. chapter 6： FiberManager.h API 全面解析 (Comprehensive API Analysis of FiberManager.h)
本章深入探讨 folly/fibers/FiberManager.h 头文件中定义的 API，FiberManager 是 Folly Fiber 库的核心组件，负责管理和调度 Fiber 的执行。理解 FiberManager 的 API 对于有效地使用 Folly Fiber 至关重要。本章将从类 FiberManager 的结构入手，详细解析其公有、保护和静态成员函数，并介绍相关的类型定义与枚举，帮助读者全面掌握 FiberManager 的功能和用法。
6.1 类 FiberManager (Class FiberManager)
FiberManager 类是 Folly Fiber 库中用于管理 Fiber 的核心类。它负责 Fiber 的创建、调度、执行和生命周期管理。FiberManager 通常以单例模式存在于应用程序中，为整个程序提供统一的 Fiber 管理服务。
6.1.1 公有成员函数 (Public Member Functions)
FiberManager 的公有成员函数提供了外部与 Fiber 管理器交互的主要接口。这些函数允许用户创建、启动、控制和查询 Fiber 的状态。
① static FiberManager& get();
⚝ 功能：获取全局唯一的 FiberManager 实例的引用。
⚝ 详解：get() 是一个静态成员函数，用于实现单例模式。它返回一个 FiberManager 对象的静态引用，确保在整个应用程序中只有一个 FiberManager 实例存在。这是访问和操作 Fiber 管理器的入口点。
⚝ 示例：
1
#include <folly/fibers/FiberManager.h>
2
3
int main() {
4
folly::fibers::FiberManager& fm = folly::fibers::FiberManager::get();
5
// 使用 fm 进行 Fiber 管理操作
6
return 0;
7
}
② void reset();
⚝ 功能：重置 FiberManager 的状态，停止所有正在运行的 Fiber 并清理资源。
⚝ 详解：reset() 函数用于将 FiberManager 恢复到初始状态。它会停止所有由该 FiberManager 管理的 Fiber 的执行，并释放相关的资源，例如 Fiber 栈和调度器资源。通常在程序退出或者需要重新初始化 Fiber 环境时调用。
⚝ 注意：调用 reset() 会强制终止正在运行的 Fiber，可能导致数据丢失或状态不一致。在调用前应确保所有重要的操作已完成。
③ Fiber::Ptr start(Func func, Args&&... args);
⚝ 功能：创建一个新的 Fiber 并开始执行指定的函数 func。
⚝ 详解：start() 函数是创建和启动 Fiber 的主要方法。它接受一个函数对象 func 和其参数 args 作为输入，创建一个新的 Fiber 对象，并将 func 作为 Fiber 的入口函数。创建的 Fiber 会被添加到 FiberManager 的调度队列中，等待调度器执行。
⚝ 返回值：返回一个指向新创建 Fiber 对象的智能指针 Fiber::Ptr。用户可以通过这个智能指针来管理 Fiber 的生命周期。
⚝ 模板参数：
▮▮▮▮⚝ Func: Fiber 入口函数的类型，可以是函数指针、函数对象或 Lambda 表达式。
▮▮▮▮⚝ Args: 传递给入口函数的参数类型。
⚝ 示例：
1
#include <folly/fibers/FiberManager.h>
2
#include <iostream>
3
4
void fiber_func(int id) {
5
std::cout << "Fiber " << id << " is running." << std::endl;
6
}
7
8
int main() {
9
folly::fibers::FiberManager& fm = folly::fibers::FiberManager::get();
10
auto fiber_ptr = fm.start(fiber_func, 1); // 启动一个 Fiber 执行 fiber_func(1)
11
fm.reset(); // 等待 Fiber 执行完成并清理资源
12
return 0;
13
}
④ Fiber::Ptr start(Options options, Func func, Args&&... args);
⚝ 功能：创建一个新的 Fiber 并开始执行指定的函数 func，并允许通过 Options 对象自定义 Fiber 的属性。
⚝ 详解：此重载版本的 start() 函数与上一个版本类似，但它接受一个 Options 对象作为第一个参数，允许用户更精细地控制 Fiber 的创建行为。Options 对象可以设置 Fiber 的栈大小、优先级、调度策略等属性。
⚝ 参数：
▮▮▮▮⚝ options: 一个 Options 对象，用于配置 Fiber 的属性。
▮▮▮▮⚝ func: Fiber 入口函数。
▮▮▮▮⚝ args: 传递给入口函数的参数。
⚝ 返回值：返回指向新创建 Fiber 对象的智能指针 Fiber::Ptr。
⚝ 示例：
1
#include <folly/fibers/FiberManager.h>
2
#include <iostream>
3
4
void fiber_func(int id) {
5
std::cout << "Fiber " << id << " is running." << std::endl;
6
}
7
8
int main() {
9
folly::fibers::FiberManager& fm = folly::fibers::FiberManager::get();
10
folly::fibers::FiberManager::Options options;
11
options.stackSize(128 * 1024); // 设置 Fiber 栈大小为 128KB
12
auto fiber_ptr = fm.start(options, fiber_func, 2); // 启动一个自定义配置的 Fiber
13
fm.reset();
14
return 0;
15
}
⑤ void schedule(Fiber& fiber);
⚝ 功能：将一个已创建但尚未调度的 Fiber 添加到调度队列中，使其等待被调度执行。
⚝ 详解：schedule() 函数用于手动将一个 Fiber 对象添加到 FiberManager 的调度队列。这通常用于在 Fiber 对象创建后，延迟或在特定条件下才开始执行 Fiber。
⚝ 参数：
▮▮▮▮⚝ fiber: 要调度的 Fiber 对象的引用。
⚝ 使用场景：例如，在某些初始化工作完成后，再启动 Fiber 的执行。
⑥ void run();
⚝ 功能：启动 FiberManager 的调度循环，开始调度和执行 Fiber。
⚝ 详解：run() 函数启动 FiberManager 的主调度循环。调度循环会不断地从调度队列中取出就绪的 Fiber 并执行，直到调度队列为空或者 FiberManager 被重置。通常在主线程中调用 run() 函数来启动 Fiber 的调度。
⚝ 阻塞调用：run() 函数是一个阻塞调用，它会一直运行直到 FiberManager 被显式停止（例如通过 reset()）。
⚝ 注意：在调用 run() 之前，通常需要先使用 start() 或 schedule() 创建并添加 Fiber 到调度队列中。
⑦ void runInMainLoop();
⚝ 功能：将当前的 FiberManager 调度循环集成到主事件循环中。
⚝ 详解：runInMainLoop() 函数用于将 FiberManager 的调度逻辑集成到应用程序的主事件循环中，例如 GUI 应用程序或基于事件驱动的网络服务器。这样 Fiber 的调度可以与主事件循环协同工作，避免阻塞主线程。
⚝ 集成事件循环：具体集成方式取决于应用程序使用的事件循环库。Folly Fiber 可能会提供与特定事件循环库（如 libevent, libuv 等）的集成接口。
⑧ bool isRunning();
⚝ 功能：检查 FiberManager 的调度循环是否正在运行。
⚝ 详解：isRunning() 函数返回一个布尔值，指示 FiberManager 的调度循环是否处于活动状态。如果调度循环正在运行，则返回 true，否则返回 false。
⚝ 用途：可以用于判断 FiberManager 的状态，例如在需要停止或重置 FiberManager 之前，先检查其是否正在运行。
⑨ size_t fiberCount() const;
⚝ 功能：获取当前 FiberManager 管理的 Fiber 的总数量。
⚝ 详解：fiberCount() 函数返回当前 FiberManager 正在管理的所有 Fiber 的数量，包括正在运行、等待调度和已完成但尚未清理的 Fiber。
⚝ 返回值：返回一个 size_t 类型的值，表示 Fiber 的数量。
⚝ 用途：可以用于监控 Fiber 的数量，了解系统的并发负载情况。
⑩ size_t runningFiberCount() const;
⚝ 功能：获取当前正在运行的 Fiber 的数量。
⚝ 详解：runningFiberCount() 函数返回当前正在 CPU 上执行的 Fiber 的数量。由于 Fiber 是协作式调度的，同一时刻真正并行运行的 Fiber 数量通常受限于 CPU 核心数和调度策略。
⚝ 返回值：返回一个 size_t 类型的值，表示正在运行的 Fiber 的数量。
⑪ size_t queuedFiberCount() const;
⚝ 功能：获取当前在调度队列中等待调度的 Fiber 的数量。
⚝ 详解：queuedFiberCount() 函数返回当前在 FiberManager 的调度队列中等待被调度的 Fiber 的数量。这些 Fiber 已经创建并添加到调度队列，但尚未被调度器选中执行。
⚝ 返回值：返回一个 size_t 类型的值，表示等待调度的 Fiber 的数量。
⑫ FiberScheduler& getScheduler();
⚝ 功能：获取 FiberManager 使用的 FiberScheduler 对象的引用。
⚝ 详解：getScheduler() 函数返回 FiberManager 内部使用的 FiberScheduler 对象的引用。FiberScheduler 负责具体的 Fiber 调度策略和执行机制。通过访问 FiberScheduler 对象，可以进一步了解和定制 Fiber 的调度行为。
⚝ 返回值：返回一个 FiberScheduler 对象的引用。
⑬ void setScheduler(std::unique_ptr<FiberScheduler> scheduler);
⚝ 功能：设置 FiberManager 使用的 FiberScheduler 对象。
⚝ 详解：setScheduler() 函数允许用户自定义 FiberManager 使用的 FiberScheduler。用户可以创建自己的 FiberScheduler 实现，并将其设置为 FiberManager 的调度器，从而定制 Fiber 的调度策略。
⚝ 参数：
▮▮▮▮⚝ scheduler: 一个指向 FiberScheduler 对象的 std::unique_ptr，表示要设置的新调度器。
⚝ 所有权转移：FiberManager 会接管 scheduler 的所有权。
⑭ FiberManager(const FiberManager&) = delete; 和 FiberManager& operator=(const FiberManager&) = delete;
⚝ 功能：禁用拷贝构造函数和拷贝赋值运算符。
⚝ 详解：这两个声明 = delete 表明 FiberManager 类禁止拷贝构造和拷贝赋值。这是单例模式的常见做法，防止创建多个 FiberManager 实例，确保全局唯一性。
6.1.2 保护成员函数 (Protected Member Functions)
FiberManager 的保护成员函数通常用于子类化和扩展 FiberManager 的功能。普通用户一般不需要直接调用这些函数。
① FiberManager();
⚝ 功能：默认构造函数。
⚝ 详解：FiberManager 的默认构造函数是保护的，这意味着不能直接在类外部创建 FiberManager 对象。只能通过静态成员函数 get() 获取单例实例。
② virtual ~FiberManager();
⚝ 功能：虚析构函数。
⚝ 详解：虚析构函数允许在继承自 FiberManager 的子类中正确地释放资源。虽然 FiberManager 通常以单例模式使用，但提供虚析构函数是一种良好的面向对象设计实践，为可能的扩展和继承提供支持。
③ virtual void fiberExited(Fiber& fiber);
⚝ 功能：当一个 Fiber 执行完成后，FiberManager 会调用此虚函数。
⚝ 详解：fiberExited() 是一个虚函数，子类可以重写此函数来执行 Fiber 退出后的自定义操作，例如资源清理、统计信息收集等。
⚝ 参数：
▮▮▮▮⚝ fiber: 已退出的 Fiber 对象的引用。
④ virtual void onRunLoopEmpty();
⚝ 功能：当 FiberManager 的调度循环发现调度队列为空时，会调用此虚函数。
⚝ 详解：onRunLoopEmpty() 是一个虚函数，子类可以重写此函数来执行在调度队列为空时的自定义操作，例如进入空闲状态、执行后台任务等。
6.1.3 静态成员函数 (Static Member Functions)
FiberManager 的静态成员函数提供了类级别的操作，例如获取单例实例和配置全局选项。
① static FiberManager& get(); (已在 6.1.1 中详细介绍)
② static Options getDefaultOptions();
⚝ 功能：获取默认的 Fiber 创建选项。
⚝ 详解：getDefaultOptions() 函数返回一个 Options 对象，其中包含了创建 Fiber 时使用的默认配置，例如默认的栈大小、调度策略等。用户可以修改返回的 Options 对象来定制默认的 Fiber 创建行为。
⚝ 返回值：返回一个 Options 对象，包含默认的 Fiber 创建选项。
③ static void setDefaultOptions(Options options);
⚝ 功能：设置默认的 Fiber 创建选项。
⚝ 详解：setDefaultOptions() 函数允许用户全局地设置默认的 Fiber 创建选项。通过调用此函数，可以修改后续所有通过 start() 创建的 Fiber 的默认属性，除非在 start() 调用中显式指定了 Options 对象。
⚝ 参数：
▮▮▮▮⚝ options: 要设置的默认 Options 对象。
6.2 相关类型定义与枚举 (Related Type Definitions and Enumerations)
在 FiberManager.h 中，除了 FiberManager 类本身，还定义了一些相关的类型定义和枚举，用于配置和控制 Fiber 的行为。
① struct Options;
⚝ 功能：Options 结构体用于封装 Fiber 的创建选项。
⚝ 成员：
▮▮▮▮⚝ size_t stackSize_: Fiber 的栈大小，单位通常是字节。
▮▮▮▮⚝ FiberPriority priority_: Fiber 的优先级，用于调度器进行优先级调度。
▮▮▮▮⚝ 其他可能的选项，例如调度策略、Fiber 名称等。
⚝ 用法：Options 对象可以传递给 FiberManager::start() 函数，以自定义创建的 Fiber 的属性。
② enum FiberPriority;
⚝ 功能：FiberPriority 枚举定义了 Fiber 的优先级级别。
⚝ 枚举值：
▮▮▮▮⚝ NORMAL: 正常优先级。
▮▮▮▮⚝ HIGH: 高优先级。
▮▮▮▮⚝ LOW: 低优先级。
▮▮▮▮⚝ 其他可能的优先级级别。
⚝ 用法：Fiber 的优先级可以影响调度器对 Fiber 的调度顺序。高优先级的 Fiber 可能会被优先调度执行。可以通过 Options 对象设置 Fiber 的优先级。
③ using Func = std::function<void()>;
⚝ 功能：Func 类型定义为 std::function<void()>，表示 Fiber 的入口函数类型。
⚝ 详解：Func 是一个类型别名，代表一个无参数、无返回值的函数对象。Fiber 的入口函数需要符合 Func 的类型签名。实际上，FiberManager::start() 的 Func 模板参数可以是更通用的函数对象，但最终会被适配成 std::function<void()> 的形式。
④ using Ptr = std::shared_ptr<Fiber>;
⚝ 功能：Ptr 类型定义为 std::shared_ptr<Fiber>，表示指向 Fiber 对象的智能指针。
⚝ 详解：Ptr 是一个类型别名，使用 std::shared_ptr 管理 Fiber 对象的生命周期。通过 shared_ptr 可以方便地进行 Fiber 对象的共享和自动内存管理。FiberManager::start() 函数返回的就是 Fiber::Ptr 类型的智能指针。
通过本章的详细解析，读者应该对 folly/fibers/FiberManager.h 中 FiberManager 类的 API 有了全面的了解。掌握这些 API 的用法，可以有效地使用 Folly Fiber 库进行 Fiber 的创建、调度和管理，构建高性能的并发应用程序。在后续章节中，我们将继续深入探讨 Fiber 类以及 Folly Fiber 的高级应用和实战案例。
END_OF_CHAPTER
7. chapter 7： Fiber.h API 全面解析 (Comprehensive API Analysis of Fiber.h)
7.1 类 Fiber (Class Fiber)
Fiber.h 中最核心的类是 Fiber 类，它代表了纤程（Fiber）本身。Fiber 类封装了纤程的执行上下文、状态以及控制方法。本节将深入剖析 Fiber 类的公有、保护和静态成员函数，帮助读者全面理解 Fiber 类的 API 设计和使用方式。
7.1.1 公有成员函数 (Public Member Functions)
Fiber 类的公有成员函数提供了操作和管理纤程的主要接口，这些函数允许用户创建、启动、控制和查询纤程的状态。
① Fiber(Func func, Args... args)
⚝ 功能：构造函数，用于创建一个新的 Fiber 对象。
⚝ 参数：
▮▮▮▮⚝ Func func: 纤程要执行的函数，可以是函数指针、函数对象或 Lambda 表达式。
▮▮▮▮⚝ Args... args: 传递给 func 函数的参数列表。
⚝ 返回值：无。
⚝ 说明：
▮▮▮▮⚝ 构造函数本身不会启动纤程的执行。纤程的启动需要显式调用 start() 或 startAndWait() 方法。
▮▮▮▮⚝ 构造函数会将传入的函数 func 和参数 args 存储起来，并在纤程启动时执行。
⚝ 示例：
1
#include <folly/fibers/Fiber.h>
2
#include <iostream>
3
4
void fiberFunction(int id) {
5
std::cout << "Fiber " << id << " is running." << std::endl;
6
}
7
8
int main() {
9
folly::fibers::Fiber f1(fiberFunction, 1); // 创建 Fiber 对象，但未启动
10
folly::fibers::Fiber f2([](std::string name){ // 使用 Lambda 表达式
11
std::cout << "Hello, " << name << " from fiber." << std::endl;
12
}, "Fiber User");
13
return 0;
14
}
② ~Fiber()
⚝ 功能：析构函数，用于销毁 Fiber 对象。
⚝ 参数：无。
⚝ 返回值：无。
⚝ 说明：
▮▮▮▮⚝ 析构函数负责释放 Fiber 对象占用的资源，包括纤程的栈空间和上下文信息。
▮▮▮▮⚝ 确保在 Fiber 对象不再使用时及时销毁，避免资源泄漏。
▮▮▮▮⚝ 如果纤程还在运行，析构函数的行为取决于具体的实现和上下文，通常应该确保纤程能够安全地结束。
③ void start()
⚝ 功能：启动纤程的执行。
⚝ 参数：无。
⚝ 返回值：无。
⚝ 说明：
▮▮▮▮⚝ start() 函数将纤程加入到 FiberManager 的调度队列中，等待调度器调度执行。
▮▮▮▮⚝ 调用 start() 后，纤程会异步执行，控制权立即返回给调用者。
▮▮▮▮⚝ 纤程的实际执行时间取决于调度器的策略和系统的负载。
⚝ 示例：
1
#include <folly/fibers/Fiber.h>
2
#include <iostream>
3
4
void fiberFunction() {
5
std::cout << "Fiber is running." << std::endl;
6
}
7
8
int main() {
9
folly::fibers::Fiber fiber(fiberFunction);
10
fiber.start(); // 启动纤程
11
std::cout << "Fiber started." << std::endl;
12
return 0; // 主线程继续执行
13
}
④ void startAndWait()
⚝ 功能：启动纤程并等待其执行完成。
⚝ 参数：无。
⚝ 返回值：无。
⚝ 说明：
▮▮▮▮⚝ startAndWait() 函数启动纤程后，会阻塞当前线程，直到纤程执行完成。
▮▮▮▮⚝ 适用于需要同步等待纤程执行结果的场景。
▮▮▮▮⚝ 内部实现通常会使用某种同步机制（例如信号量或条件变量）来等待纤程结束。
⚝ 示例：
1
#include <folly/fibers/Fiber.h>
2
#include <iostream>
3
4
int fiberFunction() {
5
std::cout << "Fiber is running and returning 42." << std::endl;
6
return 42;
7
}
8
9
int main() {
10
folly::fibers::Fiber fiber(fiberFunction);
11
fiber.startAndWait(); // 启动纤程并等待完成
12
std::cout << "Fiber finished." << std::endl;
13
return 0;
14
}
⑤ bool join()
⚝ 功能：等待纤程执行完成。
⚝ 参数：无。
⚝ 返回值：bool 类型，表示等待是否成功。通常总是返回 true。
⚝ 说明：
▮▮▮▮⚝ join() 函数与 startAndWait() 类似，也用于等待纤程结束。
▮▮▮▮⚝ 与 startAndWait() 的区别在于，join() 假设纤程已经启动（可能通过 start() 或其他方式启动），而 startAndWait() 则会启动纤程并等待。
▮▮▮▮⚝ 如果纤程尚未启动或已经结束，join() 的行为可能取决于具体实现，但通常会立即返回。
⚝ 示例：
1
#include <folly/fibers/Fiber.h>
2
#include <iostream>
3
#include <thread>
4
#include <chrono>
5
6
void fiberFunction() {
7
std::cout << "Fiber is running for 2 seconds." << std::endl;
8
std::this_thread::sleep_for(std::chrono::seconds(2));
9
std::cout << "Fiber finished." << std::endl;
10
}
11
12
int main() {
13
folly::fibers::Fiber fiber(fiberFunction);
14
fiber.start(); // 启动纤程
15
std::cout << "Waiting for fiber to join." << std::endl;
16
fiber.join(); // 等待纤程结束
17
std::cout << "Fiber joined." << std::endl;
18
return 0;
19
}
⑥ bool joinInterruptibly()
⚝ 功能：可中断地等待纤程执行完成。
⚝ 参数：无。
⚝ 返回值：bool 类型，表示等待是否成功。如果等待被中断，可能返回 false。
⚝ 说明：
▮▮▮▮⚝ joinInterruptibly() 允许在等待纤程结束的过程中被中断，例如通过取消操作。
▮▮▮▮⚝ 具体的中断机制和行为取决于 Fiber 库的实现。
▮▮▮▮⚝ 适用于需要响应取消信号的场景。
⑦ bool isRunning() const
⚝ 功能：检查纤程是否正在运行。
⚝ 参数：无。
⚝ 返回值：bool 类型，true 表示纤程正在运行，false 表示纤程未运行或已结束。
⚝ 说明：
▮▮▮▮⚝ isRunning() 函数可以用来查询纤程的当前状态。
▮▮▮▮⚝ "正在运行" 的状态通常指纤程已经被调度器调度，并且其执行函数正在执行中。
⚝ 示例：
1
#include <folly/fibers/Fiber.h>
2
#include <iostream>
3
#include <thread>
4
#include <chrono>
5
6
void fiberFunction() {
7
std::cout << "Fiber started." << std::endl;
8
std::this_thread::sleep_for(std::chrono::seconds(1));
9
std::cout << "Fiber finished." << std::endl;
10
}
11
12
int main() {
13
folly::fibers::Fiber fiber(fiberFunction);
14
fiber.start();
15
std::cout << "Is fiber running? " << fiber.isRunning() << std::endl; // 可能为 true
16
std::this_thread::sleep_for(std::chrono::seconds(2));
17
std::cout << "Is fiber running? " << fiber.isRunning() << std::endl; // 应该为 false
18
fiber.join();
19
return 0;
20
}
⑧ bool isFinished() const
⚝ 功能：检查纤程是否已经执行完成。
⚝ 参数：无。
⚝ 返回值：bool 类型，true 表示纤程已执行完成，false 表示纤程仍在运行或尚未启动。
⚝ 说明：
▮▮▮▮⚝ isFinished() 函数用于判断纤程是否已经结束执行。
▮▮▮▮⚝ 纤程执行完成后，状态会变为 "finished"。
⑨ void cancel()
⚝ 功能：请求取消纤程的执行。
⚝ 参数：无。
⚝ 返回值：无。
⚝ 说明：
▮▮▮▮⚝ cancel() 函数向纤程发送取消请求。
▮▮▮▮⚝ 纤程是否能够被成功取消以及如何响应取消请求取决于纤程内部的实现逻辑。
▮▮▮▮⚝ 通常纤程需要主动检查取消状态并做出相应的处理，例如提前退出执行。
▮▮▮▮⚝ Folly Fiber 提供了取消相关的机制，纤程可以通过检查特定的标志或调用取消相关的 API 来响应取消请求。
⑩ bool isCancelled() const
⚝ 功能：检查纤程是否已被取消。
⚝ 参数：无。
⚝ 返回值：bool 类型，true 表示纤程已被取消，false 表示纤程未被取消。
⚝ 说明：
▮▮▮▮⚝ isCancelled() 函数用于查询纤程的取消状态。
▮▮▮▮⚝ 纤程内部可以定期或在适当的时机调用 isCancelled() 来检查是否需要停止执行。
⑪ Fiber::Id getId() const
⚝ 功能：获取纤程的唯一标识符（ID）。
⚝ 参数：无。
⚝ 返回值：Fiber::Id 类型，表示纤程的 ID。
⚝ 说明：
▮▮▮▮⚝ 每个 Fiber 对象都有一个唯一的 ID，用于区分不同的纤程。
▮▮▮▮⚝ Fiber::Id 的具体类型可能是整数、指针或其他能够唯一标识纤程的类型。
▮▮▮▮⚝ 可以使用纤程 ID 进行日志记录、调试或其他需要区分纤程的场景。
⑫ FiberManager* getManager() const
⚝ 功能：获取管理当前纤程的 FiberManager 对象的指针。
⚝ 参数：无。
⚝ 返回值：FiberManager* 类型，指向管理当前纤程的 FiberManager 对象的指针。
⚝ 说明：
▮▮▮▮⚝ 每个 Fiber 对象都关联到一个 FiberManager 对象，由该 FiberManager 负责调度和管理。
▮▮▮▮⚝ 通过 getManager() 可以获取到 FiberManager 的指针，从而可以访问 FiberManager 提供的功能，例如获取调度器信息、创建新的纤程等。
⑬ void resetStackGuardPage()
⚝ 功能：重置纤程的栈保护页（Stack Guard Page）。
⚝ 参数：无。
⚝ 返回值：无。
⚝ 说明：
▮▮▮▮⚝ 栈保护页是一种用于检测栈溢出的机制。在栈的末尾设置一个特殊的内存页（保护页），当栈溢出时会访问到保护页，从而触发异常或错误，帮助检测栈溢出问题。
▮▮▮▮⚝ resetStackGuardPage() 函数可能用于在某些情况下重新设置栈保护页，例如在纤程栈被修改后。
▮▮▮▮⚝ 栈保护页的具体实现和使用方式可能与操作系统和硬件平台有关。
⑭ static Fiber* current()
⚝ 功能：获取当前正在执行的纤程的 Fiber 对象指针。
⚝ 参数：无。
⚝ 返回值：Fiber* 类型，指向当前正在执行的纤程的 Fiber 对象指针。如果当前上下文中没有纤程在执行，则可能返回 nullptr。
⚝ 说明：
▮▮▮▮⚝ current() 是一个静态成员函数，可以在纤程内部调用，获取当前纤程的 Fiber 对象指针。
▮▮▮▮⚝ 允许纤程访问自身的 Fiber 对象，从而可以调用自身的成员函数，例如获取 ID、取消自身等。
▮▮▮▮⚝ 只能在纤程上下文中安全调用，在线程上下文中调用可能返回 nullptr 或未定义行为。
⚝ 示例：
1
#include <folly/fibers/Fiber.h>
2
#include <iostream>
3
4
void fiberFunction() {
5
folly::fibers::Fiber* currentFiber = folly::fibers::Fiber::current();
6
if (currentFiber) {
7
std::cout << "Current fiber ID: " << currentFiber->getId() << std::endl;
8
} else {
9
std::cout << "Not running in a fiber context." << std::endl;
10
}
11
}
12
13
int main() {
14
folly::fibers::Fiber fiber(fiberFunction);
15
fiber.startAndWait();
16
return 0;
17
}
⑮ static FiberId currentFiberId()
⚝ 功能：获取当前正在执行的纤程的 ID。
⚝ 参数：无。
⚝ 返回值：FiberId 类型，表示当前正在执行的纤程的 ID。如果当前上下文中没有纤程在执行，则可能返回一个特殊值（例如 0 或无效 ID）。
⚝ 说明：
▮▮▮▮⚝ currentFiberId() 是一个静态成员函数，类似于 current()，但只返回纤程的 ID，而不是 Fiber 对象指针。
▮▮▮▮⚝ 比 current() 更轻量级，在只需要纤程 ID 的场景下更高效。
▮▮▮▮⚝ 同样只能在纤程上下文中安全调用。
⑯ static void yield()
⚝ 功能：主动让出当前纤程的执行权，允许其他纤程执行。
⚝ 参数：无。
⚝ 返回值：无。
⚝ 说明：
▮▮▮▮⚝ yield() 函数是实现协作式多任务处理的关键。
▮▮▮▮⚝ 当纤程调用 yield() 时，它会主动暂停执行，并将控制权交还给 FiberManager 调度器。
▮▮▮▮⚝ 调度器会选择下一个可以执行的纤程继续执行。
▮▮▮▮⚝ yield() 允许纤程在不需要长时间占用 CPU 时主动释放资源，提高系统的并发性能和响应性。
⚝ 示例：
1
#include <folly/fibers/Fiber.h>
2
#include <iostream>
3
4
void fiberFunction1() {
5
for (int i = 0; i < 5; ++i) {
6
std::cout << "Fiber 1: " << i << std::endl;
7
folly::fibers::Fiber::yield(); // 主动让出执行权
8
}
9
}
10
11
void fiberFunction2() {
12
for (int i = 0; i < 5; ++i) {
13
std::cout << "Fiber 2: " << i << std::endl;
14
folly::fibers::Fiber::yield(); // 主动让出执行权
15
}
16
}
17
18
int main() {
19
folly::fibers::Fiber fiber1(fiberFunction1);
20
folly::fibers::Fiber fiber2(fiberFunction2);
21
fiber1.start();
22
fiber2.start();
23
fiber1.join();
24
fiber2.join();
25
return 0;
26
}
⚝ 预期输出 (输出顺序可能略有不同，但会交替执行)：
1
Fiber 1: 0
2
Fiber 2: 0
3
Fiber 1: 1
4
Fiber 2: 1
5
Fiber 1: 2
6
Fiber 2: 2
7
Fiber 1: 3
8
Fiber 2: 3
9
Fiber 1: 4
10
Fiber 2: 4
⑰ static void waitFor(folly::fibers::TimedMutex& mutex)
⑱ static bool waitFor(folly::fibers::TimedMutex& mutex, std::chrono::steady_clock::time_point timeoutTime)
⑲ static void waitFor(folly::fibers::Semaphore& sema)
⑳ static bool waitFor(folly::fibers::Semaphore& sema, std::chrono::steady_clock::time_point timeoutTime)
㉑ static void waitFor(folly::fibers::Baton& baton)
㉒ static bool waitFor(folly::fibers::Baton& baton, std::chrono::steady_clock::time_point timeoutTime)
㉓ static void waitFor(folly::fibers::EventCount& ev)
㉔ static bool waitFor(folly::fibers::EventCount& ev, folly::fibers::EventCount::count_t cv)
㉕ static bool waitFor(folly::fibers::EventCount& ev, folly::fibers::EventCount::count_t cv, std::chrono::steady_clock::time_point timeoutTime)
㉖ static void waitFor(folly::fibers::AsyncEventCounter& aec)
㉗ static bool waitFor(folly::fibers::AsyncEventCounter& aec, folly::fibers::AsyncEventCounter::count_t cv)
㉘ static bool waitFor(folly::fibers::AsyncEventCounter& aec, folly::fibers::AsyncEventCounter::count_t cv, std::chrono::steady_clock::time_point timeoutTime)
⚝ 功能：一系列 waitFor 静态函数，用于在纤程中等待各种同步原语（Synchronization Primitives）变为可用状态。
⚝ 参数：
▮▮▮▮⚝ folly::fibers::TimedMutex& mutex: 互斥锁（Timed Mutex）。
▮▮▮▮⚝ std::chrono::steady_clock::time_point timeoutTime: 超时时间点。
▮▮▮▮⚝ folly::fibers::Semaphore& sema: 信号量（Semaphore）。
▮▮▮▮⚝ folly::fibers::Baton& baton: 接力棒（Baton）。
▮▮▮▮⚝ folly::fibers::EventCount& ev: 事件计数器（EventCount）。
▮▮▮▮⚝ folly::fibers::EventCount::count_t cv: 事件计数器的目标计数值。
▮▮▮▮⚝ folly::fibers::AsyncEventCounter& aec: 异步事件计数器 (AsyncEventCounter)。
▮▮▮▮⚝ folly::fibers::AsyncEventCounter::count_t cv: 异步事件计数器的目标计数值。
⚝ 返回值：
▮▮▮▮⚝ void 版本：无返回值，无限期等待，直到同步原语变为可用状态。
▮▮▮▮⚝ bool 版本：返回 bool 类型，true 表示在超时时间内同步原语变为可用状态，false 表示超时。
⚝ 说明：
▮▮▮▮⚝ 这些 waitFor 函数是纤程实现同步和协作的关键工具。
▮▮▮▮⚝ 当纤程调用 waitFor 时，如果同步原语当前不可用，纤程会主动让出执行权，进入等待状态。
▮▮▮▮⚝ 当同步原语变为可用状态时（例如互斥锁被释放、信号量可用、事件发生等），等待的纤程会被唤醒，重新加入调度队列，等待调度器调度执行。
▮▮▮▮⚝ 超时版本的 waitFor 允许纤程在等待一段时间后放弃等待，避免无限期阻塞。
▮▮▮▮⚝ 这些同步原语都是 Folly 库提供的，专门为纤程环境设计，能够与纤程调度器良好地协作。
⚝ 示例 (以 folly::fibers::Semaphore 为例)：
1
#include <folly/fibers/Fiber.h>
2
#include <folly/fibers/Semaphore.h>
3
#include <iostream>
4
#include <thread>
5
#include <chrono>
6
7
folly::fibers::Semaphore sema(0); // 初始信号量计数为 0
8
9
void fiberFunction() {
10
std::cout << "Fiber waiting for semaphore." << std::endl;
11
folly::fibers::Fiber::waitFor(sema); // 等待信号量
12
std::cout << "Fiber acquired semaphore and continues." << std::endl;
13
}
14
15
int main() {
16
folly::fibers::Fiber fiber(fiberFunction);
17
fiber.start();
18
std::this_thread::sleep_for(std::chrono::seconds(2));
19
std::cout << "Releasing semaphore." << std::endl;
20
sema.post(); // 释放信号量
21
fiber.join();
22
return 0;
23
}
7.1.2 保护成员函数 (Protected Member Functions)
Fiber 类的保护成员函数通常用于类内部实现和扩展，不直接暴露给用户使用。这些函数可能涉及到纤程的底层管理和状态控制。由于 Fiber 类的设计目标是提供稳定和易用的 API，因此保护成员函数通常不需要用户直接关注。
在 Fiber.h 中， 具体的保护成员函数可能包括（但不限于，具体实现可能有所不同，以下仅为示例）：
① virtual void run() = 0 (抽象方法)
⚝ 功能：纯虚函数，定义纤程的执行体。
⚝ 参数：无。
⚝ 返回值：无。
⚝ 说明：
▮▮▮▮⚝ 这是一个抽象方法，意味着 Fiber 类本身是一个抽象类，不能直接实例化。
▮▮▮▮⚝ 具体的 Fiber 子类需要实现 run() 方法，在 run() 方法中编写纤程要执行的代码逻辑。
▮▮▮▮⚝ 当纤程被调度执行时，调度器会调用 run() 方法。
▮▮▮▮⚝ 实际上，在 Folly Fiber 的实现中，用户提供的函数对象或 Lambda 表达式会被包装成一个内部的 run() 方法的实现。
② void setState(FiberState newState)
⚝ 功能：设置纤程的状态。
⚝ 参数：FiberState newState，新的纤程状态。
⚝ 返回值：无。
⚝ 说明：
▮▮▮▮⚝ 用于在 Fiber 类内部更新纤程的状态，例如从 "ready" 状态变为 "running" 状态，或从 "running" 状态变为 "finished" 状态。
▮▮▮▮⚝ FiberState 是一个枚举类型，定义了纤程的各种状态。
③ FiberState getState() const
⚝ 功能：获取纤程的当前状态。
⚝ 参数：无。
⚝ 返回值：FiberState 类型，表示纤程的当前状态。
⚝ 说明：
▮▮▮▮⚝ 用于在 Fiber 类内部查询纤程的当前状态。
④ void setContext(...) 和 void getContext(...)
⚝ 功能：设置和获取纤程的执行上下文（Context）。
⚝ 参数：上下文相关的数据结构或参数。
⚝ 返回值：上下文相关的数据或状态。
⚝ 说明：
▮▮▮▮⚝ 纤程的上下文包括寄存器状态、栈指针等，是纤程切换的关键信息。
▮▮▮▮⚝ 这些保护方法用于在纤程切换时保存和恢复上下文。
⑤ void allocateStack() 和 void deallocateStack()
⚝ 功能：分配和释放纤程的栈空间。
⚝ 参数：无。
⚝ 返回值：无。
⚝ 说明：
▮▮▮▮⚝ 纤程需要独立的栈空间来执行函数调用和存储局部变量。
▮▮▮▮⚝ 这些保护方法用于在创建纤程时分配栈空间，并在销毁纤程时释放栈空间。
⑥ // ... 其他可能的保护成员函数，例如用于错误处理、调试、性能监控等 ...
总结： Fiber 类的保护成员函数主要用于内部实现，用户通常不需要直接使用。理解这些保护成员函数有助于深入了解 Fiber 类的内部工作机制，但对于日常使用 Folly Fiber 库来说，公有成员函数已经提供了足够的功能。
7.1.3 静态成员函数 (Static Member Functions)
Fiber 类的静态成员函数提供了一些与纤程管理和控制相关的全局操作，这些函数不依赖于特定的 Fiber 对象实例。
在 7.1.1 公有成员函数中，我们已经详细介绍了以下静态成员函数：
⚝ static Fiber* current()
⚝ static FiberId currentFiberId()
⚝ static void yield()
⚝ static void waitFor(...) (一系列重载版本)
这些静态成员函数是 Fiber 类 API 的重要组成部分，提供了在纤程上下文中进行自我管理、协作和同步的关键能力。 它们允许纤程：
⚝ 获取自身信息 (current(), currentFiberId())： 方便纤程访问自身属性，例如 ID，用于日志记录或条件判断。
⚝ 主动让出执行权 (yield())： 实现协作式多任务处理，避免长时间占用 CPU，提高系统并发性。
⚝ 等待同步原语 (waitFor(...))： 实现纤程间的同步和协作，例如等待互斥锁、信号量、事件等，构建复杂的并发逻辑。
7.2 相关类型定义与枚举 (Related Type Definitions and Enumerations)
Fiber.h 头文件中除了 Fiber 类之外，还定义了一些相关的类型定义（typedef）和枚举（enum），这些类型和枚举用于支持 Fiber 类的功能和提供更清晰的 API 接口。
① using FiberId = uintptr_t;
⚝ 类型定义：FiberId
⚝ 基础类型：uintptr_t (无符号整型，大小足以存储指针)
⚝ 说明：
▮▮▮▮⚝ FiberId 是纤程 ID 的类型别名。
▮▮▮▮⚝ 使用 uintptr_t 作为基础类型，通常是因为纤程 ID 在内部实现中可能与内存地址或指针相关。
▮▮▮▮⚝ 用户可以使用 FiberId 类型来存储和传递纤程 ID。
② enum class FiberState { ... };
⚝ 枚举类型：FiberState
⚝ 枚举值 (示例，具体实现可能有所不同)：
▮▮▮▮⚝ INIT (初始状态，纤程已创建但未启动)
▮▮▮▮⚝ READY (就绪状态，纤程已准备好运行，等待调度器调度)
▮▮▮▮⚝ RUNNING (运行状态，纤程正在执行)
▮▮▮▮⚝ BLOCKED (阻塞状态，纤程正在等待某个事件或同步原语)
▮▮▮▮⚝ FINISHED (完成状态，纤程已执行完成)
▮▮▮▮⚝ CANCELLED (取消状态，纤程已被取消)
▮▮▮▮⚝ DETACHED (分离状态，纤程已分离，不再需要显式 join)
▮▮▮▮⚝ ERROR (错误状态，纤程执行过程中发生错误)
⚝ 说明：
▮▮▮▮⚝ FiberState 枚举定义了纤程的各种状态。
▮▮▮▮⚝ Fiber 类内部使用 FiberState 来跟踪和管理纤程的生命周期。
▮▮▮▮⚝ 用户可以通过 Fiber 类的相关方法（例如 getState()，虽然通常不直接公开，但可以通过调试或文档了解）来查询纤程的当前状态。
▮▮▮▮⚝ 了解纤程状态有助于理解纤程的执行过程和进行调试。
③ // ... 其他可能的类型定义和枚举，例如与 Fiber 上下文、调度策略、错误码等相关的类型 ...
总结： Fiber.h 中定义的类型定义和枚举，虽然数量不多，但都服务于 Fiber 类的核心功能。FiberId 用于唯一标识纤程，FiberState 用于表示纤程的生命周期状态。理解这些类型和枚举有助于更深入地理解 Folly Fiber 库的设计和使用。
END_OF_CHAPTER
8. chapter 8： Folly Fiber 实战案例 (Practical Case Studies of Folly Fibers)
8.1 基于 Fiber 实现的简单 RPC 框架 (A Simple RPC Framework Based on Fibers)
在现代分布式系统中，远程过程调用（Remote Procedure Call, RPC）框架扮演着至关重要的角色。它允许一个程序请求位于网络中另一台计算机上的程序执行服务，而无需显式了解网络通信的底层细节。传统的 RPC 框架通常依赖于线程或进程来处理并发请求，但这在高并发场景下可能会导致资源消耗过高和性能瓶颈。Folly Fiber 提供了一种轻量级的并发模型，非常适合构建高性能、低延迟的 RPC 框架。
RPC 框架的核心需求
一个典型的 RPC 框架需要处理以下关键任务：
① 请求接收与解析：监听网络端口，接收客户端的 RPC 请求，并解析请求参数。
② 服务查找与调用：根据请求的服务名和方法名，查找相应的服务实现，并调用目标方法。
③ 结果序列化与发送：将服务执行结果序列化成网络传输格式，并通过网络发送回客户端。
④ 并发处理：能够高效地处理大量并发的 RPC 请求，保证系统的吞吐量和响应速度。
Fiber 在 RPC 框架中的优势
使用 Fiber 构建 RPC 框架，可以充分利用 Fiber 的以下优势：
① 轻量级并发：Fiber 比线程更轻量级，创建和切换 Fiber 的开销远小于线程，这使得 RPC 服务能够轻松处理数以万计的并发连接。
② 高效的上下文切换：Fiber 的上下文切换由用户态代码控制，避免了内核态的系统调用开销，切换速度非常快，提高了并发处理效率。
③ 协作式多任务：Fiber 采用协作式多任务处理，避免了线程上下文切换中的锁竞争问题，简化了并发编程的复杂性。
④ 异步编程的简化：Fiber 天然适合异步编程模型，可以方便地实现非阻塞的 I/O 操作和异步服务调用，提高系统的响应能力。
基于 Fiber 的简单 RPC 框架示例
下面是一个简化的基于 Folly Fiber 的 RPC 框架示例，展示了如何使用 Fiber 处理 RPC 请求。为了突出 Fiber 的应用，我们简化了网络通信和序列化部分，重点关注请求处理流程。
1
#include <folly/fibers/FiberManager.h>
2
#include <folly/fibers/Fiber.h>
3
#include <iostream>
4
#include <string>
5
#include <functional>
6
7
using namespace folly::fibers;
8
9
// 假设的 RPC 服务接口
10
class RpcService {
11
public:
12
std::string echo(const std::string& message) {
13
// 模拟服务处理耗时
14
FiberManager::yield();
15
return "Server Echo: " + message;
16
}
17
};
18
19
int main() {
20
FiberManager fm;
21
RpcService service;
22
23
// 模拟接收 RPC 请求
24
auto requestHandler = [&](std::string request) {
25
fm.addTask([&, req = std::move(request)]() {
26
std::cout << "接收到请求: " << req << std::endl;
27
std::string response = service.echo(req);
28
std::cout << "发送响应: " << response << std::endl;
29
});
30
};
31
32
// 模拟多个并发请求
33
requestHandler("Hello Fiber RPC 1");
34
requestHandler("Hello Fiber RPC 2");
35
requestHandler("Hello Fiber RPC 3");
36
37
fm.join(); // 等待所有 Fiber 执行完成
38
return 0;
39
}
代码解释
① RpcService 类模拟了一个简单的 RPC 服务，其中 echo 方法是服务提供的接口。
② FiberManager fm; 创建了一个 Fiber 管理器，用于调度和管理 Fiber。
③ requestHandler lambda 函数模拟接收 RPC 请求的处理逻辑。每当接收到一个请求，就使用 fm.addTask 创建一个新的 Fiber 来处理该请求。
④ 在 Fiber 的任务函数中，调用 service.echo(req) 执行服务逻辑，并模拟服务处理耗时 FiberManager::yield()，然后打印请求和响应信息。
⑤ fm.join() 等待所有 Fiber 执行完成，确保程序正常退出。
关键要点
⚝ Fiber 的创建与调度：FiberManager::addTask 用于创建新的 Fiber 并将其加入调度队列。FiberManager 负责调度 Fiber 的执行。
⚝ 协作式让出：FiberManager::yield() 主动让出 Fiber 的执行权，允许其他 Fiber 运行。这体现了 Fiber 的协作式多任务特性。
⚝ 并发处理能力：通过创建多个 Fiber 并行处理请求，实现了简单的并发 RPC 服务。
总结
这个简单的示例展示了如何使用 Folly Fiber 构建一个基本的 RPC 框架。在实际应用中，还需要考虑网络通信、序列化、服务注册与发现、负载均衡、错误处理、监控等更复杂的功能。但 Fiber 提供的高效并发能力为构建高性能 RPC 框架奠定了坚实的基础。通过 Fiber，开发者可以更轻松地处理高并发的 RPC 请求，提升系统的吞吐量和响应速度。
8.2 使用 Fiber 构建高性能 HTTP 服务器 (Building a High-Performance HTTP Server Using Fibers)
HTTP 服务器是互联网基础设施的核心组件，需要处理大量的并发连接和请求。传统的多线程或多进程 HTTP 服务器在高并发场景下会面临性能瓶颈，例如线程上下文切换开销大、内存占用高等问题。Folly Fiber 提供了一种更高效的并发模型，可以用于构建高性能的 HTTP 服务器。
高性能 HTTP 服务器的挑战
构建高性能 HTTP 服务器需要解决以下关键挑战：
① 高并发连接处理：服务器需要能够同时处理大量的客户端连接，并保持低延迟和高吞吐量。
② 非阻塞 I/O：为了避免阻塞线程，服务器需要采用非阻塞 I/O 模型，例如 epoll (Linux) 或 kqueue (macOS, FreeBSD)。
③ 高效的请求处理：请求处理逻辑需要快速高效，避免长时间阻塞，影响其他请求的处理。
④ 资源管理：服务器需要有效地管理系统资源，例如内存、CPU、文件描述符等，防止资源耗尽。
Fiber 在 HTTP 服务器中的优势
Folly Fiber 在构建高性能 HTTP 服务器方面具有显著优势：
① 轻量级并发：Fiber 比线程更轻量级，可以创建大量的 Fiber 来处理并发连接，而不会造成过多的资源开销。
② 高效的上下文切换：Fiber 的上下文切换速度非常快，远低于线程切换，这在高并发场景下可以显著提高性能。
③ 简化异步编程：Fiber 使得异步编程更加直观和易于管理。可以使用同步风格的代码编写异步逻辑，降低了异步编程的复杂性。
④ 更好的资源利用率：Fiber 可以更有效地利用 CPU 和内存资源，提高服务器的整体性能和吞吐量。
基于 Fiber 的 HTTP 服务器架构
一个基于 Fiber 的高性能 HTTP 服务器的典型架构可能包括以下组件：
① 监听器 (Listener)：负责监听指定的端口，接受新的客户端连接。通常使用非阻塞 socket 和 epoll/kqueue 等 I/O 多路复用机制。
② 连接管理器 (Connection Manager)：管理客户端连接，为每个连接创建一个 Fiber 来处理请求。
③ 请求解析器 (Request Parser)：解析 HTTP 请求报文，提取请求方法、URL、头部、Body 等信息。
④ 路由 (Router)：根据请求 URL 将请求路由到相应的请求处理器。
⑤ 请求处理器 (Request Handler)：处理具体的业务逻辑，生成 HTTP 响应。
⑥ 响应构建器 (Response Builder)：构建 HTTP 响应报文，包括状态码、头部、Body 等。
⑦ 响应发送器 (Response Sender)：将 HTTP 响应发送回客户端。
Fiber 在 HTTP 请求处理流程中的应用
在基于 Fiber 的 HTTP 服务器中，每个客户端连接通常会分配一个 Fiber 来处理该连接上的所有请求。请求处理流程可能如下：
- 连接建立：监听器接受新的客户端连接。
- Fiber 创建：连接管理器为该连接创建一个 Fiber。
- 请求接收：Fiber 负责从 socket 接收 HTTP 请求数据（非阻塞 I/O）。
- 请求解析：Fiber 解析接收到的 HTTP 请求。
- 路由：Fiber 根据请求 URL 将请求路由到相应的请求处理器。
- 请求处理：Fiber 执行请求处理器中的业务逻辑。这部分逻辑可以是同步的，也可以是异步的（例如，访问数据库、调用其他服务）。如果需要执行异步操作，可以在 Fiber 中发起异步调用，并使用
FiberManager::yield()让出执行权，等待异步操作完成。 - 响应构建：Fiber 构建 HTTP 响应。
- 响应发送：Fiber 将 HTTP 响应发送回客户端（非阻塞 I/O）。
- 连接关闭或保持：根据 HTTP 协议和服务器策略，决定是否关闭连接或保持连接等待下一个请求。
简化代码示例 (伪代码)
1
// 监听 socket，接受连接
2
while (true) {
3
Socket clientSocket = listener.accept();
4
fiberManager.addTask([clientSocket]() { // 为每个连接创建 Fiber
5
while (true) {
6
HttpRequest request = receiveHttpRequest(clientSocket); // 非阻塞接收请求
7
if (request.isValid()) {
8
HttpResponse response = handleHttpRequest(request); // 处理请求
9
sendHttpResponse(clientSocket, response); // 非阻塞发送响应
10
} else {
11
break; // 连接关闭或错误
12
}
13
}
14
closeSocket(clientSocket);
15
});
16
}
17
18
HttpResponse handleHttpRequest(const HttpRequest& request) {
19
// ... 请求解析和路由 ...
20
if (request.path == "/api/data") {
21
return processDataRequest(request); // 处理数据请求
22
} else if (request.path == "/static/file.html") {
23
return serveStaticFile(request); // 提供静态文件服务
24
} else {
25
return createNotFoundResponse(); // 404 Not Found
26
}
27
}
28
29
HttpResponse processDataRequest(const HttpRequest& request) {
30
// ... 业务逻辑 ...
31
DatabaseResult result = queryDatabase(request.query); // 异步数据库查询 (假设)
32
// FiberManager::yield(); // 如果 queryDatabase 是异步的，需要 yield 等待
33
JsonData jsonData = formatResultToJson(result);
34
return createJsonResponse(jsonData);
35
}
关键要点
⚝ 每个连接一个 Fiber：为每个客户端连接创建一个 Fiber，隔离了连接之间的状态，简化了并发处理逻辑。
⚝ 非阻塞 I/O：HTTP 服务器的核心是高效的 I/O 处理。Fiber 可以很好地与非阻塞 I/O 结合使用，提高并发性能。
⚝ 异步操作处理：在 Fiber 中可以方便地发起异步操作（例如数据库查询、外部服务调用），并通过 FiberManager::yield() 让出执行权，避免阻塞 Fiber，提高整体吞吐量。
总结
使用 Folly Fiber 构建 HTTP 服务器可以显著提高服务器的并发处理能力和性能。Fiber 的轻量级、高效上下文切换和对异步编程的良好支持，使得开发者能够构建出高性能、低延迟的 HTTP 服务。在实际应用中，还需要考虑连接池管理、Keep-Alive 连接处理、HTTPS 支持、负载均衡、安全等方面的问题，但 Fiber 提供了一种强大的并发模型，为构建现代高性能 HTTP 服务器提供了有力的工具。
8.3 Fiber 在流式数据处理中的应用 (Application of Fibers in Streaming Data Processing)
流式数据处理（Streaming Data Processing）是一种实时处理连续数据流的技术，广泛应用于实时监控、金融交易、日志分析、物联网等领域。流式数据处理系统需要具备低延迟、高吞吐量和可扩展性等特点。Folly Fiber 由于其轻量级和高效的并发特性，非常适合用于构建流式数据处理管道。
流式数据处理的特点与挑战
流式数据处理与传统的批处理（Batch Processing）不同，它具有以下特点：
① 数据连续性：数据以连续不断的数据流形式到达，而不是静态的数据集。
② 实时性要求：需要实时或近实时地处理数据，并快速产生结果。
③ 高吞吐量：系统需要能够处理高速率的数据流，保证数据的及时处理。
④ 低延迟：从数据产生到处理完成的时间延迟要尽可能低。
⑤ 无状态或弱状态：为了保证性能和可扩展性，流式处理通常倾向于无状态或弱状态的处理方式。
流式数据处理系统面临的主要挑战包括：
① 并发处理：需要高效地处理多个数据流或数据流中的多个数据单元，以满足高吞吐量和低延迟的要求。
② 背压 (Backpressure)：当数据产生速度超过处理速度时，需要有效地进行背压控制，防止系统过载。
③ 容错性：流式处理系统需要具备一定的容错能力，保证在部分组件故障时，系统仍能正常运行。
④ 状态管理：对于有状态的流式处理，需要有效地管理和维护状态信息。
Fiber 在流式数据处理中的优势
Folly Fiber 在流式数据处理中具有以下优势：
① 轻量级并发：Fiber 可以创建大量的并发执行单元，用于处理数据流中的各个数据单元或不同的数据流。
② 高效的上下文切换：Fiber 的快速上下文切换使得在多个数据处理任务之间快速切换成为可能，提高了系统的并发处理能力。
③ 协作式管道：可以使用 Fiber 构建协作式的流式处理管道，将数据处理流程分解为多个 Fiber 协同完成。
④ 简化异步 I/O：流式数据通常涉及大量的 I/O 操作，Fiber 可以简化异步 I/O 编程，提高 I/O 效率。
基于 Fiber 的流式数据处理管道
可以使用 Fiber 构建一个流式数据处理管道，将数据处理流程分解为多个阶段，每个阶段由一个或多个 Fiber 负责处理。一个典型的流式数据处理管道可能包括以下阶段：
① 数据源 (Data Source)：负责从外部数据源（例如，消息队列、网络 socket、文件）读取数据流。
② 数据解析 (Data Parser)：解析原始数据，将其转换为结构化数据格式。
③ 数据转换 (Data Transformer)：对数据进行转换、过滤、清洗等操作。
④ 数据聚合 (Data Aggregator)：对数据进行聚合、分组、窗口化等操作。
⑤ 数据Sink (Data Sink)：将处理后的数据输出到外部系统（例如，数据库、消息队列、存储系统）。
Fiber 在流式处理管道中的应用
在基于 Fiber 的流式处理管道中，每个阶段可以由一个或多个 Fiber 组成。数据在管道中流动，从一个 Fiber 传递到下一个 Fiber。可以使用 Channel 或 Queue 等数据结构在 Fiber 之间传递数据。
简化代码示例 (伪代码)
1
#include <folly/fibers/FiberManager.h>
2
#include <folly/fibers/Fiber.h>
3
#include <folly/ConcurrentQueue.h>
4
#include <iostream>
5
#include <string>
6
7
using namespace folly::fibers;
8
using namespace folly;
9
10
ConcurrentQueue<std::string> rawDataQueue; // 原始数据队列
11
ConcurrentQueue<JsonData> parsedDataQueue; // 解析后的数据队列
12
ConcurrentQueue<AggregatedData> aggregatedDataQueue; // 聚合后的数据队列
13
14
// 数据源 Fiber
15
void dataSourceFiber() {
16
while (true) {
17
std::string rawData = readDataFromSource(); // 从数据源读取数据 (假设)
18
if (rawData.empty()) break; // 数据源结束
19
rawDataQueue.enqueue(rawData);
20
FiberManager::yield(); // 让出执行权
21
}
22
}
23
24
// 数据解析 Fiber
25
void dataParserFiber() {
26
while (true) {
27
std::string rawData;
28
rawDataQueue.dequeue(rawData);
29
JsonData parsedData = parseData(rawData); // 解析数据 (假设)
30
parsedDataQueue.enqueue(parsedData);
31
FiberManager::yield();
32
}
33
}
34
35
// 数据聚合 Fiber
36
void dataAggregatorFiber() {
37
while (true) {
38
JsonData parsedData;
39
parsedDataQueue.dequeue(parsedData);
40
AggregatedData aggregatedData = aggregateData(parsedData); // 聚合数据 (假设)
41
aggregatedDataQueue.enqueue(aggregatedData);
42
FiberManager::yield();
43
}
44
}
45
46
// 数据 Sink Fiber
47
void dataSinkFiber() {
48
while (true) {
49
AggregatedData aggregatedData;
50
aggregatedDataQueue.dequeue(aggregatedData);
51
writeDataToSink(aggregatedData); // 将数据写入 Sink (假设)
52
FiberManager::yield();
53
}
54
}
55
56
int main() {
57
FiberManager fm;
58
59
fm.addTask(dataSourceFiber);
60
fm.addTask(dataParserFiber);
61
fm.addTask(dataAggregatorFiber);
62
fm.addTask(dataSinkFiber);
63
64
fm.join(); // 等待所有 Fiber 执行完成
65
return 0;
66
}
代码解释
① 使用 folly::ConcurrentQueue 创建了三个队列，用于在不同阶段的 Fiber 之间传递数据。
② dataSourceFiber 模拟数据源，不断从数据源读取数据并放入 rawDataQueue。
③ dataParserFiber 从 rawDataQueue 取出原始数据，解析成 JsonData 格式，并放入 parsedDataQueue。
④ dataAggregatorFiber 从 parsedDataQueue 取出解析后的数据，进行聚合操作，并将聚合结果放入 aggregatedDataQueue。
⑤ dataSinkFiber 从 aggregatedDataQueue 取出聚合后的数据，并写入数据 Sink。
⑥ 每个 Fiber 在处理完一个数据单元后，都调用 FiberManager::yield() 让出执行权，允许其他 Fiber 运行，实现了协作式的流式处理管道。
关键要点
⚝ Fiber 管道：使用多个 Fiber 协同工作，构建流式数据处理管道，每个 Fiber 负责管道中的一个阶段。
⚝ 并发队列：使用并发队列在 Fiber 之间传递数据，实现数据在管道中的流动。
⚝ 协作式处理：Fiber 之间通过协作式调度，共同完成流式数据处理任务。
总结
Folly Fiber 非常适合用于构建流式数据处理系统。Fiber 的轻量级并发、高效上下文切换和协作式多任务处理特性，使得开发者能够构建出高性能、低延迟、高吞吐量的流式数据处理管道。在实际应用中，还需要考虑错误处理、背压控制、状态管理、窗口处理、容错性等方面的问题，但 Fiber 提供了一种强大的并发模型，为构建现代流式数据处理系统提供了有力的支持。
END_OF_CHAPTER
9. chapter 9： Folly Fiber 最佳实践与常见问题 (Best Practices and Common Issues of Folly Fibers)
9.1 Fiber 编程的最佳实践 (Best Practices for Fiber Programming)
使用 Folly Fiber 进行编程能够带来诸多优势，尤其是在构建高性能并发应用时。然而，为了充分发挥 Fiber 的潜力并避免潜在的陷阱，遵循一些最佳实践至关重要。本节将深入探讨 Fiber 编程中的关键最佳实践，帮助开发者编写更高效、更可靠、更易于维护的 Fiber 应用。
① 理解协作式多任务处理 (Understanding Cooperative Multitasking)
Fiber 的核心是协作式多任务处理 (Cooperative Multitasking)。与抢占式多任务处理的线程不同，Fiber 的切换完全依赖于 Fiber 主动放弃 CPU 执行权。这意味着，如果一个 Fiber 长时间占用 CPU 而不进行 yield 操作，将会导致其他 Fiber 无法得到执行，从而影响整个程序的并发性能甚至造成程序假死。
最佳实践：
⚝ 避免长时间的 CPU 密集型操作： 在 Fiber 中执行 CPU 密集型任务时，务必考虑任务的执行时间。如果任务执行时间过长，应该将其分解为更小的任务，并在任务执行过程中适时地调用 fiber::yield() 让出 CPU，给其他 Fiber 执行的机会。
⚝ 充分利用非阻塞 I/O： Fiber 非常适合与非阻塞 I/O (Non-blocking I/O) 结合使用。当 Fiber 执行 I/O 操作时，应该使用非阻塞的 API，并在 I/O 操作未完成时立即 yield。当 I/O 操作完成时，Fiber 可以被调度器唤醒并继续执行。这样可以最大程度地提高 CPU 的利用率，避免 Fiber 在等待 I/O 时阻塞线程。
⚝ 显式地 yield： 在可能长时间运行的操作（例如循环、计算密集型函数）中，显式地插入 fiber::yield() 调用，确保其他 Fiber 能够及时获得执行机会，维持系统的响应性。
② 合理使用 FiberManager (Proper Use of FiberManager)
FiberManager 是 Folly Fiber 的核心组件，负责 Fiber 的创建、调度和管理。合理地使用 FiberManager 是构建高效 Fiber 应用的关键。
最佳实践：
⚝ 单例模式 (Singleton Pattern) 或全局访问： 通常情况下，一个应用程序只需要一个 FiberManager 实例。可以考虑使用单例模式 (Singleton Pattern) 或者将其作为全局变量进行管理，方便在程序的任何地方创建和调度 Fiber。
⚝ 根据需求配置调度器： FiberManager 允许自定义调度器 (Scheduler)。Folly 提供了多种内置调度器，例如 getDefaultCPUExecutor() 和 getIOExecutor()。根据应用程序的特性（CPU 密集型、I/O 密集型）选择合适的调度器，或者自定义调度策略，可以优化 Fiber 的调度效率。
⚝ 控制 Fiber 的数量： 虽然 Fiber 的创建开销相对线程较小，但过多的 Fiber 仍然会消耗资源，并可能导致调度开销增加。应该根据应用程序的实际并发需求，合理控制 Fiber 的数量，避免创建过多的 Fiber。
⚝ 优雅地关闭 FiberManager： 在程序退出时，需要确保 FiberManager 能够被正确地关闭，释放其占用的资源。可以使用 FiberManager::stop() 方法来停止调度器，并等待所有 Fiber 执行完成。
③ 细致的错误处理 (Careful Error Handling)
错误处理在任何程序中都至关重要，在 Fiber 编程中也不例外。由于 Fiber 运行在同一个线程中，一个 Fiber 中未处理的异常可能会影响到其他 Fiber 甚至整个程序。
最佳实践：
⚝ 使用 try-catch 块： 在 Fiber 的入口函数处，使用 try-catch 块捕获可能抛出的异常。这样可以防止异常扩散到 FiberManager，导致程序崩溃。
⚝ Fiber 局部存储 (Fiber-Local Storage) 错误上下文： 可以使用 Fiber 局部存储 (Fiber-Local Storage) 来记录 Fiber 执行过程中的错误信息和上下文。当发生异常时，可以从 Fiber 局部存储中获取详细的错误信息，方便调试和诊断。
⚝ 异常传播策略： 根据应用程序的需求，设计合适的异常传播策略。可以选择将异常传递给调用者 Fiber，或者记录错误日志并继续执行其他 Fiber。
⚝ 资源清理： 即使在发生异常的情况下，也要确保 Fiber 能够正确地清理资源，例如释放内存、关闭文件句柄等。可以使用 RAII (Resource Acquisition Is Initialization) 技术来自动管理资源。
④ 有效的资源管理 (Effective Resource Management)
Fiber 的轻量级特性并不意味着可以忽略资源管理。不当的资源管理仍然可能导致内存泄漏、资源耗尽等问题。
最佳实践：
⚝ 控制 Fiber 栈大小： Fiber 的栈大小可以在创建时指定。默认栈大小可能对于某些复杂的 Fiber 函数来说不足够，而过大的栈大小则会浪费内存。应该根据 Fiber 函数的实际需求，合理设置栈大小。可以使用 Fiber::Builder::stackSize() 方法来指定栈大小。
⚝ Fiber 池化 (Fiber Pooling)： 对于频繁创建和销毁的 Fiber，可以考虑使用 Fiber 池化 (Fiber Pooling) 技术。预先创建一批 Fiber 放入池中，当需要执行任务时，从池中获取一个 Fiber，任务执行完成后将 Fiber 返回池中。这样可以减少 Fiber 创建和销毁的开销，提高性能。
⚝ 避免资源竞争： 多个 Fiber 可能会共享相同的资源（例如文件、网络连接、内存）。需要使用适当的同步机制 (Synchronization Mechanisms)（例如互斥锁、信号量）来保护共享资源，避免竞争条件 (Race Condition) 和数据不一致性。
⑤ 清晰的代码和可维护性 (Clear Code and Maintainability)
Fiber 编程可能会引入额外的复杂性，尤其是在处理并发和异步逻辑时。保持代码的清晰和可维护性至关重要。
最佳实践：
⚝ 保持 Fiber 函数简短： 尽量将 Fiber 函数设计得简洁明了，避免过于复杂的逻辑。如果 Fiber 函数过于庞大，应该将其分解为更小的、更易于理解的子函数。
⚝ 避免深层嵌套： 过深的 Fiber 调用嵌套会降低代码的可读性和可维护性。应该尽量扁平化 Fiber 的调用结构，使用合适的异步编程模式来组织代码。
⚝ 使用有意义的命名： 为 Fiber 函数、变量和类选择具有描述性的名称，提高代码的可读性。
⚝ 充分的注释： 对于复杂的 Fiber 逻辑，添加清晰的注释，解释代码的功能和意图。
⚝ 单元测试： 编写充分的单元测试 (Unit Test) 来验证 Fiber 代码的正确性。可以使用 Folly 提供的测试框架来测试 Fiber 的行为。
遵循这些最佳实践，可以帮助开发者更好地利用 Folly Fiber 构建高性能、可靠且易于维护的并发应用程序。
9.2 常见 Fiber 编程错误与避免 (Common Fiber Programming Errors and Avoidance)
尽管 Fiber 提供了强大的并发能力，但在实际编程中，开发者可能会遇到一些常见的错误。理解这些错误并学会避免它们，对于编写健壮的 Fiber 应用至关重要。本节将介绍 Fiber 编程中常见的错误，并提供相应的避免方法。
① 阻塞操作导致 Fiber 饥饿 (Blocking Operations Leading to Fiber Starvation)
错误描述： 在 Fiber 中执行了阻塞操作 (Blocking Operation)，例如同步 I/O、sleep() 等。由于 Fiber 是协作式调度的，阻塞操作会使得当前 Fiber 长时间占用线程，而不主动 yield，导致其他 Fiber 无法得到执行，造成 Fiber 饥饿 (Fiber Starvation)。
避免方法：
⚝ 使用非阻塞 I/O： 始终优先使用非阻塞 I/O (Non-blocking I/O) API。例如，使用 folly::Socket 的非阻塞方法进行网络操作。
⚝ 避免同步等待： 避免在 Fiber 中使用 std::mutex::lock()、std::condition_variable::wait() 等同步等待操作。如果需要同步，应该使用 Fiber 提供的同步原语，例如 folly::fibers::Baton、folly::fibers::Latch 等，或者使用基于 Fiber 的异步同步机制。
⚝ 分解 CPU 密集型任务： 对于 CPU 密集型任务，将其分解为更小的单元，并在每个单元执行完毕后调用 fiber::yield()，让出 CPU。
⚝ 超时机制： 对于可能耗时较长的操作，设置超时机制 (Timeout Mechanism)。如果操作在指定时间内未完成，则主动 yield 或取消操作，避免长时间阻塞。
示例 (错误代码 - 阻塞操作):
1
#include <iostream>
2
#include <thread>
3
#include <chrono>
4
#include <folly/fibers/FiberManager.h>
5
#include <folly/fibers/Fiber.h>
6
7
using namespace folly::fibers;
8
9
void blocking_fiber_func() {
10
std::cout << "Blocking Fiber started" << std::endl;
11
std::this_thread::sleep_for(std::chrono::seconds(5)); // 阻塞操作
12
std::cout << "Blocking Fiber finished" << std::endl;
13
}
14
15
void non_blocking_fiber_func() {
16
std::cout << "Non-blocking Fiber started" << std::endl;
17
for (int i = 0; i < 5; ++i) {
18
std::cout << "Non-blocking Fiber yielding: " << i << std::endl;
19
fiber::yield(); // 主动 yield
20
}
21
std::cout << "Non-blocking Fiber finished" << std::endl;
22
}
23
24
int main() {
25
FiberManager fm;
26
fm.start();
27
28
fm.add([&]() { blocking_fiber_func(); });
29
fm.add([&]() { non_blocking_fiber_func(); });
30
31
fm.join();
32
fm.stop();
33
return 0;
34
}
分析： 在上述代码中，blocking_fiber_func 使用 std::this_thread::sleep_for() 进行阻塞等待，这将导致 non_blocking_fiber_func 延迟执行，甚至可能出现饥饿现象。正确的做法是避免在 Fiber 中使用阻塞操作，或者使用非阻塞的替代方案。
② 栈溢出 (Stack Overflow)
错误描述： Fiber 的栈空间是有限的。如果 Fiber 函数调用过深（例如递归调用层级过高）或者局部变量占用过多栈空间，就可能导致 栈溢出 (Stack Overflow)，程序崩溃。
避免方法：
⚝ 限制递归深度： 避免在 Fiber 中进行过深的递归调用。如果必须使用递归，要确保递归深度在可控范围内。
⚝ 减少栈上局部变量： 尽量减少 Fiber 函数中栈上局部变量的使用。可以将大型数据结构分配在堆上，或者使用 Fiber 局部存储。
⚝ 增大 Fiber 栈大小： 如果 Fiber 函数确实需要较大的栈空间，可以在创建 Fiber 时使用 Fiber::Builder::stackSize() 方法增大栈大小。但要注意，过大的栈大小会浪费内存。
⚝ 尾递归优化： 对于某些递归函数，可以尝试进行尾递归优化 (Tail Recursion Optimization)，减少栈帧的积累。
示例 (错误代码 - 栈溢出):
1
#include <iostream>
2
#include <folly/fibers/FiberManager.h>
3
#include <folly/fibers/Fiber.h>
4
5
using namespace folly::fibers;
6
7
void recursive_fiber_func(int depth) {
8
if (depth > 10000) { // 深度过大可能导致栈溢出
9
std::cout << "Stack overflow likely!" << std::endl;
10
return;
11
}
12
char buffer[1024]; // 栈上分配较大 buffer
13
std::cout << "Recursive call depth: " << depth << std::endl;
14
recursive_fiber_func(depth + 1);
15
}
16
17
int main() {
18
FiberManager fm;
19
fm.start();
20
21
fm.add([&]() { recursive_fiber_func(1); });
22
23
fm.join();
24
fm.stop();
25
return 0;
26
}
分析： 上述代码中，recursive_fiber_func 进行深度递归调用，并且在栈上分配了较大的 buffer，容易导致栈溢出。避免栈溢出的方法包括限制递归深度、减少栈上局部变量、增大栈大小等。
③ 死锁和竞争条件 (Deadlocks and Race Conditions)
错误描述： 在多 Fiber 并发环境中，如果不正确地使用同步机制，可能会导致 死锁 (Deadlock) 或 竞争条件 (Race Condition)。死锁是指两个或多个 Fiber 互相等待对方释放资源而无限期地阻塞。竞争条件是指多个 Fiber 访问共享资源时，由于执行顺序的不确定性，导致程序出现意外的结果。
避免方法：
⚝ 避免循环依赖： 在申请锁或其他资源时，避免形成循环依赖关系，这是导致死锁的常见原因。
⚝ 锁的粒度控制： 尽量减小锁的粒度，只在必要时才加锁，并尽快释放锁。避免长时间持有锁，减少死锁的风险。
⚝ 使用非阻塞同步原语： 考虑使用非阻塞的同步原语，例如原子操作、无锁数据结构，来减少锁的使用。
⚝ 仔细设计同步逻辑： 在设计并发逻辑时，仔细分析共享资源的访问模式，确保同步机制能够正确地保护共享资源，避免竞争条件。
⚝ 死锁检测和预防： 可以使用死锁检测工具来检测程序中是否存在死锁。在设计程序时，可以采用一些死锁预防策略，例如资源排序、超时机制等。
示例 (错误代码 - 死锁):
1
#include <iostream>
2
#include <mutex>
3
#include <folly/fibers/FiberManager.h>
4
#include <folly/fibers/Fiber.h>
5
6
using namespace folly::fibers;
7
8
std::mutex mutex1;
9
std::mutex mutex2;
10
11
void fiber_func1() {
12
std::cout << "Fiber 1 trying to lock mutex1" << std::endl;
13
std::lock_guard<std::mutex> lock1(mutex1);
14
std::cout << "Fiber 1 locked mutex1" << std::endl;
15
fiber::yield(); // 模拟 Fiber 切换
16
std::cout << "Fiber 1 trying to lock mutex2" << std::endl;
17
std::lock_guard<std::mutex> lock2(mutex2); // 可能发生死锁
18
std::cout << "Fiber 1 locked mutex2" << std::endl;
19
}
20
21
void fiber_func2() {
22
std::cout << "Fiber 2 trying to lock mutex2" << std::endl;
23
std::lock_guard<std::mutex> lock2(mutex2);
24
std::cout << "Fiber 2 locked mutex2" << std::endl;
25
fiber::yield(); // 模拟 Fiber 切换
26
std::cout << "Fiber 2 trying to lock mutex1" << std::endl;
27
std::lock_guard<std::mutex> lock1(mutex1); // 可能发生死锁
28
std::cout << "Fiber 2 locked mutex1" << std::endl;
29
}
30
31
int main() {
32
FiberManager fm;
33
fm.start();
34
35
fm.add([&]() { fiber_func1(); });
36
fm.add([&]() { fiber_func2(); });
37
38
fm.join(); // 程序可能在此处hang住，因为死锁
39
fm.stop();
40
return 0;
41
}
分析： 上述代码中，fiber_func1 先锁定 mutex1，然后尝试锁定 mutex2；fiber_func2 先锁定 mutex2，然后尝试锁定 mutex1。由于 Fiber 切换，可能出现 fiber_func1 持有 mutex1，fiber_func2 持有 mutex2，然后两者互相等待对方释放锁，从而导致死锁。避免死锁的关键在于打破循环等待条件，例如保证锁的获取顺序一致。
④ 不当使用 Fiber 局部存储 (Improper Use of Fiber-Local Storage)
错误描述： Fiber 局部存储 (Fiber-Local Storage) 提供了 Fiber 级别的线程局部存储，但如果使用不当，可能会导致内存泄漏、数据访问错误等问题。
避免方法：
⚝ 谨慎使用全局 Fiber 局部存储： 全局 Fiber 局部存储的生命周期与 FiberManager 相同，如果存储的对象没有被及时清理，可能会导致内存泄漏。
⚝ 避免在 Fiber 局部存储中存储大型对象： Fiber 局部存储的分配和访问可能会有一定开销，避免在其中存储大型对象，影响性能。
⚝ 理解 Fiber 局部存储的生命周期： 清楚 Fiber 局部存储的生命周期，确保在 Fiber 结束时，存储的对象能够被正确地清理。可以使用 RAII 技术来管理 Fiber 局部存储中的对象。
⚝ 避免跨 Fiber 共享 Fiber 局部存储数据： Fiber 局部存储的设计目的是为 Fiber 提供独立的存储空间，避免在不同的 Fiber 之间直接共享 Fiber 局部存储的数据，可能导致数据竞争和错误。
⑤ 异常处理不当 (Improper Exception Handling)
错误描述： Fiber 中未处理的异常可能会导致 Fiber 提前终止，甚至影响到其他 Fiber 或整个程序。
避免方法：
⚝ 在 Fiber 入口函数处捕获异常： 在 Fiber 的入口函数处，使用 try-catch 块捕获可能抛出的异常，防止异常扩散到 FiberManager。
⚝ 记录错误日志： 当 Fiber 中发生异常时，应该记录详细的错误日志，包括异常类型、错误信息、Fiber 上下文等，方便后续的调试和诊断。
⚝ 优雅地处理异常： 根据应用程序的需求，设计合适的异常处理策略。可以选择终止 Fiber 并通知调用者，或者忽略异常并继续执行其他 Fiber。
⚝ 资源清理： 即使在发生异常的情况下，也要确保 Fiber 能够正确地清理资源，例如释放内存、关闭文件句柄等。
⑥ 调试困难 (Debugging Challenges)
错误描述： Fiber 的执行流程相对复杂，上下文切换频繁，使得 Fiber 程序的调试比传统的线程程序更具挑战性。
应对方法：
⚝ 使用 Fiber 感知的调试器： 一些调试器（例如 gdb 的某些插件）提供了 Fiber 感知的调试功能，可以方便地查看 Fiber 的状态、栈信息等。
⚝ 日志记录： 在 Fiber 代码中添加详细的日志记录，输出 Fiber 的执行流程、关键变量的值等，帮助理解 Fiber 的行为。
⚝ 单元测试： 编写充分的单元测试来验证 Fiber 代码的正确性。可以使用 Folly 提供的测试框架进行 Fiber 单元测试。
⚝ 性能分析工具： 使用性能分析工具（例如 perf、FlameGraph）来分析 Fiber 程序的性能瓶颈，帮助定位问题。
⚝ 逐步调试： 使用调试器逐步执行 Fiber 代码，观察 Fiber 的执行流程和状态变化。
理解并避免这些常见的 Fiber 编程错误，可以显著提高 Fiber 程序的健壮性和可靠性，减少调试和维护的成本。
9.3 Fiber 性能调优技巧 (Fiber Performance Tuning Techniques)
Folly Fiber 旨在提供高性能的并发编程能力。然而，要充分发挥 Fiber 的性能潜力，还需要进行适当的性能调优。本节将介绍一些 Fiber 性能调优的技巧，帮助开发者构建更高效的 Fiber 应用。
① 性能剖析与分析 (Performance Profiling and Analysis)
性能调优的第一步是进行性能剖析 (Performance Profiling) 和分析，找出程序的性能瓶颈。
调优技巧：
⚝ 使用性能分析工具： 使用性能分析工具，例如 perf、FlameGraph、gprof 等，对 Fiber 程序进行性能剖析。这些工具可以帮助识别 CPU 占用率高的函数、热点代码路径、内存分配情况等，从而定位性能瓶颈。
⚝ 关注 Fiber 调度开销： 使用性能分析工具，关注 Fiber 调度相关的函数调用，例如 FiberManager::schedule()、Fiber::yield() 等。过高的调度开销可能表明 Fiber 调度策略不合理，或者 Fiber 数量过多。
⚝ 分析上下文切换开销： 虽然 Fiber 的上下文切换开销比线程小，但频繁的上下文切换仍然会影响性能。分析上下文切换的频率和开销，考虑减少不必要的上下文切换。
⚝ 内存分配分析： 使用内存分析工具，例如 valgrind --tool=massif，分析 Fiber 程序的内存分配情况。过多的内存分配和释放操作会影响性能。
② Fiber 调度策略优化 (Fiber Scheduling Policy Optimization)
FiberManager 的调度器 (Scheduler) 负责 Fiber 的调度执行。选择合适的调度器或者自定义调度策略，可以显著影响 Fiber 程序的性能。
调优技巧：
⚝ 选择合适的内置调度器： Folly 提供了多种内置调度器，例如 getDefaultCPUExecutor()、getIOExecutor()、getSameThreadExecutor() 等。根据应用程序的特性（CPU 密集型、I/O 密集型、延迟敏感型）选择合适的调度器。
⚝ 自定义调度策略： 如果内置调度器不能满足需求，可以自定义调度策略。例如，可以实现一个优先级调度器 (Priority Scheduler)，根据 Fiber 的优先级进行调度；或者实现一个公平调度器 (Fair Scheduler)，保证每个 Fiber 都能获得公平的执行机会。
⚝ 调整调度器参数： 某些调度器允许调整参数，例如线程池大小、调度队列长度等。根据应用程序的负载情况，调整这些参数，优化调度器的性能。
⚝ 避免调度器饥饿： 确保调度器有足够的线程来执行 Fiber。如果调度器线程池过小，可能会导致 Fiber 调度延迟，影响性能。
③ 栈大小优化 (Stack Size Optimization)
Fiber 的栈大小 (Stack Size) 会影响内存占用和上下文切换开销。合理地设置栈大小可以优化 Fiber 程序的性能。
调优技巧：
⚝ 减小栈大小： 如果 Fiber 函数的栈空间需求较小，可以减小 Fiber 的栈大小，减少内存占用。可以使用 Fiber::Builder::stackSize() 方法设置栈大小。
⚝ 动态栈增长： 某些 Fiber 实现支持动态栈增长 (Dynamic Stack Growth)。如果 Fiber 的栈空间需求不确定，可以考虑使用动态栈增长，避免预先分配过大的栈空间。
⚝ 栈预分配： 对于频繁创建和销毁的 Fiber，可以考虑栈预分配 (Stack Pre-allocation) 技术，预先分配一批栈空间，减少栈分配的开销。
④ Fiber 池化 (Fiber Pooling)
Fiber 池化 (Fiber Pooling) 可以减少 Fiber 创建和销毁的开销，提高性能。
调优技巧：
⚝ 使用 Fiber 池： 对于频繁创建和销毁的 Fiber，使用 Fiber 池来复用 Fiber 对象。可以使用现有的 Fiber 池库，或者自定义 Fiber 池实现。
⚝ 调整 Fiber 池大小： 根据应用程序的负载情况，调整 Fiber 池的大小。池大小过小可能导致 Fiber 供应不足，池大小过大则会浪费内存。
⚝ 预热 Fiber 池： 在程序启动时，预先创建一批 Fiber 放入池中，进行预热 (Warm-up)，减少程序运行时的 Fiber 创建延迟。
⑤ 减少上下文切换开销 (Reducing Context Switching Overhead)
虽然 Fiber 的上下文切换开销比线程小，但频繁的上下文切换仍然会影响性能。
调优技巧：
⚝ 批量处理任务： 将多个小任务合并成一个大任务进行处理，减少上下文切换的次数。
⚝ 减少 yield 调用： 避免在不必要的地方调用 fiber::yield()。只有在 Fiber 需要等待 I/O 或者长时间占用 CPU 时，才需要 yield。
⚝ 优化调度策略： 选择合适的调度策略，减少不必要的上下文切换。例如，可以使用本地调度 (Local Scheduling)，尽量将 Fiber 调度到同一个 CPU 核心上执行，减少跨核心的上下文切换开销。
⑥ 非阻塞 I/O 优化 (Non-blocking I/O Optimization)
非阻塞 I/O (Non-blocking I/O) 是 Fiber 高性能的关键。优化非阻塞 I/O 的使用可以显著提高 Fiber 程序的性能。
调优技巧：
⚝ 使用高效的 I/O 多路复用机制： 选择高效的 I/O 多路复用机制，例如 epoll (Linux)、kqueue (macOS)、iocp (Windows)。
⚝ 减少系统调用： 尽量减少 I/O 操作的系统调用次数。可以使用批量 I/O (Batch I/O) 技术，将多个 I/O 操作合并成一个系统调用。
⚝ 零拷贝技术： 对于大块数据的 I/O 操作，可以使用零拷贝 (Zero-copy) 技术，减少数据拷贝的开销。例如，使用 sendfile() 系统调用进行文件传输。
⚝ I/O 调度优化： 对于磁盘 I/O，可以使用 I/O 调度器来优化磁盘 I/O 的性能。例如，使用 CFQ、Deadline 等 I/O 调度器。
⑦ 数据局部性优化 (Data Locality Optimization)
数据局部性 (Data Locality) 指的是程序访问的数据在内存中聚集的程度。提高数据局部性可以减少 CPU 缓存失效，提高程序性能。
调优技巧：
⚝ 数据结构优化： 选择合适的数据结构，提高数据访问的局部性。例如，使用数组 (Array) 代替链表 (Linked List)，可以提高顺序访问的局部性。
⚝ 缓存友好的数据布局： 将相关的数据放在一起，提高空间局部性。例如，可以使用结构体数组 (Array of Structures, AOS) 代替数组结构体 (Structure of Arrays, SOA)，提高结构体成员的访问局部性。
⚝ CPU 亲和性： 将 Fiber 绑定到特定的 CPU 核心上执行，提高 CPU 缓存的命中率。可以使用 pthread_setaffinity_np() 等 API 设置 CPU 亲和性。
⑧ 代码优化 (Code Optimization)
最终，代码本身的效率也直接影响 Fiber 程序的性能。
调优技巧：
⚝ 算法优化： 选择更高效的算法，降低时间复杂度。
⚝ 编译器优化： 使用编译器优化选项（例如 -O3）进行编译，开启编译器的各种优化功能。
⚝ 内联函数： 对于频繁调用的短小函数，使用 inline 关键字进行内联，减少函数调用开销。
⚝ 避免不必要的内存分配： 尽量避免在循环中进行内存分配和释放操作。可以使用对象池 (Object Pool) 或内存池 (Memory Pool) 来复用对象和内存。
⚝ 减少虚函数调用： 虚函数调用会增加函数调用开销。如果不需要多态性，尽量避免使用虚函数。
通过综合运用这些性能调优技巧，可以显著提升 Folly Fiber 程序的性能，使其更好地满足高性能并发应用的需求。性能调优是一个迭代的过程，需要不断地进行剖析、分析、优化和测试，才能达到最佳的性能效果。
END_OF_CHAPTER
10. chapter 10： 总结与展望 (Summary and Future Outlook)
10.1 Folly Fiber 的优势与局限性总结 (Summary of Advantages and Limitations of Folly Fibers)
Folly Fiber 作为一种轻量级的并发编程工具，在现代高性能应用开发中扮演着重要的角色。本节将对 Folly Fiber 的优势与局限性进行总结，以便读者能够更全面地理解和应用 Fiber 技术。
优势 (Advantages):
① 轻量级并发 (Lightweight Concurrency)：Fiber 最显著的优势在于其轻量级特性。
▮▮▮▮ⓑ 与传统的线程和进程相比，Fiber 的创建和切换开销非常小，因为它运行在用户空间，无需操作系统内核的介入。这使得 Fiber 能够支持大规模并发，轻松管理数以万计甚至数十万计的并发任务，而不会显著增加系统负担。
▮▮▮▮ⓒ 这种轻量级特性使得 Fiber 非常适合 I/O 密集型应用，例如网络服务器、消息队列和微服务架构，在这些场景下，大量的并发连接和请求需要高效处理。
② 高效的上下文切换 (Efficient Context Switching)：Fiber 的上下文切换由用户代码控制，通常比线程的内核级上下文切换快得多。
▮▮▮▮ⓑ Fiber 的上下文切换仅需保存和恢复少量的寄存器和栈信息，而线程的上下文切换则涉及更复杂的内核状态管理，开销更大。
▮▮▮▮ⓒ 高效的上下文切换使得 Fiber 能够在不同的任务之间快速切换，从而提高系统的整体吞吐量和响应速度。
③ 协作式多任务处理 (Cooperative Multitasking)：Folly Fiber 采用协作式多任务处理模型，Fiber 只有在主动让出 CPU 时才会发生切换。
▮▮▮▮ⓑ 这种模型避免了线程的抢占式调度带来的上下文切换开销和资源竞争问题，简化了并发编程的复杂性。
▮▮▮▮ⓒ 程序员可以更精确地控制任务的执行流程，更容易编写出高效且可靠的并发程序。
④ 更好的资源利用率 (Improved Resource Utilization)：由于 Fiber 的轻量级和高效切换特性，使用 Fiber 可以更充分地利用系统资源，例如 CPU 和内存。
▮▮▮▮ⓑ 在相同的硬件资源下，Fiber 可以支持比线程更多的并发任务，从而提高系统的资源利用率和整体性能。
▮▮▮▮ⓒ 这对于需要处理大规模并发的应用场景尤为重要，例如高负载的网络服务和大数据处理系统。
⑤ 简化异步编程 (Simplified Asynchronous Programming)：Fiber 提供了一种更简洁、更直观的异步编程模型。
▮▮▮▮ⓑ 使用 Fiber 可以将异步操作写成看似同步的代码，避免了传统回调函数和 Promise 带来的代码复杂性和可读性问题。
▮▮▮▮ⓒ 例如，可以使用 folly::fibers::Baton 等同步原语来协调 Fiber 之间的操作，使得异步编程更加容易理解和维护。
局限性 (Limitations):
① 协作式调度的局限 (Limitations of Cooperative Scheduling)：协作式调度依赖于 Fiber 主动让出 CPU，如果某个 Fiber 长时间占用 CPU 而不让出，可能会导致其他 Fiber 饥饿，甚至整个程序hang住。
▮▮▮▮ⓑ 这要求程序员在编写 Fiber 程序时，必须注意避免长时间的 CPU 密集型操作，或者在适当的时候主动让出 CPU，例如使用 folly::fibers::yield()。
▮▮▮▮ⓒ 相比之下，线程的抢占式调度可以更好地保证公平性，避免某个线程长时间占用 CPU。
② 阻塞式系统调用的问题 (Blocking System Calls)：在 Fiber 中执行阻塞式系统调用（例如 read、write、sleep 等）会阻塞整个线程，影响同一线程上运行的其他 Fiber。
▮▮▮▮ⓑ 为了避免这个问题，应该尽量使用非阻塞式 I/O 操作，并结合 folly::EventBase 和 folly::AsyncSocket 等异步 I/O 工具。
▮▮▮▮ⓒ 或者，可以将阻塞式操作放到独立的线程中执行，然后通过 Fiber 与线程之间的通信机制进行协调。
③ 调试和诊断的挑战 (Debugging and Diagnosis Challenges)：Fiber 的执行流程相对复杂，调试和诊断 Fiber 程序可能会比调试线程程序更具挑战性。
▮▮▮▮ⓑ 由于 Fiber 的上下文切换发生在用户空间，传统的调试工具可能无法直接跟踪 Fiber 的执行状态。
▮▮▮▮ⓒ 需要使用专门的 Fiber 调试工具和技术，例如日志记录、性能分析和 Fiber 状态监控，来定位和解决 Fiber 程序中的问题。
④ 与现有代码的集成 (Integration with Existing Code)：将 Fiber 集成到现有的多线程代码库中可能需要进行一定的改造。
▮▮▮▮ⓑ 需要仔细考虑 Fiber 和线程之间的交互，例如数据共享、同步和错误处理。
▮▮▮▮ⓒ 在某些情况下，可能需要重构部分代码，以充分利用 Fiber 的优势，并避免潜在的兼容性问题。
⑤ 学习曲线 (Learning Curve)：虽然 Fiber 的概念相对简单，但要熟练掌握 Fiber 编程并充分发挥其潜力，仍然需要一定的学习成本。
▮▮▮▮ⓑ 程序员需要理解 Fiber 的核心原理、API 和最佳实践，并掌握 Fiber 相关的调试和性能优化技术。
▮▮▮▮ⓒ 对于初学者来说，可能需要花费一些时间来适应 Fiber 的编程模型，并避免常见的 Fiber 编程错误。
总结 (Summary)
Folly Fiber 作为一种强大的并发编程工具，具有轻量级、高效、易用等优点，在高性能网络编程、异步任务处理和并发控制等领域具有广泛的应用前景。然而，Fiber 也存在一些局限性，例如协作式调度的局限、阻塞式系统调用的问题以及调试和诊断的挑战。
在实际应用中，需要根据具体的场景和需求，权衡 Fiber 的优势与局限性，合理选择并发编程模型。对于 I/O 密集型应用，Fiber 通常是一个非常好的选择。对于 CPU 密集型应用，或者需要与现有线程代码库深度集成的场景，可能需要结合线程或其他并发技术来解决问题。
10.2 Fiber 技术的未来发展趋势 (Future Development Trends of Fiber Technology)
随着计算机技术的不断发展，对高性能、高并发应用的需求日益增长，Fiber 技术作为一种轻量级并发解决方案，其未来发展趋势备受关注。本节将对 Fiber 技术的未来发展趋势进行展望，探讨其可能的发展方向和应用前景。
更广泛的应用场景 (Wider Application Scenarios)
① 云计算与边缘计算 (Cloud Computing and Edge Computing)：随着云计算和边缘计算的兴起，对资源高效利用和高性能并发处理的需求更加迫切。Fiber 技术凭借其轻量级和高效的特性，有望在云计算和边缘计算领域得到更广泛的应用，例如构建高性能的云服务、边缘计算节点和serverless 函数。
② 物联网 (Internet of Things, IoT)：物联网设备数量庞大，连接复杂，对并发处理能力和资源消耗提出了更高的要求。Fiber 技术可以应用于物联网平台、网关和设备端，实现高效的设备管理、数据采集和控制，提升物联网系统的整体性能和可扩展性。
③ 人工智能 (Artificial Intelligence, AI)：人工智能应用，例如深度学习和自然语言处理，通常需要处理大规模的数据和复杂的计算任务。Fiber 技术可以应用于 AI 框架和推理引擎，提高数据处理和模型推理的并发性，加速 AI 应用的开发和部署。
④ 游戏开发 (Game Development)：游戏开发对性能和响应速度要求极高，尤其是在多人在线游戏中。Fiber 技术可以应用于游戏服务器和客户端，实现高效的并发处理和低延迟的网络通信，提升游戏的用户体验。
⑤ 实时系统 (Real-time Systems)：在某些实时系统中，例如金融交易系统和工业控制系统，对响应时间和吞吐量有严格的要求。Fiber 技术可以应用于构建高性能的实时系统，满足其对低延迟和高并发的需求。
与新兴技术的融合 (Integration with Emerging Technologies)
① 与协程 (Coroutines) 的融合：协程是另一种轻量级并发技术，与 Fiber 在概念和实现上有很多相似之处。未来，Fiber 技术有望与协程技术进一步融合，例如在语言层面提供对 Fiber 和协程的统一支持，或者在库层面提供 Fiber 和协程的互操作性，从而为开发者提供更灵活、更强大的并发编程工具。
② 与 Actor 模型 (Actor Model) 的结合：Actor 模型是一种基于消息传递的并发模型，可以有效地解决并发编程中的状态管理和同步问题。将 Fiber 技术与 Actor 模型结合，可以构建更高效、更易于管理的并发系统，例如使用 Fiber 实现 Actor 的轻量级执行单元，或者使用 Actor 模型来管理 Fiber 的生命周期和调度。
③ 与硬件加速 (Hardware Acceleration) 的结合：随着硬件加速技术的发展，例如 GPU 和 FPGA，可以利用硬件加速器来加速 Fiber 的上下文切换和调度，进一步提升 Fiber 的性能。例如，可以将 Fiber 的上下文切换操作卸载到 GPU 或 FPGA 上执行，或者使用硬件加速器来实现更高效的 Fiber 调度器。
④ 与新型编程语言 (New Programming Languages) 的集成：一些新型编程语言，例如 Rust 和 Go，在设计之初就考虑了并发编程的需求，并提供了对轻量级并发机制的原生支持。未来，Fiber 技术有望与这些新型编程语言更紧密地集成，例如作为语言标准库的一部分提供，或者作为语言特性的核心组成部分，从而降低 Fiber 编程的学习成本和使用门槛。
技术挑战与发展方向 (Technical Challenges and Development Directions)
① 更智能的调度器 (Smarter Schedulers)：未来的 Fiber 调度器需要更加智能，能够根据应用的负载和资源状况，动态调整调度策略，实现更高效的资源利用和更好的性能。例如，可以开发基于机器学习的 Fiber 调度器，根据历史数据和实时监控信息，预测 Fiber 的执行时间和资源需求，从而做出更优的调度决策。
② 更完善的调试工具 (More Comprehensive Debugging Tools)：为了解决 Fiber 调试和诊断的挑战，需要开发更完善的 Fiber 调试工具，例如支持 Fiber 状态可视化、Fiber 执行路径跟踪、Fiber 性能分析等功能，帮助开发者更快速、更准确地定位和解决 Fiber 程序中的问题。
③ 更易用的 API (More User-Friendly APIs)：为了降低 Fiber 编程的学习成本和使用门槛，需要设计更易用、更友好的 Fiber API，例如提供更简洁的同步原语、更方便的错误处理机制、更清晰的编程模型，使得开发者能够更轻松地编写出高效、可靠的 Fiber 程序。
④ 更好的跨平台支持 (Better Cross-Platform Support)：为了提高 Fiber 技术的通用性和可移植性，需要加强 Fiber 技术的跨平台支持，例如支持更多的操作系统和硬件平台，提供统一的 Fiber API 和行为，使得开发者能够更方便地将 Fiber 程序部署到不同的环境中。
总结 (Summary)
Fiber 技术作为一种轻量级并发解决方案，具有广阔的发展前景。随着云计算、物联网、人工智能等新兴技术的兴起，Fiber 技术有望在更多领域得到应用。未来，Fiber 技术将与协程、Actor 模型、硬件加速等技术进一步融合，并面临着调度器优化、调试工具完善、API 易用性提升和跨平台支持增强等技术挑战。通过不断的技术创新和发展，Fiber 技术将为构建高性能、高并发应用提供更强大的支持。
附录 A：术语表 (Glossary)
⚝ Fiber (纤程)：一种轻量级的用户级线程，与操作系统线程相比，Fiber 的创建、切换和销毁开销更小，可以支持更高的并发度。
⚝ Thread (线程)：操作系统调度的最小单元，线程共享进程的地址空间和资源，但拥有独立的执行栈和寄存器。
⚝ Process (进程)：操作系统资源分配的最小单元，进程拥有独立的地址空间和资源，进程之间相互隔离。
⚝ Context Switching (上下文切换)：CPU 从一个执行单元（线程或 Fiber）切换到另一个执行单元的过程，包括保存和恢复执行单元的上下文信息。
⚝ Cooperative Multitasking (协作式多任务处理)：一种多任务处理方式，任务只有在主动让出 CPU 时才会发生切换，与抢占式多任务处理相对。
⚝ Preemptive Multitasking (抢占式多任务处理)：一种多任务处理方式，操作系统根据时间片轮转等策略，强制切换任务的执行，与协作式多任务处理相对。
⚝ Scheduler (调度器)：负责管理和调度执行单元（线程或 Fiber）的组件，决定哪个执行单元在何时运行。
⚝ Fiber Pool (Fiber 池)：预先创建一组 Fiber，用于复用 Fiber 对象，减少 Fiber 创建和销毁的开销，提高性能。
⚝ Fiber-Local Storage (Fiber 局部存储)：一种线程局部存储的变体，允许在 Fiber 级别存储和访问数据，每个 Fiber 拥有独立的局部存储空间。
⚝ Asynchronous Programming (异步编程)：一种编程范式，允许程序在等待 I/O 操作完成时继续执行其他任务，提高程序的并发性和响应速度。
⚝ Blocking Operation (阻塞式操作)：一种操作，在完成之前会阻塞当前执行单元（线程或 Fiber），例如阻塞式 I/O 操作。
⚝ Non-blocking Operation (非阻塞式操作)：一种操作，不会阻塞当前执行单元，立即返回，即使操作尚未完成，例如非阻塞式 I/O 操作。
⚝ EventBase (事件循环)：Folly 库中的事件循环机制，用于处理异步事件，例如 I/O 事件、定时器事件等。
⚝ AsyncSocket (异步套接字)：Folly 库提供的异步套接字 API，用于进行非阻塞式网络 I/O 操作。
⚝ Baton (接力棒)：Folly Fiber 提供的同步原语，用于 Fiber 之间的同步和通信。
⚝ Yield (让出)：Fiber 主动让出 CPU 的操作，允许其他 Fiber 运行。
⚝ Starvation (饥饿)：在协作式多任务处理中，某个任务长时间无法获得 CPU 执行机会的现象。
⚝ Deadlock (死锁)：两个或多个任务互相等待对方释放资源，导致所有任务都无法继续执行的状态。
⚝ Race Condition (竞争条件)：多个任务并发访问共享资源，导致程序行为不确定或出现错误的状态。
⚝ RPC (Remote Procedure Call，远程过程调用)：一种计算机通信协议，允许程序调用另一台计算机上的函数或过程，就像调用本地函数一样。
⚝ HTTP (Hypertext Transfer Protocol，超文本传输协议)：一种用于传输超文本的应用层协议，是万维网数据传输的基础。
⚝ Streaming Data Processing (流式数据处理)：一种数据处理方式，实时处理连续不断的数据流，而不是批量处理静态数据。
⚝ Performance Tuning (性能调优)：通过调整程序代码、配置参数或系统环境，提高程序性能的过程。
⚝ Debugging (调试)：查找和修复程序错误的过程。
⚝ Diagnosis (诊断)：分析和定位程序问题的根源的过程。
⚝ Concurrency (并发)：程序同时处理多个任务的能力。
⚝ Parallelism (并行)：程序在多个处理器或核心上同时执行多个任务的能力。
附录 B：扩展阅读与参考资料 (Further Reading and References)
Folly 官方文档 (Folly Official Documentation)
⚝ Folly GitHub 仓库: https://github.com/facebook/folly (包含 Folly Fiber 的源代码和文档)
⚝ Folly 官方文档: https://facebook.github.io/folly/ (提供 Folly 库的详细介绍和使用指南)
⚝ Folly Fiber 文档: (在 Folly 官方文档中搜索 "Fiber" 或 "FiberManager" 可以找到 Fiber 相关的文档)
Fiber 技术相关资料 (Fiber Technology Related Resources)
⚝ Wikipedia - Fiber (computer science): https://en.wikipedia.org/wiki/Fiber_(computer_science) (维基百科关于 Fiber 的介绍)
⚝ Boost.Fiber: https://www.boost.org/doc/libs/1_83_0/libs/fiber/doc/html/index.html (Boost 库提供的 Fiber 实现)
⚝ libmill: http://libmill.org/ (C 语言的 Fiber 库)
⚝ Go Coroutines (Goroutines): https://go.dev/tour/concurrency/1 (Go 语言的协程，与 Fiber 概念类似)
⚝ Kotlin Coroutines: https://kotlinlang.org/docs/coroutines-guide.html (Kotlin 语言的协程)
⚝ C++20 Coroutines: https://en.cppreference.com/w/cpp/language/coroutines (C++20 标准引入的协程)
并发编程相关书籍 (Concurrency Programming Related Books)
⚝ 《深入理解计算机系统 (深入理解计算机系统)》 (Computer Systems: A Programmer's Perspective) - Randal E. Bryant, David R. O'Hallaron (经典计算机系统教材，包含并发编程章节)
⚝ 《Effective C++》 - Scott Meyers (C++ 编程经典书籍，包含多线程编程建议)
⚝ 《Effective Modern C++》 - Scott Meyers (C++11/14 编程经典书籍，包含并发编程新特性)
⚝ 《C++ Concurrency in Action》 - Anthony Williams (C++ 并发编程实战指南)
⚝ 《Java Concurrency in Practice》 - Brian Goetz 等 (Java 并发编程经典书籍，虽然是 Java，但并发编程思想通用)
⚝ 《Seven Concurrency Models in Seven Weeks》 - Paul Butcher (介绍七种不同的并发模型，包括 Actor 模型、CSP 等)
在线课程与博客 (Online Courses and Blogs)
⚝ Coursera, edX, Udacity 等在线教育平台: (搜索 "Concurrency", "Parallel Programming", "Asynchronous Programming" 等关键词，可以找到并发编程相关的课程)
⚝ CppCon 演讲: https://www.youtube.com/results?search_query=CppCon+concurrency (CppCon 会议有很多关于 C++ 并发编程的演讲视频)
⚝ Herb Sutter 的博客 "GotW" (Guru of the Week): https://herbsutter.com/gotw/ (Herb Sutter 是 C++ 标准委员会主席，他的博客有很多关于 C++ 并发编程的深入讨论)
⚝ 其他技术博客: (搜索 "C++ Fiber", "Folly Fiber", "Concurrency Programming" 等关键词，可以找到很多技术博客文章)
论文 (Papers)
⚝ "Threads cannot be implemented as a library" - Hans-J. Boehm (讨论了用户级线程（Fiber）和内核级线程的区别和优劣)
⚝ "The Performance of User-Level Threads" - Brian N. Bershad, Thomas E. Anderson, Edward D. Lazowska, Henry M. Levy (评估了用户级线程的性能)
希望以上扩展阅读与参考资料能够帮助读者更深入地学习和理解 Fiber 技术，以及相关的并发编程知识。
END_OF_CHAPTER