021 《folly EventBase.h 编程权威指南》
🌟🌟🌟本文案由Gemini 2.0 Flash Thinking Experimental 01-21创作，用来辅助学习知识。🌟🌟🌟
书籍大纲
▮▮▮▮ 1. chapter 1： 初识 EventBase (Introduction to EventBase)
▮▮▮▮▮▮▮ 1.1 事件驱动编程模型概述 (Overview of Event-Driven Programming Model)
▮▮▮▮▮▮▮ 1.2 为什么选择 EventBase (Why Choose EventBase)
▮▮▮▮▮▮▮ 1.3 EventBase 的核心概念 (Core Concepts of EventBase)
▮▮▮▮▮▮▮ 1.4 搭建开发环境 (Setting up Development Environment)
▮▮▮▮▮▮▮▮▮▮▮ 1.4.1 依赖库安装 (Dependency Library Installation)
▮▮▮▮▮▮▮▮▮▮▮ 1.4.2 编译与配置 (Compilation and Configuration)
▮▮▮▮▮▮▮▮▮▮▮ 1.4.3 第一个 EventBase 程序 (First EventBase Program)
▮▮▮▮ 2. chapter 2： EventBase 核心机制详解 (Detailed Explanation of EventBase Core Mechanism)
▮▮▮▮▮▮▮ 2.1 事件循环 (Event Loop)
▮▮▮▮▮▮▮ 2.2 事件注册与分发 (Event Registration and Dispatch)
▮▮▮▮▮▮▮ 2.3 文件描述符事件 (File Descriptor Events)
▮▮▮▮▮▮▮ 2.4 定时器事件 (Timer Events)
▮▮▮▮▮▮▮ 2.5 信号事件 (Signal Events)
▮▮▮▮ 3. chapter 3： EventBase 实战代码 (Practical Code of EventBase)
▮▮▮▮▮▮▮ 3.1 基于 EventBase 的简单 TCP 服务器 (Simple TCP Server based on EventBase)
▮▮▮▮▮▮▮ 3.2 处理客户端连接 (Handling Client Connections)
▮▮▮▮▮▮▮ 3.3 数据收发与事件处理 (Data Sending and Receiving and Event Handling)
▮▮▮▮▮▮▮ 3.4 超时管理 (Timeout Management)
▮▮▮▮ 4. chapter 4： EventBase 高级应用 (Advanced Applications of EventBase)
▮▮▮▮▮▮▮ 4.1 集成异步任务 (Integrating Asynchronous Tasks)
▮▮▮▮▮▮▮ 4.2 多线程 EventBase (Multi-threaded EventBase)
▮▮▮▮▮▮▮ 4.3 自定义事件源 (Custom Event Sources)
▮▮▮▮▮▮▮ 4.4 性能调优与最佳实践 (Performance Tuning and Best Practices)
▮▮▮▮ 5. chapter 5： EventBase API 全面解析 (Comprehensive API Analysis of EventBase)
▮▮▮▮▮▮▮ 5.1 EventBase 类详解 (Detailed Explanation of EventBase Class)
▮▮▮▮▮▮▮ 5.2 EventHandler 类族 (EventHandler Class Family)
▮▮▮▮▮▮▮ 5.3 TimerHandler 和 SignalHandler (TimerHandler and SignalHandler)
▮▮▮▮▮▮▮ 5.4 文件描述符操作 API (File Descriptor Operation APIs)
▮▮▮▮ 6. chapter 6： EventBase 与 Folly 库其他组件集成 (Integration of EventBase with other Folly Library Components)
▮▮▮▮▮▮▮ 6.1 使用 Folly Futures 简化异步编程 (Simplifying Asynchronous Programming with Folly Futures)
▮▮▮▮▮▮▮ 6.2 与 IO 库的协同工作 (Working with IO Library)
▮▮▮▮▮▮▮ 6.3 结合 TaskQueue 实现任务调度 (Implementing Task Scheduling with TaskQueue)
▮▮▮▮ 7. chapter 7： EventBase 源码剖析 (Source Code Analysis of EventBase)
▮▮▮▮▮▮▮ 7.1 EventLoop 的实现原理 (Implementation Principle of EventLoop)
▮▮▮▮▮▮▮ 7.2 事件分发机制深入分析 (In-depth Analysis of Event Dispatch Mechanism)
▮▮▮▮▮▮▮ 7.3 跨平台兼容性处理 (Cross-platform Compatibility Handling)
▮▮▮▮ 8. chapter 8： 案例分析与最佳实践 (Case Studies and Best Practices)
▮▮▮▮▮▮▮ 8.1 高并发网络服务器设计 (High-Concurrency Network Server Design)
▮▮▮▮▮▮▮ 8.2 构建高性能 RPC 框架 (Building High-Performance RPC Framework)
▮▮▮▮▮▮▮ 8.3 EventBase 在大型项目中的应用 (Application of EventBase in Large-scale Projects)
▮▮▮▮ 9. chapter 9： EventBase 的未来展望 (Future Prospects of EventBase)
▮▮▮▮▮▮▮ 9.1 EventBase 的发展趋势 (Development Trend of EventBase)
▮▮▮▮▮▮▮ 9.2 与其他事件循环库的比较 (Comparison with other Event Loop Libraries)
▮▮▮▮▮▮▮ appendix A： 常用术语表 (Glossary of Common Terms)
▮▮▮▮▮▮▮ appendix B： EventBase 快速参考 (EventBase Quick Reference)
1. chapter 1： 初识 EventBase (Introduction to EventBase)
1.1 事件驱动编程模型概述 (Overview of Event-Driven Programming Model)
在深入探索 folly/EventBase.h 之前，我们首先需要理解事件驱动编程模型 (Event-Driven Programming Model) 的基本概念。这是一种有别于传统同步编程模型 (Synchronous Programming Model) 的、更加高效和灵活的程序设计范式，尤其在处理高并发和 I/O 密集型任务时表现出色。
传统的同步编程模型，也常被称为线性编程 (Linear Programming) 或顺序编程 (Sequential Programming)，程序按照代码的书写顺序自上而下依次执行。当程序执行到 I/O 操作（例如，读取文件、网络请求）时，会阻塞 (Block) 当前线程，等待 I/O 操作完成才能继续执行后续代码。这种模式在处理简单的、低并发的任务时尚可，但在面对需要同时处理大量并发连接或需要快速响应用户操作的场景时，其效率和响应性会显著下降。
与之形成鲜明对比的是事件驱动编程模型。它不再以程序的执行流程为主线，而是以事件 (Event) 的产生和处理为核心。程序的主体是一个事件循环 (Event Loop)，它不断地监听各种事件源（例如，文件描述符、定时器、信号），当事件发生时，事件循环会分发 (Dispatch) 事件到预先注册的事件处理器 (Event Handler) 进行处理。
事件驱动模型的核心思想可以概括为以下几点：
① 非阻塞 I/O (Non-blocking I/O)：当程序发起 I/O 操作时，不会阻塞当前线程，而是立即返回。程序可以继续执行其他任务，而 I/O 操作在后台异步进行。当 I/O 操作完成时，会产生一个事件通知程序。
② 事件循环 (Event Loop)：程序的核心是一个无限循环，负责监听和分发事件。事件循环不断地检查是否有事件发生，如果有，则将事件分发给相应的事件处理器进行处理。
③ 事件处理器 (Event Handler)：也称为回调函数 (Callback Function)。当事件发生时，事件循环会调用预先注册的事件处理器来处理该事件。事件处理器通常是短小精悍的函数，负责快速处理事件并返回，避免长时间阻塞事件循环。
④ 异步编程 (Asynchronous Programming)：事件驱动模型天然地支持异步编程。程序可以发起多个异步操作，而无需等待每个操作完成。当操作完成时，通过事件通知机制来处理结果。
为了更形象地理解事件驱动模型，我们可以将其比作一个餐厅的服务流程：
⚝ 同步模型：顾客（线程）点餐后，服务员（程序）会一直站在顾客旁边等待菜品做好（I/O 操作完成），然后将菜品端给顾客，才能服务下一位顾客。如果菜品制作时间很长，服务员就会一直空闲等待，效率低下。
⚝ 事件驱动模型：顾客点餐后，服务员将订单交给厨房（发起异步 I/O 操作），然后就可以去服务其他顾客。当菜品做好后，厨房会通过叫号系统（事件通知）通知服务员，服务员再将菜品端给对应的顾客（事件处理）。这样，服务员可以同时处理多个顾客的订单，提高了效率。
事件驱动编程模型具有以下显著优点：
① 高并发性 (High Concurrency)：由于采用非阻塞 I/O 和事件循环机制，程序可以同时处理大量的并发连接，而无需创建大量的线程或进程，从而降低了系统开销，提高了并发性能。
② 高响应性 (High Responsiveness)：程序能够及时响应外部事件，例如用户输入、网络请求等，因为事件处理是异步的，不会阻塞主线程，保证了程序的快速响应。
③ 资源效率 (Resource Efficiency)：相比于多线程或多进程模型，事件驱动模型通常使用更少的线程或进程来处理并发任务，从而节省了系统资源，例如 CPU 和内存。
④ 代码简洁 (Code Simplicity)：在某些场景下，事件驱动模型可以简化异步编程的复杂性，使代码更加清晰易懂。
然而，事件驱动编程模型也存在一些挑战：
① 回调地狱 (Callback Hell)：当异步操作嵌套过多时，容易形成深层嵌套的回调函数，导致代码难以理解和维护。为了解决这个问题，现代编程语言和库通常会提供更高级的异步编程抽象，例如 Promise (承诺)、Future (未来)、async/await (异步/等待) 等。
② 错误处理 (Error Handling)：在异步编程中，错误处理可能会更加复杂，因为错误可能在不同的时间点和不同的回调函数中发生。需要仔细设计错误处理机制，确保程序的健壮性。
③ 调试困难 (Debugging Difficulty)：异步程序的执行流程不如同步程序直观，调试起来可能会更加困难。需要使用专门的调试工具和技巧来定位和解决问题。
总而言之，事件驱动编程模型是一种强大而高效的编程范式，特别适用于构建高性能、高并发的网络应用、GUI 应用、实时系统等。理解事件驱动模型的核心概念和原理，对于深入学习和应用 folly/EventBase.h 至关重要。
1.2 为什么选择 EventBase (Why Choose EventBase)
在众多的事件循环库中，例如 libevent、libuv、asio 等，folly/EventBase.h 凭借其独特的优势，成为了构建高性能 C++ 应用的卓越选择。EventBase 是 Folly (Facebook Open-source Library) 库的核心组件之一，而 Folly 库是由 Meta (前 Facebook) 开源的一套高性能 C++ 库，被广泛应用于 Meta 的各种核心基础设施中，经历了大规模、高负载的生产环境的严苛考验，其稳定性和可靠性毋庸置疑。
选择 EventBase 的理由主要体现在以下几个方面：
① 高性能与可扩展性 (High Performance and Scalability)：EventBase 底层基于高效的 I/O 多路复用机制，例如 epoll (Linux)、kqueue (macOS, FreeBSD)、select 和 poll 等，能够高效地处理大量的并发连接和事件。其设计目标就是为了满足 Meta 级别的高性能和可扩展性需求，因此在性能方面有着卓越的表现。
② 跨平台兼容性 (Cross-platform Compatibility)：EventBase 抽象了底层不同操作系统平台 I/O 多路复用机制的差异，提供了统一的 API 接口，使得开发者可以编写一份代码，在 Linux、macOS、Windows 等多个平台上编译和运行，大大提高了代码的可移植性。
③ 与 Folly 库的深度集成 (Deep Integration with Folly Library)：EventBase 与 Folly 库的其他组件，例如 Futures (未来)、IO 库、TaskQueue (任务队列) 等，有着良好的集成和协同工作能力。这使得开发者可以充分利用 Folly 库提供的丰富功能，构建更加强大和高效的应用。例如，结合 Folly Futures 可以简化异步编程，结合 IO 库可以方便地进行网络 I/O 操作，结合 TaskQueue 可以实现任务调度和管理。
④ 成熟稳定，久经考验 (Mature and Well-tested)：EventBase 在 Meta 内部经过了多年的大规模应用和持续优化，经历了各种复杂场景和高负载的考验，其稳定性和可靠性得到了充分验证。作为一个成熟的开源库，EventBase 拥有完善的文档和社区支持，可以为开发者提供有力的保障。
⑤ 丰富的功能特性 (Rich Features)：EventBase 提供了丰富的功能特性，支持多种类型的事件，包括：
▮▮▮▮⚝ 文件描述符事件 (File Descriptor Events)：用于监听文件描述符的可读、可写、错误等事件，常用于网络 I/O、文件 I/O 等场景。
▮▮▮▮⚝ 定时器事件 (Timer Events)：用于在指定的时间或周期性地触发事件，常用于定时任务、超时处理等场景。
▮▮▮▮⚝ 信号事件 (Signal Events)：用于监听系统信号，例如 SIGINT、SIGTERM 等，常用于处理进程信号。
▮▮▮▮⚝ 用户自定义事件 (Custom Events)：允许用户自定义事件源和事件类型，扩展 EventBase 的功能。
⑥ 易用性 (Ease of Use)：EventBase 提供了简洁明了的 API 接口，易于学习和使用。其设计注重实用性和效率，避免了过度复杂的设计，使得开发者可以快速上手并构建应用。
EventBase 尤其适合以下应用场景：
⚝ 高性能网络服务器 (High-Performance Network Servers)：例如，Web 服务器、反向代理服务器、游戏服务器、实时通信服务器等。EventBase 可以帮助构建能够处理海量并发连接、低延迟、高吞吐量的网络应用。
⚝ RPC 框架 (RPC Frameworks)：EventBase 可以作为 RPC 框架的底层事件循环库，提供高效的异步通信能力。
⚝ 消息队列系统 (Message Queue Systems)：EventBase 可以用于构建高性能的消息队列系统，处理大量的消息收发和路由。
⚝ 实时系统 (Real-time Systems)：例如，实时监控系统、金融交易系统等。EventBase 可以提供低延迟、高可靠的事件处理能力。
⚝ GUI 应用程序 (GUI Applications)：虽然 EventBase 主要用于服务器端开发，但也可以与 GUI 框架集成，用于处理用户界面事件和异步任务。
总之，EventBase 是一款高性能、跨平台、成熟稳定的事件循环库，是构建高性能 C++ 应用的理想选择。尤其对于需要处理高并发、I/O 密集型任务的应用场景，EventBase 能够提供强大的支持。
1.3 EventBase 的核心概念 (Core Concepts of EventBase)
要深入理解和使用 EventBase，掌握其核心概念至关重要。EventBase 的核心概念主要围绕事件循环 (Event Loop) 和事件处理 (Event Handling) 展开。
① EventBase 对象 (EventBase Object)：EventBase 类是 folly/EventBase.h 的核心类，代表一个事件循环实例。一个程序可以创建多个 EventBase 对象，每个 EventBase 对象管理一个独立的事件循环。通常情况下，一个线程会拥有一个 EventBase 对象。
② 事件循环 (Event Loop)：事件循环是 EventBase 的核心机制，它是一个无限循环，不断地执行以下操作：
▮▮▮▮⚝ 等待事件 (Wait for Events)：事件循环会调用底层的 I/O 多路复用机制（例如 epoll_wait、kqueue、select 等）来等待事件的发生。这个等待操作是阻塞 (Blocking) 的，但它只阻塞事件循环所在的线程，不会影响其他线程。
▮▮▮▮⚝ 事件分发 (Event Dispatch)：当有事件发生时，I/O 多路复用机制会返回就绪的事件。事件循环会遍历就绪的事件，并根据事件类型和关联的事件处理器 (Event Handler)，调用相应的事件处理器来处理事件。
▮▮▮▮⚝ 处理就绪队列 (Process Ready Queue)：EventBase 内部维护一个就绪队列 (Ready Queue)，用于存放待处理的事件。事件循环从就绪队列中取出事件，并调用事件处理器进行处理。
可以用以下伪代码来描述事件循环的工作流程：
1
while (true) {
2
// 1. 等待事件
3
ready_events = wait_for_events();
4
5
// 2. 事件分发
6
for (event in ready_events) {
7
handler = get_handler_for_event(event);
8
if (handler) {
9
// 将事件添加到就绪队列
10
ready_queue.push(event, handler);
11
}
12
}
13
14
// 3. 处理就绪队列
15
while (!ready_queue.empty()) {
16
event, handler = ready_queue.pop();
17
handler(event); // 调用事件处理器
18
}
19
}
③ 事件 (Event)：事件是程序中发生的某种值得关注的事情，例如：
▮▮▮▮⚝ 文件描述符事件 (File Descriptor Event)：表示文件描述符（例如 socket）上的可读、可写、错误等状态变化。
▮▮▮▮⚝ 定时器事件 (Timer Event)：表示定时器到期。
▮▮▮▮⚝ 信号事件 (Signal Event)：表示接收到系统信号。
▮▮▮▮⚝ 用户自定义事件 (Custom Event)：用户自定义的事件类型。
④ 事件源 (Event Source)：事件源是事件的来源，例如：
▮▮▮▮⚝ 文件描述符 (File Descriptor)：例如 socket、文件、管道等。
▮▮▮▮⚝ 定时器 (Timer)：由 EventBase 内部的定时器机制管理。
▮▮▮▮⚝ 信号 (Signal)：由操作系统内核产生。
▮▮▮▮⚝ 用户自定义事件源 (Custom Event Source)：用户自定义的事件来源。
⑤ 事件处理器 (Event Handler)：事件处理器是当事件发生时被调用的函数或对象。事件处理器负责处理事件，例如：
▮▮▮▮⚝ 读取文件描述符数据
▮▮▮▮⚝ 发送网络数据
▮▮▮▮⚝ 执行定时任务
▮▮▮▮⚝ 处理信号
▮▮▮▮⚝ 执行用户自定义的操作
在 EventBase 中，事件处理器通常以回调函数 (Callback Function) 或函数对象 (Function Object) 的形式注册到 EventBase 对象中。当事件发生时，事件循环会调用相应的事件处理器。
⑥ EventHandler 类族 (EventHandler Class Family)：EventBase 提供了一系列的 EventHandler 类族，用于方便地管理不同类型的事件处理器。例如：
▮▮▮▮⚝ EventHandler：基类，用于处理文件描述符事件。
▮▮▮▮⚝ TimerHandler：用于处理定时器事件。
▮▮▮▮⚝ SignalHandler：用于处理信号事件。
开发者可以通过继承这些 EventHandler 类，并重写相应的虚函数，来实现自定义的事件处理逻辑。
⑦ I/O 多路复用 (I/O Multiplexing)：EventBase 底层使用 I/O 多路复用机制来高效地监听多个文件描述符上的事件。常见的 I/O 多路复用机制包括：
▮▮▮▮⚝ select：最早的 I/O 多路复用机制，性能相对较低，存在文件描述符数量限制。
▮▮▮▮⚝ poll：改进的 select，解决了文件描述符数量限制，但性能仍然不高。
▮▮▮▮⚝ epoll (Linux)：Linux 平台上高效的 I/O 多路复用机制，基于事件通知和回调，性能很高。
▮▮▮▮⚝ kqueue (macOS, FreeBSD)：macOS 和 FreeBSD 平台上高效的 I/O 多路复用机制，功能强大，性能优异。
EventBase 会根据不同的操作系统平台，自动选择最佳的 I/O 多路复用机制，并对其进行封装，提供统一的接口。
理解了这些核心概念，我们就对 EventBase 的基本工作原理有了初步的认识。在接下来的章节中，我们将深入探讨 EventBase 的具体使用方法和高级应用。
1.4 搭建开发环境 (Setting up Development Environment)
在开始使用 EventBase 进行开发之前，我们需要先搭建好开发环境。本节将指导读者完成 EventBase 开发环境的搭建，包括依赖库安装、编译配置以及创建第一个 EventBase 程序。
1.4.1 依赖库安装 (Dependency Library Installation)
folly/EventBase.h 依赖于一些第三方库，在编译和运行 EventBase 程序之前，需要先安装这些依赖库。常见的依赖库包括：
① CMake：用于构建和管理 Folly 库的构建系统。
② Boost：C++ 准标准库，Folly 库大量使用了 Boost 库的功能。建议安装 Boost 1.60 或更高版本。
③ OpenSSL：用于网络安全和加密，如果需要使用 EventBase 的 SSL/TLS 功能，则需要安装 OpenSSL。
④ libevent：一个高性能的事件通知库，Folly 的 EventBase 内部可以使用 libevent 作为底层实现之一。虽然 Folly 也可以不依赖 libevent 自行实现事件循环，但安装 libevent 可以提供更多的选择和兼容性。
⑤ glog：Google Logging Library，用于日志记录。
⑥ gflags：Google Flags Library，用于命令行参数解析。
⑦ fmt：一个现代的 C++ 格式化库，用于替代 printf 和 iostream，提供更安全、更高效、更易用的格式化功能。
⑧ 双精度浮点支持 (Double-precision floating-point support): 确保你的编译器支持双精度浮点运算。
⑨ libsodium (可选): 一个现代的、易于使用的加密库。如果需要使用 Folly 的加密相关功能，则可能需要安装。
⑩ zlib, lz4, zstd, snappy (可选): 压缩库，用于数据压缩和解压缩。根据你使用的 Folly 组件，可能需要安装其中一些库。
⑪ Python (可选): 构建 Folly 库可能需要 Python 环境。
⑫ pkg-config (可选): 用于帮助编译器和链接器找到依赖库的路径。
在不同的操作系统平台上，安装这些依赖库的方式有所不同。以下分别介绍在 Linux 和 macOS 平台上的常用安装方法。
Linux (以 Ubuntu/Debian 为例)：
在 Ubuntu/Debian 系统上，可以使用 apt 包管理器来安装依赖库。打开终端，执行以下命令：
1
sudo apt update
2
sudo apt install -y cmake libboost-dev libboost-system-dev libboost-thread-dev libssl-dev libevent-dev libgoogle-glog-dev libgflags-dev libfmt-dev zlib1g-dev liblz4-dev libzstd-dev libsnappy-dev libsodium-dev python3 pkg-config
macOS (使用 Homebrew)：
如果你的 macOS 系统上安装了 Homebrew 包管理器，可以使用 brew 命令来安装依赖库。打开终端，执行以下命令：
1
brew update
2
brew install cmake boost openssl@1.1 libevent glog gflags fmt zlib lz4 zstd snappy libsodium python3 pkg-config
Windows:
在 Windows 上安装依赖库相对复杂一些，通常需要手动下载预编译的库文件，或者使用包管理器如 vcpkg 或 Chocolatey。由于本书主要面向 Linux 和 macOS 平台，Windows 平台的详细安装步骤在此不做赘述。读者可以参考 Folly 官方文档或相关教程进行 Windows 环境的搭建。
安装完依赖库后，可以使用 pkg-config --modversion <package-name> 命令来检查库是否安装成功以及版本信息。例如，检查 Boost 库是否安装成功，可以执行 pkg-config --modversion boost 命令。
1.4.2 编译与配置 (Compilation and Configuration)
安装完依赖库后，接下来需要编译和配置 Folly 库。Folly 库使用 CMake 作为构建系统。
① 克隆 Folly 仓库 (Clone Folly Repository)：
首先，需要从 GitHub 上克隆 Folly 库的源代码仓库。打开终端，使用 git clone 命令：
1
git clone https://github.com/facebook/folly.git
2
cd folly
② 创建构建目录 (Create Build Directory)：
在 Folly 仓库根目录下，创建一个用于存放构建文件的目录，例如 build：
1
mkdir build
2
cd build
③ 执行 CMake 配置 (Run CMake Configuration)：
在 build 目录下，执行 cmake 命令进行配置。CMake 会根据系统环境和 CMakeLists.txt 文件生成构建系统所需的 Makefile 或工程文件。
1
cmake ..
CMake 提供了丰富的配置选项，可以通过 -D<option>=<value> 的形式传递给 CMake 命令。常用的配置选项包括：
⚝ CMAKE_INSTALL_PREFIX：指定安装目录，默认为 /usr/local。
⚝ CMAKE_BUILD_TYPE：指定构建类型，例如 Debug、Release、RelWithDebInfo 等。默认为 Debug。
⚝ BUILD_SHARED_LIBS：指定构建共享库还是静态库，默认为 ON (构建共享库)。
⚝ BUILD_TESTS：指定是否构建测试程序，默认为 ON。
⚝ BUILD_EXAMPLES：指定是否构建示例程序，默认为 ON。
例如，要构建 Release 版本的 Folly 库，并安装到 /opt/folly 目录，可以执行以下 CMake 命令：
1
cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/opt/folly ..
④ 编译 (Compile)：
配置完成后，使用 make 命令进行编译：
1
make -j$(nproc)
-j$(nproc) 选项表示使用多线程编译，可以加快编译速度。$(nproc) 会自动获取当前系统的 CPU 核心数。
⑤ 安装 (Install)：
编译完成后，使用 make install 命令将 Folly 库安装到指定的安装目录（CMAKE_INSTALL_PREFIX）。需要使用 sudo 权限进行安装，因为默认安装目录 /usr/local 通常需要管理员权限。
1
sudo make install
安装完成后，Folly 库的头文件会被安装到 <CMAKE_INSTALL_PREFIX>/include/folly 目录，库文件会被安装到 <CMAKE_INSTALL_PREFIX>/lib 目录，CMake 配置文件会被安装到 <CMAKE_INSTALL_PREFIX>/lib/cmake/folly 目录。
⑥ 配置环境变量 (Configure Environment Variables) (可选)：
为了方便使用 Folly 库，可以将 Folly 库的头文件目录和库文件目录添加到系统的环境变量中。例如，可以将以下内容添加到 ~/.bashrc 或 ~/.zshrc 文件中：
1
export CMAKE_PREFIX_PATH=$CMAKE_PREFIX_PATH:/opt/folly # 如果安装到 /opt/folly
2
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/opt/folly/lib # Linux
3
export DYLD_LIBRARY_PATH=$DYLD_LIBRARY_PATH:/opt/folly/lib # macOS
然后执行 source ~/.bashrc 或 source ~/.zshrc 命令使环境变量生效。
1.4.3 第一个 EventBase 程序 (First EventBase Program)
环境搭建完成后，我们来编写第一个 EventBase 程序，体验 EventBase 的基本用法。
创建一个名为 hello_eventbase.cpp 的文件，输入以下代码：
1
#include <folly/EventBase.h>
2
#include <folly/Timer.h>
3
#include <iostream>
4
5
int main() {
6
folly::EventBase evb;
7
8
// 创建一个定时器，2秒后触发
9
folly::Timer timer(evb, std::chrono::milliseconds(2000));
10
timer.scheduleTimeout([&]() {
11
std::cout << "Hello, EventBase!" << std::endl;
12
evb.terminateLoopSoon(); // 停止事件循环
13
});
14
15
std::cout << "Starting EventBase loop..." << std::endl;
16
evb.loopForever(); // 启动事件循环
17
std::cout << "EventBase loop finished." << std::endl;
18
19
return 0;
20
}
代码解释：
① #include <folly/EventBase.h>：包含 EventBase 类的头文件。
② #include <folly/Timer.h>：包含 Timer 类的头文件，用于创建定时器。
③ folly::EventBase evb;：创建一个 EventBase 对象 evb，代表一个事件循环实例。
④ folly::Timer timer(evb, std::chrono::milliseconds(2000));：创建一个定时器 timer，关联到 evb 事件循环，定时器超时时间设置为 2000 毫秒 (2 秒)。
⑤ timer.scheduleTimeout([&]() { ... });：注册定时器超时回调函数。当定时器超时时，会执行 lambda 表达式中的代码：
▮▮▮▮⚝ std::cout << "Hello, EventBase!" << std::endl;：打印 "Hello, EventBase!"。
▮▮▮▮⚝ evb.terminateLoopSoon();：请求 evb 事件循环在当前事件处理完成后尽快停止。
⑥ std::cout << "Starting EventBase loop..." << std::endl;：打印 "Starting EventBase loop..."，表示即将启动事件循环。
⑦ evb.loopForever();：启动 evb 事件循环，进入无限循环，开始监听和处理事件。
⑧ std::cout << "EventBase loop finished." << std::endl;：当事件循环停止后，打印 "EventBase loop finished."。
编译程序：
使用 g++ 编译器编译 hello_eventbase.cpp 文件。需要链接 Folly 库和其依赖库。假设 Folly 库安装在 /opt/folly 目录，可以使用以下命令编译：
1
g++ hello_eventbase.cpp -o hello_eventbase -I/opt/folly/include -L/opt/folly/lib -lfolly -lfolly_json -lfolly_test_util -lfolly_wangle -lfolly_纖維 -lfolly_測量 -lboost_system -lboost_thread -lssl -lcrypto -levent -lglog -lgflags -lfmt -lz -llz4 -lzstd -lsnappy -lsodium
运行程序：
编译成功后，会生成可执行文件 hello_eventbase。在终端中运行该程序：
1
./hello_eventbase
程序输出如下：
1
Starting EventBase loop...
2
Hello, EventBase!
3
EventBase loop finished.
程序首先打印 "Starting EventBase loop..."，然后启动事件循环。2 秒后，定时器超时，回调函数被执行，打印 "Hello, EventBase!"，并停止事件循环。最后程序打印 "EventBase loop finished." 并退出。
恭喜你，你已经成功运行了第一个 EventBase 程序！这标志着你已经完成了 EventBase 开发环境的搭建，并对 EventBase 的基本用法有了初步的了解。在接下来的章节中，我们将继续深入学习 EventBase 的更多高级特性和应用。
END_OF_CHAPTER
2. chapter 2： EventBase 核心机制详解 (Detailed Explanation of EventBase Core Mechanism)
2.1 事件循环 (Event Loop)
事件驱动编程模型的核心是事件循环（Event Loop）。它是一种程序结构，用于等待和分发程序中发生的事件或消息。在传统的同步编程模型中，程序的执行流程是线性的，程序按照预定的顺序一步一步执行。而在事件驱动模型中，程序的执行流程由外部事件驱动，程序会不断地循环监听事件的发生，一旦事件发生，就调用相应的事件处理函数进行处理。
EventBase 作为 folly 库中事件驱动的核心组件，其最关键的机制就是事件循环。EventBase 对象本身就代表了一个事件循环实例。理解 EventBase 的事件循环是深入掌握其工作原理和高效应用的基础。
事件循环的基本工作流程如下：
- 初始化 (Initialization)：事件循环开始前，需要进行初始化操作，例如创建事件队列、设置事件监听器等。对于 EventBase 来说，创建 EventBase 对象的过程就包含了事件循环的初始化。
- 事件等待 (Event Waiting)：事件循环进入等待状态，等待新的事件发生。这个阶段通常会使用操作系统的 I/O 多路复用机制，例如
epoll(Linux)、kqueue(macOS, FreeBSD)、select或poll等，高效地监听多个文件描述符上的事件。EventBase 默认使用性能最佳的 I/O 多路复用机制，并提供了跨平台兼容性。 - 事件检测 (Event Detection)：当有事件发生时（例如文件描述符可读、定时器超时、信号到达等），操作系统会通知事件循环。事件循环从操作系统获取就绪的事件。
- 事件分发 (Event Dispatch)：事件循环根据事件类型，将事件分发到相应的事件处理器（EventHandler）。在 EventBase 中，事件处理器通常是用户自定义的回调函数或者继承自
EventHandler的类。 - 事件处理 (Event Handling)：事件处理器执行具体的事件处理逻辑。例如，对于文件描述符可读事件，事件处理器可能会读取数据；对于定时器事件，事件处理器可能会执行定时任务；对于信号事件，事件处理器可能会处理信号。
- 循环 (Loop)：事件处理完成后，事件循环再次回到事件等待状态，继续监听新的事件，如此循环往复，直到事件循环被显式地停止。
EventBase 的事件循环特点：
⚝ 单线程 (Single-threaded)：EventBase 的事件循环通常运行在单个线程中。这意味着所有的事件处理都在同一个线程中执行，避免了多线程同步的复杂性，简化了编程模型。当然，EventBase 也支持多线程模式，这将在后续章节中详细介绍。
⚝ 高效的 I/O 多路复用 (Efficient I/O Multiplexing)：EventBase 底层使用高效的 I/O 多路复用机制，能够同时监听大量的文件描述符，从而支持高并发的网络应用。
⚝ 非阻塞 I/O (Non-blocking I/O)：EventBase 配合非阻塞 I/O 操作，使得事件循环在等待事件时不会阻塞，可以持续处理事件，提高程序的响应速度和吞吐量。
⚝ 可扩展性 (Extensibility)：EventBase 提供了灵活的接口，允许用户注册各种类型的事件，包括文件描述符事件、定时器事件、信号事件以及自定义事件源，满足各种应用场景的需求。
代码示例 (伪代码)：
1
// 创建 EventBase 实例
2
EventBase evb;
3
4
// 注册文件描述符事件
5
auto socketEventHandler = [&](EventType events) {
6
// 处理 socket 事件，例如读写数据
7
};
8
evb.add(socketFd, EventType::Read | EventType::Write, socketEventHandler);
9
10
// 注册定时器事件
11
auto timerEventHandler = [&]() {
12
// 执行定时任务
13
};
14
evb.runAfterDelay(std::chrono::milliseconds(100), timerEventHandler);
15
16
// 启动事件循环
17
evb.loopForever();
总结：
事件循环是 EventBase 的核心，它负责监听和分发各种事件，驱动程序的执行。理解事件循环的工作原理是使用 EventBase 的关键。EventBase 通过高效的 I/O 多路复用机制和非阻塞 I/O 操作，实现了高性能的事件驱动编程模型。
2.2 事件注册与分发 (Event Registration and Dispatch)
EventBase 的核心功能之一就是事件注册（Event Registration）和事件分发（Event Dispatch）。这两个机制协同工作，使得 EventBase 能够有效地管理和处理各种类型的事件。
事件注册 (Event Registration)
事件注册是指将感兴趣的事件告知 EventBase，并关联相应的事件处理器（EventHandler）。当注册的事件发生时，EventBase 能够识别并调用相应的事件处理器进行处理。
EventBase 提供了多种方法来注册不同类型的事件，例如：
⚝ 文件描述符事件注册：使用 EventBase::add(fd, events, handler) 方法注册文件描述符事件。
▮▮▮▮⚝ fd：要监听的文件描述符。
▮▮▮▮⚝ events：感兴趣的事件类型，例如 EventType::Read (可读事件), EventType::Write (可写事件), EventType::ReadWrite (可读可写事件), EventType::Persist (持久事件), EventType::ET (边缘触发), EventType::SignalFd (信号文件描述符事件) 等。
▮▮▮▮⚝ handler：事件处理器，可以是函数对象 (function object), Lambda 表达式 (lambda expression), 或者继承自 EventHandler 的类实例。
⚝ 定时器事件注册：使用 EventBase::runAfterDelay(duration, callback) 或 EventBase::runAt(time_point, callback) 方法注册定时器事件。
▮▮▮▮⚝ duration：延迟时间，在指定延迟后触发定时器事件。
▮▮▮▮⚝ time_point：指定的时间点，在到达指定时间点时触发定时器事件。
▮▮▮▮⚝ callback：定时器事件处理器，通常是一个无参数的函数对象或 Lambda 表达式。
⚝ 信号事件注册：使用 EventBase::installSignalHandler(signal, handler) 方法注册信号事件。
▮▮▮▮⚝ signal：要监听的信号，例如 SIGINT, SIGTERM, SIGUSR1 等。
▮▮▮▮⚝ handler：信号事件处理器，通常是一个接受信号编号作为参数的函数对象或 Lambda 表达式。
事件分发 (Event Dispatch)
事件分发是指当事件循环检测到已注册的事件发生时，将事件传递给相应的事件处理器进行处理的过程。
EventBase 的事件分发机制主要由事件循环驱动。当事件循环在事件等待阶段被唤醒，并检测到有就绪的事件时，它会执行以下步骤进行事件分发：
- 事件类型识别 (Event Type Identification)：事件循环首先识别发生的事件类型，例如文件描述符事件、定时器事件、信号事件等。
- 查找事件处理器 (Handler Lookup)：根据事件类型和事件源（例如文件描述符、定时器 ID、信号编号），事件循环查找与之关联的事件处理器。EventBase 内部维护着事件注册表，用于快速查找事件处理器。
- 调用事件处理器 (Handler Invocation)：事件循环调用找到的事件处理器，并将事件相关的信息作为参数传递给事件处理器。例如，对于文件描述符事件，会将文件描述符和事件类型传递给处理器；对于信号事件，会将信号编号传递给处理器。
- 事件处理结果处理 (Handler Result Handling)：事件处理器执行事件处理逻辑后，可能会返回一些结果。EventBase 会根据事件处理器的返回值，决定是否需要继续监听该事件，或者取消事件监听。例如，对于非持久的文件描述符事件，事件处理器执行一次后，事件监听会自动取消。
代码示例 (文件描述符事件注册与分发)：
1
#include <folly/EventBase.h>
2
#include <sys/socket.h>
3
#include <netinet/in.h>
4
#include <iostream>
5
#include <unistd.h>
6
7
using namespace folly;
8
9
int main() {
10
EventBase evb;
11
int listenFd = socket(AF_INET, SOCK_STREAM, 0);
12
sockaddr_in addr;
13
addr.sin_family = AF_INET;
14
addr.sin_port = htons(8080);
15
addr.sin_addr.s_addr = INADDR_ANY;
16
bind(listenFd, (sockaddr*)&addr, sizeof(addr));
17
listen(listenFd, 10);
18
19
auto acceptHandler = [&](EventType events) {
20
if (events & EventType::Read) {
21
sockaddr_in clientAddr;
22
socklen_t clientAddrLen = sizeof(clientAddr);
23
int clientFd = accept(listenFd, (sockaddr*)&clientAddr, &clientAddrLen);
24
if (clientFd != -1) {
25
std::cout << "接受客户端连接: " << clientFd << std::endl;
26
// TODO: 注册 clientFd 的读写事件
27
} else {
28
perror("accept");
29
}
30
} else {
31
std::cerr << "listenFd unexpected event: " << static_cast<int>(events) << std::endl;
32
}
33
};
34
35
evb.add(listenFd, EventType::Read | EventType::Persist, acceptHandler);
36
37
std::cout << "服务器启动，监听端口 8080..." << std::endl;
38
evb.loopForever();
39
40
close(listenFd);
41
return 0;
42
}
代码解释：
⚝ 创建 EventBase 实例 evb。
⚝ 创建监听 socket listenFd，并绑定到 8080 端口。
⚝ 定义 Lambda 表达式 acceptHandler 作为 listenFd 的事件处理器。
▮▮▮▮⚝ 当 listenFd 可读时 ( EventType::Read )，表示有新的客户端连接请求到达。
▮▮▮▮⚝ 调用 accept() 接受客户端连接，并打印客户端文件描述符。
▮▮▮▮⚝ TODO: 这里可以进一步注册 clientFd 的读写事件，处理客户端的数据收发。
▮▮▮▮⚝ 如果发生其他事件 ( else 分支)，打印错误信息。
⚝ 使用 evb.add() 方法将 listenFd 注册到 EventBase 中，监听 EventType::Read 事件和 EventType::Persist 事件。EventType::Persist 表示该事件是持久的，即事件处理完成后，仍然继续监听该事件。
⚝ 调用 evb.loopForever() 启动事件循环。
总结：
事件注册和分发是 EventBase 实现事件驱动编程的关键机制。通过事件注册，用户可以将感兴趣的事件和事件处理器关联起来；通过事件分发，EventBase 能够高效地将发生的事件传递给相应的处理器进行处理。理解事件注册和分发机制，可以帮助我们更好地使用 EventBase 构建事件驱动的应用。
2.3 文件描述符事件 (File Descriptor Events)
文件描述符事件（File Descriptor Events）是 EventBase 最常用也是最重要的事件类型之一。在网络编程和 I/O 密集型应用中，文件描述符事件扮演着核心角色。EventBase 通过监听文件描述符上的状态变化（例如可读、可写、错误等），并触发相应的事件处理器，实现了高效的非阻塞 I/O 操作。
文件描述符 (File Descriptor)
在 Unix-like 系统中，文件描述符（File Descriptor, FD）是一个小的非负整数，用于访问文件或其他 I/O 资源，例如管道、socket 等。每个打开的文件或 I/O 资源都会被分配一个唯一的文件描述符。应用程序通过文件描述符与操作系统内核进行交互，执行读写等 I/O 操作。
文件描述符事件类型 (File Descriptor Event Types)
EventBase 支持监听以下文件描述符事件类型：
⚝ EventType::Read (可读事件)：当文件描述符可以进行非阻塞读取操作时触发。例如，对于 socket，当接收缓冲区中有数据可读时触发。
⚝ EventType::Write (可写事件)：当文件描述符可以进行非阻塞写入操作时触发。例如，对于 socket，当发送缓冲区有空间可写时触发。
⚝ EventType::ReadWrite (可读可写事件)：同时监听可读和可写事件。
⚝ EventType::Persist (持久事件)：表示事件是持久的，事件处理完成后，仍然继续监听该事件。默认情况下，文件描述符事件是非持久的，即事件处理一次后，监听会自动取消。
⚝ EventType::ET (边缘触发)：使用边缘触发模式监听事件。默认情况下，EventBase 使用水平触发模式。边缘触发模式和水平触发模式是 I/O 多路复用机制中两种不同的事件通知模式，具体区别将在后续深入分析章节中介绍。
⚝ EventType::SignalFd (信号文件描述符事件)：用于监听信号文件描述符上的事件。信号文件描述符是一种特殊的文件描述符，可以用于接收信号。
文件描述符事件注册与处理 (File Descriptor Event Registration and Handling)
使用 EventBase::add(fd, events, handler) 方法注册文件描述符事件。其中 fd 是要监听的文件描述符，events 是感兴趣的事件类型，handler 是事件处理器。
事件处理器通常是一个 Lambda 表达式或函数对象，接受一个 EventType 参数，表示实际发生的事件类型。在事件处理器中，可以根据事件类型执行相应的 I/O 操作，例如读取数据、写入数据、处理错误等。
代码示例 (TCP 客户端)：
1
#include <folly/EventBase.h>
2
#include <sys/socket.h>
3
#include <netinet/in.h>
4
#include <arpa/inet.h>
5
#include <iostream>
6
#include <unistd.h>
7
#include <string>
8
9
using namespace folly;
10
11
int main() {
12
EventBase evb;
13
int clientFd = socket(AF_INET, SOCK_STREAM, 0);
14
sockaddr_in serverAddr;
15
serverAddr.sin_family = AF_INET;
16
serverAddr.sin_port = htons(8080);
17
inet_pton(AF_INET, "127.0.0.1", &serverAddr.sin_addr);
18
19
connect(clientFd, (sockaddr*)&serverAddr, sizeof(serverAddr));
20
21
auto readHandler = [&](EventType events) {
22
if (events & EventType::Read) {
23
char buffer[1024];
24
ssize_t bytesRead = recv(clientFd, buffer, sizeof(buffer), 0);
25
if (bytesRead > 0) {
26
std::cout << "接收到服务器数据: " << std::string(buffer, bytesRead) << std::endl;
27
} else if (bytesRead == 0) {
28
std::cout << "服务器关闭连接" << std::endl;
29
evb.remove(clientFd); // 移除事件监听
30
close(clientFd);
31
} else {
32
perror("recv");
33
evb.remove(clientFd);
34
close(clientFd);
35
}
36
} else {
37
std::cerr << "clientFd unexpected event: " << static_cast<int>(events) << std::endl;
38
}
39
};
40
41
evb.add(clientFd, EventType::Read | EventType::Persist, readHandler);
42
43
std::cout << "客户端已连接到服务器，等待接收数据..." << std::endl;
44
evb.loopForever();
45
46
return 0;
47
}
代码解释：
⚝ 创建 EventBase 实例 evb。
⚝ 创建客户端 socket clientFd，并连接到本地 8080 端口的服务器。
⚝ 定义 Lambda 表达式 readHandler 作为 clientFd 的读事件处理器。
▮▮▮▮⚝ 当 clientFd 可读时 ( EventType::Read )，表示服务器有数据发送过来。
▮▮▮▮⚝ 调用 recv() 函数接收数据。
▮▮▮▮⚝ 如果 recv() 返回值大于 0，表示成功接收到数据，打印接收到的数据。
▮▮▮▮⚝ 如果 recv() 返回值等于 0，表示服务器关闭连接，移除 clientFd 的事件监听，并关闭 clientFd。
▮▮▮▮⚝ 如果 recv() 返回值小于 0，表示发生错误，打印错误信息，移除 clientFd 的事件监听，并关闭 clientFd。
▮▮▮▮⚝ 如果发生其他事件 ( else 分支)，打印错误信息。
⚝ 使用 evb.add() 方法将 clientFd 注册到 EventBase 中，监听 EventType::Read 事件和 EventType::Persist 事件。
⚝ 调用 evb.loopForever() 启动事件循环。
总结：
文件描述符事件是 EventBase 中最核心的事件类型，用于处理各种 I/O 操作。通过监听文件描述符事件，EventBase 可以实现高效的非阻塞 I/O，构建高性能的网络应用和 I/O 密集型应用。理解文件描述符事件的类型、注册和处理方式，是深入掌握 EventBase 的关键。
2.4 定时器事件 (Timer Events)
定时器事件（Timer Events）是 EventBase 提供的另一种重要的事件类型。定时器事件允许程序在指定的时间点或延迟后执行特定的任务，常用于实现定时任务、超时处理、心跳检测等功能。
定时器事件的类型 (Timer Event Types)
EventBase 提供了两种主要的定时器事件注册方式：
⚝ 延迟定时器 (Delay Timer)：在指定的延迟时间后触发一次定时器事件。使用 EventBase::runAfterDelay(duration, callback) 方法注册延迟定时器。
▮▮▮▮⚝ duration：延迟时间，类型为 std::chrono::duration，例如 std::chrono::milliseconds(100) 表示 100 毫秒。
▮▮▮▮⚝ callback：定时器事件处理器，通常是一个无参数的函数对象或 Lambda 表达式。
⚝ 定时点定时器 (Time Point Timer)：在指定的时间点触发一次定时器事件。使用 EventBase::runAt(time_point, callback) 方法注册定时点定时器。
▮▮▮▮⚝ time_point：指定的时间点，类型为 std::chrono::time_point，例如 std::chrono::system_clock::now() + std::chrono::seconds(1) 表示 1 秒后的时间点。
▮▮▮▮⚝ callback：定时器事件处理器，与延迟定时器相同。
定时器事件的精度 (Timer Event Precision)
EventBase 的定时器事件精度取决于操作系统和底层 I/O 多路复用机制的精度。通常情况下，定时器事件的精度可以达到毫秒级别，甚至更高。但是，由于系统调度和负载等因素的影响，实际的定时器触发时间可能会有一定的偏差。对于对时间精度要求非常高的应用，需要进行更精细的考量和测试。
定时器事件的取消 (Timer Event Cancellation)
延迟定时器和定时点定时器都是一次性事件，触发一次后会自动取消。如果需要在定时器事件触发前手动取消定时器，可以使用 EventBase::cancelTimeout(timeoutToken) 方法。runAfterDelay() 和 runAt() 方法会返回一个 TimeoutToken 对象，用于标识注册的定时器事件。
代码示例 (定时器示例)：
1
#include <folly/EventBase.h>
2
#include <iostream>
3
#include <chrono>
4
5
using namespace folly;
6
7
int main() {
8
EventBase evb;
9
10
// 延迟定时器示例： 1 秒后执行
11
auto delayTimerCallback = [&]() {
12
std::cout << "延迟定时器触发，当前时间: " << std::chrono::system_clock::now() << std::endl;
13
};
14
evb.runAfterDelay(std::chrono::seconds(1), delayTimerCallback);
15
16
// 定时点定时器示例： 3 秒后执行
17
auto timePointTimerCallback = [&]() {
18
std::cout << "定时点定时器触发，当前时间: " << std::chrono::system_clock::now() << std::endl;
19
};
20
auto timePoint = std::chrono::system_clock::now() + std::chrono::seconds(3);
21
evb.runAt(timePoint, timePointTimerCallback);
22
23
// 取消延迟定时器示例 (假设在 0.5 秒后取消)
24
auto cancelTimerCallback = [&]() {
25
std::cout << "延迟定时器 (将被取消) 触发，当前时间: " << std::chrono::system_clock::now() << std::endl;
26
};
27
auto timeoutToken = evb.runAfterDelay(std::chrono::seconds(2), cancelTimerCallback);
28
evb.runAfterDelay(std::chrono::milliseconds(500), [&]() {
29
evb.cancelTimeout(timeoutToken);
30
std::cout << "延迟定时器已取消" << std::endl;
31
});
32
33
34
std::cout << "启动事件循环，等待定时器事件触发..." << std::endl;
35
evb.loopForever();
36
37
return 0;
38
}
代码解释：
⚝ 创建 EventBase 实例 evb。
⚝ 使用 evb.runAfterDelay() 注册一个延迟定时器，延迟 1 秒后触发 delayTimerCallback。
⚝ 使用 evb.runAt() 注册一个定时点定时器，在 3 秒后的时间点触发 timePointTimerCallback。
⚝ 使用 evb.runAfterDelay() 注册一个延迟定时器，延迟 2 秒后触发 cancelTimerCallback，并获取返回的 TimeoutToken。
⚝ 使用 evb.runAfterDelay() 注册另一个延迟定时器，延迟 0.5 秒后执行取消操作，调用 evb.cancelTimeout(timeoutToken) 取消之前注册的延迟定时器。
⚝ 调用 evb.loopForever() 启动事件循环。
总结：
定时器事件是 EventBase 中用于处理时间相关任务的重要事件类型。通过延迟定时器和定时点定时器，可以方便地实现各种定时任务和超时处理逻辑。理解定时器事件的注册、精度和取消方式，可以帮助我们更好地利用 EventBase 构建时间敏感的应用。
2.5 信号事件 (Signal Events)
信号事件（Signal Events）是 EventBase 提供的用于处理系统信号的事件类型。在 Unix-like 系统中，信号（Signal）是操作系统用于通知进程发生了某些事件的一种机制，例如用户按下 Ctrl+C ( SIGINT 信号), 进程接收到终止信号 ( SIGTERM 信号) 等。EventBase 允许程序注册信号事件处理器，当指定的信号到达时，EventBase 会调用相应的处理器进行处理。
信号 (Signal)
常见的信号包括：
⚝ SIGINT: 中断信号，通常由用户按下 Ctrl+C 产生。
⚝ SIGTERM: 终止信号，通常由 kill 命令发送，请求进程正常终止。
⚝ SIGKILL: 强制终止信号，通常由 kill -9 命令发送，强制进程立即终止，无法被捕获或忽略。
⚝ SIGUSR1, SIGUSR2: 用户自定义信号，可以用于进程间通信或自定义事件通知。
⚝ SIGHUP: 挂起信号，通常在终端连接断开时发送，用于通知进程重新加载配置文件或重新启动。
信号事件注册与处理 (Signal Event Registration and Handling)
使用 EventBase::installSignalHandler(signal, handler) 方法注册信号事件。
⚝ signal：要监听的信号，例如 SIGINT, SIGTERM, SIGUSR1 等。可以使用 SIG_DFL (默认处理) 或 SIG_IGN (忽略信号) 作为特殊的处理器。
⚝ handler：信号事件处理器，通常是一个接受信号编号 int 作为参数的函数对象或 Lambda 表达式。
信号处理的注意事项 (Signal Handling Considerations)
⚝ 信号处理函数限制：在信号处理函数中，可以执行的操作受到限制。为了保证信号处理的可靠性和效率，信号处理函数应该是可重入的（reentrant）和异步信号安全的（async-signal-safe）。这意味着信号处理函数中应该避免调用可能导致阻塞或死锁的函数，例如 malloc, printf, mutex lock 等。可以使用 write, _exit, signal 等异步信号安全的函数。
⚝ 信号屏蔽 (Signal Masking)：在多线程程序中，需要注意信号屏蔽的问题。默认情况下，新创建的线程会继承父线程的信号屏蔽设置。可以使用 pthread_sigmask 函数来设置线程的信号屏蔽。EventBase 内部会处理信号屏蔽，确保信号事件在正确的线程中被处理。
⚝ SIGKILL 信号：SIGKILL 信号是无法被捕获或忽略的，因此无法为 SIGKILL 信号注册信号事件处理器。
代码示例 (信号处理示例)：
1
#include <folly/EventBase.h>
2
#include <iostream>
3
#include <csignal>
4
#include <unistd.h>
5
6
using namespace folly;
7
8
int main() {
9
EventBase evb;
10
bool running = true;
11
12
auto sigIntHandler = [&](int sig) {
13
std::cout << "接收到 SIGINT 信号 (" << sig << ")，程序即将退出..." << std::endl;
14
running = false;
15
evb.terminateLoopSoon(); // 安全终止事件循环
16
};
17
18
auto sigUsr1Handler = [&](int sig) {
19
std::cout << "接收到 SIGUSR1 信号 (" << sig << ")，执行自定义操作..." << std::endl;
20
// TODO: 执行自定义操作
21
};
22
23
evb.installSignalHandler(SIGINT, sigIntHandler);
24
evb.installSignalHandler(SIGUSR1, sigUsr1Handler);
25
26
std::cout << "程序启动，等待信号..." << std::endl;
27
while (running) {
28
evb.loopOnce(); // 使用 loopOnce() 避免 loopForever() 无法终止
29
sleep(1); // 模拟程序主循环的其他工作
30
}
31
32
std::cout << "程序退出" << std::endl;
33
return 0;
34
}
代码解释：
⚝ 创建 EventBase 实例 evb。
⚝ 定义布尔变量 running 控制程序主循环。
⚝ 定义 Lambda 表达式 sigIntHandler 作为 SIGINT 信号的处理器。
▮▮▮▮⚝ 当接收到 SIGINT 信号时，打印信息，设置 running 为 false，并调用 evb.terminateLoopSoon() 安全终止事件循环。terminateLoopSoon() 会在当前事件循环迭代完成后安全退出循环。
⚝ 定义 Lambda 表达式 sigUsr1Handler 作为 SIGUSR1 信号的处理器。
▮▮▮▮⚝ 当接收到 SIGUSR1 信号时，打印信息，并预留 TODO 位置执行自定义操作。
⚝ 使用 evb.installSignalHandler() 方法注册 SIGINT 和 SIGUSR1 信号的处理器。
⚝ 进入 while (running) 循环，模拟程序主循环的其他工作。
▮▮▮▮⚝ 在循环中使用 evb.loopOnce() 而不是 evb.loopForever()，以便在接收到 SIGINT 信号后能够安全退出循环。loopOnce() 执行一次事件循环迭代后返回。
▮▮▮▮⚝ 使用 sleep(1) 模拟程序主循环的其他工作。
总结：
信号事件是 EventBase 中用于处理系统信号的重要事件类型。通过注册信号事件处理器，程序可以响应各种系统信号，例如优雅地处理终止信号、重新加载配置信号等。理解信号事件的注册、处理和注意事项，可以帮助我们构建更加健壮和可靠的应用程序。
END_OF_CHAPTER
3. chapter 3： EventBase 实战代码 (Practical Code of EventBase)
3.1 基于 EventBase 的简单 TCP 服务器 (Simple TCP Server based on EventBase)
在本章中，我们将深入探讨 EventBase 的实战应用。理论知识固然重要，但真正的理解往往来自于实践。本节，我们将从构建一个简单的 TCP 服务器入手，逐步展示如何使用 EventBase 处理网络事件，并最终构建一个功能完善、性能高效的服务器应用。通过本节的学习，你将能够掌握 EventBase 在网络编程中的基本用法，为后续更复杂的应用场景打下坚实的基础。
首先，让我们从事件驱动编程模型在网络服务器中的应用开始讲起。传统的阻塞式 I/O 模型在处理高并发连接时效率低下，而事件驱动模型则通过非阻塞 I/O 和事件循环机制，能够高效地处理大量并发连接，成为现代网络服务器的主流选择。EventBase 正是构建事件驱动型网络应用的核心组件。
3.1.1 TCP 服务器的工作原理 (Working Principle of TCP Server)
在深入代码之前，我们先简要回顾一下 TCP 服务器的基本工作原理。一个 TCP 服务器主要完成以下几个步骤：
① 创建 socket (Create socket)：服务器首先需要创建一个 socket 文件描述符（file descriptor），作为网络通信的端点。
② 绑定地址和端口 (Bind address and port)：将创建的 socket 绑定到服务器的 IP 地址和端口号上，这样客户端才能找到服务器。
③ 监听连接 (Listen for connections)：服务器开始监听指定端口上的连接请求。
④ 接受连接 (Accept connections)：当有客户端发起连接请求时，服务器接受连接，并创建一个新的 socket 文件描述符用于与该客户端进行通信。
⑤ 数据收发 (Send and receive data)：服务器通过新创建的 socket 与客户端进行数据收发。
⑥ 关闭连接 (Close connection)：通信结束后，服务器关闭与客户端的连接。
在传统的阻塞式 I/O 模型中，accept()、recv()、send() 等操作都是阻塞的，即在操作完成之前，程序会一直等待，无法执行其他任务。这在高并发场景下会严重降低服务器的性能。而 EventBase 的核心价值在于将这些阻塞操作转化为非阻塞事件，通过事件循环和事件分发机制，实现高效的并发处理。
3.1.2 使用 EventBase 构建 TCP 服务器的基本框架 (Basic Framework of TCP Server using EventBase)
接下来，我们来看一下如何使用 EventBase 构建一个简单的 TCP 服务器的基本框架。以下代码展示了一个最基本的 TCP 服务器的骨架，它只负责监听端口，接受客户端连接，并简单地打印连接信息。
1
#include <folly/io/async/EventBase.h>
2
#include <folly/io/async/AsyncServerSocket.h>
3
#include <folly/SocketAddress.h>
4
#include <iostream>
5
6
using namespace folly;
7
using namespace std;
8
9
int main() {
10
EventBase evb; // ① 创建 EventBase 实例 (Create EventBase instance)
11
AsyncServerSocket serverSocket(&evb); // ② 创建 AsyncServerSocket (Create AsyncServerSocket)
12
13
// ③ 设置监听地址 (Set listening address)
14
SocketAddress listenAddress;
15
listenAddress.setFromLocalPort(8080); // 监听 8080 端口 (Listen on port 8080)
16
17
// ④ 绑定地址并开始监听 (Bind address and start listening)
18
serverSocket.bind(listenAddress);
19
serverSocket.listen(1024); // 设置最大连接队列长度 (Set maximum connection queue length)
20
21
// ⑤ 设置连接接受回调 (Set connection accept callback)
22
serverSocket.setAcceptCallback([&](
23
NetworkSocket fd,
24
const SocketAddress& peerAddress,
25
AcceptCallback::AcceptError error) {
26
if (error == AcceptCallback::AcceptError::NONE) {
27
cout << "接受到来自 " << peerAddress.getAddressStr() << " 的连接" << endl; // 打印连接信息 (Print connection information)
28
// TODO: 处理新的连接 (Handle new connection)
29
NetworkSocket::close(fd); // 简单关闭连接 (Simply close the connection)
30
} else {
31
cerr << "接受连接错误: " << (int)error << endl; // 打印错误信息 (Print error information)
32
}
33
});
34
35
cout << "服务器已启动，监听端口 8080..." << endl; // 打印服务器启动信息 (Print server startup information)
36
evb.loopForever(); // ⑥ 启动事件循环 (Start event loop)
37
38
return 0;
39
}
代码解析 (Code Explanation):
① EventBase evb;： 创建 EventBase 实例。EventBase 是 folly/EventBase.h 中最核心的类，它是事件循环的容器和驱动器。所有的事件注册、分发和处理都由 EventBase 实例管理。
② AsyncServerSocket serverSocket(&evb);： 创建 AsyncServerSocket 实例。AsyncServerSocket 是 folly 库提供的用于异步 TCP 服务器 socket 操作的类，它封装了底层的 socket 创建、绑定、监听和接受连接等操作，并与 EventBase 集成，实现非阻塞的连接接受。构造函数需要传入一个 EventBase 实例的指针，将 AsyncServerSocket 绑定到指定的事件循环中。
③ SocketAddress listenAddress; listenAddress.setFromLocalPort(8080);： 设置服务器监听的地址和端口。SocketAddress 类用于表示网络地址，setFromLocalPort(8080) 表示监听本地的 8080 端口。
④ serverSocket.bind(listenAddress); serverSocket.listen(1024);： 绑定地址和开始监听。bind() 方法将 AsyncServerSocket 绑定到指定的地址，listen(1024) 方法开始监听连接，参数 1024 表示最大连接队列长度。
⑤ serverSocket.setAcceptCallback([&](...) { ... });： 设置连接接受回调函数。setAcceptCallback() 方法用于注册一个回调函数，当有新的客户端连接请求到达时，EventBase 会调用这个回调函数。回调函数的参数包括：
▮▮▮▮⚝ NetworkSocket fd：新连接的 socket 文件描述符。
▮▮▮▮⚝ const SocketAddress& peerAddress：客户端的地址信息。
▮▮▮▮⚝ AcceptCallback::AcceptError error：接受连接过程中发生的错误，NONE 表示没有错误。
1
在回调函数中，我们简单地打印了客户端的地址信息，并使用 `NetworkSocket::close(fd)` 关闭了连接。在实际应用中，这里需要进行更复杂的处理，例如创建新的 `AsyncSocket` 对象来处理与客户端的通信。
⑥ evb.loopForever();： 启动事件循环。loopForever() 方法使 EventBase 进入事件循环，开始监听和处理各种事件，包括网络事件、定时器事件、信号事件等。事件循环会一直运行，直到程序退出。
编译和运行 (Compilation and Running):
要编译和运行上述代码，你需要确保已经安装了 folly 库及其依赖项，并使用支持 C++17 或更高版本的编译器。编译命令示例如下（假设你已经配置好了 folly 的编译环境）：
1
g++ -std=c++17 simple_tcp_server.cpp -o simple_tcp_server -lfolly -lglog -lgflags -lssl -lcrypto -lz
编译成功后，运行可执行文件 simple_tcp_server，服务器就会在 8080 端口启动并监听连接。你可以使用 telnet 或其他网络工具连接到 localhost:8080 来测试服务器。
1
./simple_tcp_server
2
服务器已启动，监听端口 8080...
在另一个终端窗口中使用 telnet 连接：
1
telnet localhost 8080
2
Trying ::1...
3
Connected to localhost.
4
Escape character is '^]'.
5
Connection closed by foreign host.
在服务器端，你将会看到类似以下的输出，表明服务器成功接受了客户端的连接：
1
接受到来自 127.0.0.1 的连接
这个简单的例子展示了使用 EventBase 构建 TCP 服务器的基本流程。在接下来的章节中，我们将逐步完善这个服务器，添加处理客户端连接、数据收发和超时管理等功能。
3.2 处理客户端连接 (Handling Client Connections)
上一节，我们创建了一个简单的 TCP 服务器，它可以接受客户端连接，但仅仅是打印连接信息并立即关闭连接。在实际应用中，我们需要处理客户端连接，与客户端进行数据交互。本节，我们将深入探讨如何使用 EventBase 处理客户端连接，并为后续的数据收发和事件处理打下基础。
3.2.1 AsyncSocket 类 (AsyncSocket Class)
AsyncSocket 是 folly/io/async/AsyncSocket.h 中提供的核心类，用于处理客户端 socket 的异步 I/O 操作。与 AsyncServerSocket 用于监听和接受连接不同，AsyncSocket 用于与已连接的客户端进行数据收发。当我们通过 AsyncServerSocket 接受一个新的客户端连接时，通常会创建一个 AsyncSocket 对象来代表这个客户端连接，并使用 EventBase 监听其读写事件。
3.2.2 接受连接后创建 AsyncSocket (Creating AsyncSocket after Accepting Connection)
在 AsyncServerSocket 的 acceptCallback 中，当我们接受一个新的连接时，需要创建一个 AsyncSocket 对象来处理这个连接。修改上一节的代码，将连接处理逻辑添加到 acceptCallback 中：
1
#include <folly/io/async/EventBase.h>
2
#include <folly/io/async/AsyncServerSocket.h>
3
#include <folly/io/async/AsyncSocket.h> // 引入 AsyncSocket 头文件 (Include AsyncSocket header file)
4
#include <folly/SocketAddress.h>
5
#include <iostream>
6
#include <memory> // 引入 std::shared_ptr (Include std::shared_ptr)
7
8
using namespace folly;
9
using namespace std;
10
11
int main() {
12
EventBase evb;
13
AsyncServerSocket serverSocket(&evb);
14
15
SocketAddress listenAddress;
16
listenAddress.setFromLocalPort(8080);
17
18
serverSocket.bind(listenAddress);
19
serverSocket.listen(1024);
20
21
serverSocket.setAcceptCallback([&](
22
NetworkSocket fd,
23
const SocketAddress& peerAddress,
24
AcceptCallback::AcceptError error) {
25
if (error == AcceptCallback::AcceptError::NONE) {
26
cout << "接受到来自 " << peerAddress.getAddressStr() << " 的连接" << endl;
27
// ① 创建 AsyncSocket 对象 (Create AsyncSocket object)
28
std::shared_ptr<AsyncSocket> clientSocket = std::make_shared<AsyncSocket>(&evb, fd);
29
// TODO: 设置 clientSocket 的读写事件处理 (Set read/write event handling for clientSocket)
30
31
// 注意：这里不再关闭 fd，AsyncSocket 会管理 fd 的生命周期 (Note: Do not close fd here, AsyncSocket will manage fd's lifecycle)
32
// NetworkSocket::close(fd); // 删除此行 (Remove this line)
33
} else {
34
cerr << "接受连接错误: " << (int)error << endl;
35
}
36
});
37
38
cout << "服务器已启动，监听端口 8080..." << endl;
39
evb.loopForever();
40
41
return 0;
42
}
代码修改说明 (Code Modification Explanation):
① std::shared_ptr<AsyncSocket> clientSocket = std::make_shared<AsyncSocket>(&evb, fd);： 在 acceptCallback 中，我们使用 std::make_shared 创建了一个 AsyncSocket 对象的智能指针 clientSocket。AsyncSocket 的构造函数接受两个参数：EventBase 实例的指针和新连接的 socket 文件描述符 fd。使用智能指针可以方便地管理 AsyncSocket 对象的生命周期，避免内存泄漏。
重要提示 (Important Note):
在创建 AsyncSocket 对象后，我们不再需要手动关闭 socket 文件描述符 fd。AsyncSocket 对象会接管 fd 的所有权，并在 AsyncSocket 对象销毁时自动关闭 fd。如果在 acceptCallback 中手动关闭 fd，会导致 AsyncSocket 对象操作无效的文件描述符，引发错误。
3.2.3 设置 AsyncSocket 的事件处理回调 (Setting Event Handling Callbacks for AsyncSocket)
创建 AsyncSocket 对象后，我们需要为其设置事件处理回调函数，以便在 socket 上发生读写事件时得到通知。AsyncSocket 提供了多种回调函数用于处理不同的事件，常用的包括：
⚝ setReadCB(ReadCallback* cb)：设置读事件回调函数。当 socket 可读时，EventBase 会调用 ReadCallback 接口的方法。
⚝ setWriteCB(WriteCallback* cb)：设置写事件回调函数。当 socket 可写时，EventBase 会调用 WriteCallback 接口的方法。
⚝ setCloseCallback(CloseCallback* cb)：设置连接关闭回调函数。当连接关闭时（包括客户端主动关闭、服务器主动关闭或发生错误导致连接断开），EventBase 会调用 CloseCallback 接口的方法。
⚝ setErrorCallback(ErrorCallback* cb)：设置错误事件回调函数。当 socket 发生错误时，EventBase 会调用 ErrorCallback 接口的方法。
这些回调接口都是抽象类，我们需要创建具体的类来实现这些接口，并将其对象设置给 AsyncSocket。
3.2.4 实现 ReadCallback 接口处理读事件 (Implementing ReadCallback Interface to Handle Read Events)
为了处理客户端发送的数据，我们需要实现 ReadCallback 接口。ReadCallback 接口定义了以下方法：
⚝ void getReadBuffer(void** bufReturn, size_t* lenReturn)： 此方法由 EventBase 调用，用于获取读缓冲区。我们需要在此方法中设置读缓冲区的起始地址 bufReturn 和大小 lenReturn。
⚝ void readDataAvailable(size_t len)： 此方法由 EventBase 调用，表示有 len 字节的数据可读。我们可以在此方法中从读缓冲区读取数据并进行处理。
⚝ void readEOF()： 此方法由 EventBase 调用，表示连接已关闭（客户端发送了 FIN 包）。
⚝ void readErr(const AsyncSocketException& ex)： 此方法由 EventBase 调用，表示读取数据时发生错误。
下面是一个简单的 ReadCallback 实现示例，它将接收到的数据打印到控制台：
1
#include <folly/io/async/ReadCallback.h>
2
#include <folly/io/IOBuf.h>
3
#include <iostream>
4
5
using namespace folly;
6
using namespace std;
7
8
class EchoReadCallback : public ReadCallback {
9
public:
10
explicit EchoReadCallback(std::shared_ptr<AsyncSocket> sock) : sock_(sock) {}
11
12
void getReadBuffer(void** bufReturn, size_t* lenReturn) override {
13
// 分配 8KB 读缓冲区 (Allocate 8KB read buffer)
14
*bufReturn = readBuffer_.writableData();
15
*lenReturn = readBuffer_.capacity();
16
}
17
18
void readDataAvailable(size_t len) override {
19
// 处理接收到的数据 (Process received data)
20
readBuffer_.append(len);
21
cout << "接收到数据: " << readBuffer_.coalesce() << endl; // 打印接收到的数据 (Print received data)
22
readBuffer_.clear(); // 清空读缓冲区 (Clear read buffer)
23
24
// TODO: 回复客户端 (Reply to client)
25
}
26
27
void readEOF() override {
28
cout << "客户端关闭连接" << endl; // 打印客户端关闭连接信息 (Print client connection closed information)
29
sock_->close(); // 关闭 socket (Close socket)
30
}
31
32
void readErr(const AsyncSocketException& ex) override {
33
cerr << "读取数据错误: " << ex.what() << endl; // 打印读取数据错误信息 (Print read data error information)
34
sock_->close(); // 关闭 socket (Close socket)
35
}
36
37
private:
38
std::shared_ptr<AsyncSocket> sock_;
39
IOBuf readBuffer_{IOBuf::CREATE, 8192}; // 8KB 读缓冲区 (8KB read buffer)
40
};
代码解析 (Code Explanation):
⚝ EchoReadCallback 类继承自 ReadCallback 抽象类。
⚝ 构造函数接受一个 std::shared_ptr<AsyncSocket> 对象，用于在回调函数中操作 AsyncSocket。
⚝ getReadBuffer() 方法分配一个 8KB 的 IOBuf 作为读缓冲区。IOBuf 是 folly 库提供的用于高效 I/O 操作的缓冲区类。
⚝ readDataAvailable() 方法在有数据可读时被调用。它将读取到的数据追加到 readBuffer_ 中，然后打印接收到的数据，并清空 readBuffer_ 以准备接收下一次数据。
⚝ readEOF() 方法在客户端关闭连接时被调用，它打印连接关闭信息并关闭 AsyncSocket。
⚝ readErr() 方法在读取数据发生错误时被调用，它打印错误信息并关闭 AsyncSocket。
3.2.5 将 ReadCallback 设置给 AsyncSocket (Setting ReadCallback to AsyncSocket)
现在，我们需要在 acceptCallback 中创建 EchoReadCallback 对象，并将其设置为 AsyncSocket 的读事件回调：
1
// ... (之前的代码) ...
2
#include "EchoReadCallback.h" // 引入 EchoReadCallback 头文件 (Include EchoReadCallback header file)
3
4
serverSocket.setAcceptCallback([&](
5
NetworkSocket fd,
6
const SocketAddress& peerAddress,
7
AcceptCallback::AcceptError error) {
8
if (error == AcceptCallback::AcceptError::NONE) {
9
cout << "接受到来自 " << peerAddress.getAddressStr() << " 的连接" << endl;
10
std::shared_ptr<AsyncSocket> clientSocket = std::make_shared<AsyncSocket>(&evb, fd);
11
// ① 创建 EchoReadCallback 对象 (Create EchoReadCallback object)
12
std::shared_ptr<EchoReadCallback> readCallback = std::make_shared<EchoReadCallback>(clientSocket);
13
// ② 设置读事件回调 (Set read event callback)
14
clientSocket->setReadCB(readCallback.get());
15
} else {
16
cerr << "接受连接错误: " << (int)error << endl;
17
}
18
});
19
// ... (后续代码) ...
代码修改说明 (Code Modification Explanation):
① std::shared_ptr<EchoReadCallback> readCallback = std::make_shared<EchoReadCallback>(clientSocket);： 在 acceptCallback 中，我们创建了一个 EchoReadCallback 对象的智能指针 readCallback，并将之前创建的 clientSocket 传递给 EchoReadCallback 的构造函数。
② clientSocket->setReadCB(readCallback.get());： 使用 clientSocket->setReadCB() 方法将 readCallback 对象设置为 clientSocket 的读事件回调。注意，这里传递的是 readCallback.get()，即原始指针，因为 AsyncSocket::setReadCB() 接受的是原始指针。AsyncSocket 不会管理 ReadCallback 对象的生命周期，我们需要确保 ReadCallback 对象在 AsyncSocket 对象生命周期内有效。在本例中，由于 readCallback 是一个局部变量，当 acceptCallback 返回后，readCallback 对象会被销毁，这将导致程序出错。为了解决这个问题，我们需要将 readCallback 对象保存在一个更长生命周期的地方，例如 AsyncSocket 对象本身，或者使用其他生命周期管理策略。为了简化示例，我们暂时忽略这个问题，在后续章节中会讨论更完善的生命周期管理方案。
编译和运行 (Compilation and Running):
编译并运行修改后的代码。使用 telnet 连接到服务器，并发送一些数据，你将在服务器端看到接收到的数据被打印出来。
1
g++ -std=c++17 simple_tcp_server.cpp EchoReadCallback.cpp -o simple_tcp_server -lfolly -lglog -lgflags -lssl -lcrypto -lz
2
./simple_tcp_server
3
服务器已启动，监听端口 8080...
在另一个终端窗口中使用 telnet 连接并发送数据：
1
telnet localhost 8080
2
Trying ::1...
3
Connected to localhost.
4
Escape character is '^]'.
5
Hello, EventBase!
6
接收到数据: Hello, EventBase!
服务器端输出：
1
接受到来自 127.0.0.1 的连接
2
接收到数据: Hello, EventBase!
至此，我们已经成功地让服务器能够接受客户端连接，并接收客户端发送的数据。下一步，我们将学习如何向客户端发送数据，并完善事件处理逻辑。
3.3 数据收发与事件处理 (Data Sending and Receiving and Event Handling)
在上一节，我们实现了接收客户端数据的基本功能。本节，我们将进一步完善服务器，使其能够向客户端发送数据，并处理更全面的事件，例如写事件和连接关闭事件。通过本节的学习，你将掌握 EventBase 在数据收发和事件处理方面的核心用法。
3.3.1 发送数据 (Sending Data)
AsyncSocket 提供了 write(std::unique_ptr<IOBuf> buf) 方法用于发送数据。我们需要将要发送的数据封装成 IOBuf 对象，然后调用 write() 方法。write() 方法是非阻塞的，它会将数据写入 socket 的发送缓冲区，并立即返回。当 socket 可写时，EventBase 会将缓冲区中的数据发送出去。
为了实现简单的回显服务器，我们需要在 EchoReadCallback::readDataAvailable() 方法中，将接收到的数据原样发送回客户端。修改 EchoReadCallback::readDataAvailable() 方法如下：
1
void readDataAvailable(size_t len) override {
2
readBuffer_.append(len);
3
cout << "接收到数据: " << readBuffer_.coalesce() << endl;
4
5
// ① 创建 IOBuf 对象，封装要发送的数据 (Create IOBuf object to encapsulate data to be sent)
6
std::unique_ptr<IOBuf> writeBuf = IOBuf::copyBuffer(readBuffer_.coalesce());
7
// ② 发送数据 (Send data)
8
sock_->write(std::move(writeBuf));
9
10
readBuffer_.clear();
11
}
代码修改说明 (Code Modification Explanation):
① std::unique_ptr<IOBuf> writeBuf = IOBuf::copyBuffer(readBuffer_.coalesce());： 使用 IOBuf::copyBuffer() 方法将接收到的数据（readBuffer_.coalesce() 返回一个 ByteRange 对象，表示 readBuffer_ 中的所有数据）复制到一个新的 IOBuf 对象 writeBuf 中。IOBuf::copyBuffer() 会创建一个新的 IOBuf 对象，并将数据复制到新的缓冲区中。我们使用 std::unique_ptr 来管理 writeBuf 的生命周期。
② sock_->write(std::move(writeBuf));： 调用 sock_->write() 方法发送数据。std::move(writeBuf) 将 writeBuf 的所有权转移给 write() 方法，write() 方法会在内部管理 writeBuf 的生命周期。
3.3.2 处理写事件 (Handling Write Events)
AsyncSocket 提供了 setWriteCB(WriteCallback* cb) 方法用于设置写事件回调。WriteCallback 接口定义了以下方法：
⚝ void writeSuccess()： 此方法由 EventBase 调用，表示上次 write() 操作的数据已经成功发送到网络。
⚝ void writeErr(const AsyncSocketException& ex)： 此方法由 EventBase 调用，表示 write() 操作发生错误。
在简单的回显服务器中，我们不需要特别处理写事件，因为 write() 操作通常不会立即阻塞，数据会先被写入发送缓冲区，然后由操作系统异步发送。但是，在某些情况下，例如发送大量数据时，发送缓冲区可能会满，write() 操作可能会阻塞或返回错误。为了更健壮地处理写事件，我们可以实现 WriteCallback 接口，并在 writeSuccess() 回调中检查是否还有数据需要发送，或者在 writeErr() 回调中处理写错误。
对于本例中的简单回显服务器，我们暂时不需要实现 WriteCallback 接口。
3.3.3 处理连接关闭事件 (Handling Connection Close Events)
除了读写事件，连接关闭事件也是网络编程中需要处理的重要事件。当客户端主动关闭连接，或者服务器主动关闭连接时，我们需要释放与该连接相关的资源，例如 AsyncSocket 对象和 ReadCallback 对象。
AsyncSocket 提供了 setCloseCallback(CloseCallback* cb) 方法用于设置连接关闭回调。CloseCallback 接口定义了以下方法：
⚝ void connectionLost()： 此方法由 EventBase 调用，表示连接丢失（例如，客户端主动关闭连接，或者网络中断）。
⚝ void connectionClosed()： 此方法由 EventBase 调用，表示连接已正常关闭（例如，服务器主动调用 close() 方法关闭连接）。
我们可以实现 CloseCallback 接口，并在 connectionLost() 或 connectionClosed() 回调中释放资源。修改之前的代码，添加 CloseCallback 的实现：
1
#include <folly/io/async/CloseCallback.h>
2
3
class EchoCloseCallback : public CloseCallback {
4
public:
5
explicit EchoCloseCallback(std::shared_ptr<AsyncSocket> sock) : sock_(sock) {}
6
7
void connectionLost() override {
8
cout << "连接丢失" << endl; // 打印连接丢失信息 (Print connection lost information)
9
// TODO: 释放资源 (Release resources)
10
sock_.reset(); // 释放 AsyncSocket 对象 (Release AsyncSocket object)
11
}
12
13
void connectionClosed() override {
14
cout << "连接正常关闭" << endl; // 打印连接正常关闭信息 (Print connection closed information)
15
// TODO: 释放资源 (Release resources)
16
sock_.reset(); // 释放 AsyncSocket 对象 (Release AsyncSocket object)
17
}
18
19
private:
20
std::shared_ptr<AsyncSocket> sock_;
21
};
代码解析 (Code Explanation):
⚝ EchoCloseCallback 类继承自 CloseCallback 抽象类。
⚝ 构造函数接受一个 std::shared_ptr<AsyncSocket> 对象。
⚝ connectionLost() 和 connectionClosed() 方法在连接丢失或正常关闭时被调用。在这些方法中，我们打印连接关闭信息，并使用 sock_.reset() 释放 AsyncSocket 对象的智能指针，从而释放 AsyncSocket 对象和相关的资源。
3.3.4 将 CloseCallback 设置给 AsyncSocket (Setting CloseCallback to AsyncSocket)
在 acceptCallback 中，创建 EchoCloseCallback 对象，并将其设置为 AsyncSocket 的连接关闭回调：
1
// ... (之前的代码) ...
2
#include "EchoCloseCallback.h" // 引入 EchoCloseCallback 头文件 (Include EchoCloseCallback header file)
3
4
serverSocket.setAcceptCallback([&](
5
NetworkSocket fd,
6
const SocketAddress& peerAddress,
7
AcceptCallback::AcceptError error) {
8
if (error == AcceptCallback::AcceptError::NONE) {
9
cout << "接受到来自 " << peerAddress.getAddressStr() << " 的连接" << endl;
10
std::shared_ptr<AsyncSocket> clientSocket = std::make_shared<AsyncSocket>(&evb, fd);
11
std::shared_ptr<EchoReadCallback> readCallback = std::make_shared<EchoReadCallback>(clientSocket);
12
clientSocket->setReadCB(readCallback.get());
13
// ① 创建 EchoCloseCallback 对象 (Create EchoCloseCallback object)
14
std::shared_ptr<EchoCloseCallback> closeCallback = std::make_shared<EchoCloseCallback>(clientSocket);
15
// ② 设置连接关闭回调 (Set connection close callback)
16
clientSocket->setCloseCallback(closeCallback.get());
17
} else {
18
cerr << "接受连接错误: " << (int)error << endl;
19
}
20
});
21
// ... (后续代码) ...
代码修改说明 (Code Modification Explanation):
① std::shared_ptr<EchoCloseCallback> closeCallback = std::make_shared<EchoCloseCallback>(clientSocket);： 创建 EchoCloseCallback 对象。
② clientSocket->setCloseCallback(closeCallback.get());： 设置连接关闭回调。
完整的 Echo 服务器代码 (Complete Echo Server Code):
将以上代码片段整合，得到一个完整的基于 EventBase 的简单 TCP Echo 服务器的代码：
1
#include <folly/io/async/EventBase.h>
2
#include <folly/io/async/AsyncServerSocket.h>
3
#include <folly/io/async/AsyncSocket.h>
4
#include <folly/SocketAddress.h>
5
#include <folly/io/async/ReadCallback.h>
6
#include <folly/io/async/CloseCallback.h>
7
#include <folly/io/IOBuf.h>
8
#include <iostream>
9
#include <memory>
10
11
using namespace folly;
12
using namespace std;
13
14
class EchoReadCallback : public ReadCallback {
15
public:
16
explicit EchoReadCallback(std::shared_ptr<AsyncSocket> sock) : sock_(sock) {}
17
18
void getReadBuffer(void** bufReturn, size_t* lenReturn) override {
19
*bufReturn = readBuffer_.writableData();
20
*lenReturn = readBuffer_.capacity();
21
}
22
23
void readDataAvailable(size_t len) override {
24
readBuffer_.append(len);
25
cout << "接收到数据: " << readBuffer_.coalesce() << endl;
26
std::unique_ptr<IOBuf> writeBuf = IOBuf::copyBuffer(readBuffer_.coalesce());
27
sock_->write(std::move(writeBuf));
28
readBuffer_.clear();
29
}
30
31
void readEOF() override {
32
cout << "客户端关闭连接" << endl;
33
sock_->close();
34
}
35
36
void readErr(const AsyncSocketException& ex) override {
37
cerr << "读取数据错误: " << ex.what() << endl;
38
sock_->close();
39
}
40
41
private:
42
std::shared_ptr<AsyncSocket> sock_;
43
IOBuf readBuffer_{IOBuf::CREATE, 8192};
44
};
45
46
class EchoCloseCallback : public CloseCallback {
47
public:
48
explicit EchoCloseCallback(std::shared_ptr<AsyncSocket> sock) : sock_(sock) {}
49
50
void connectionLost() override {
51
cout << "连接丢失" << endl;
52
sock_.reset();
53
}
54
55
void connectionClosed() override {
56
cout << "连接正常关闭" << endl;
57
sock_.reset();
58
}
59
60
private:
61
std::shared_ptr<AsyncSocket> sock_;
62
};
63
64
65
int main() {
66
EventBase evb;
67
AsyncServerSocket serverSocket(&evb);
68
69
SocketAddress listenAddress;
70
listenAddress.setFromLocalPort(8080);
71
72
serverSocket.bind(listenAddress);
73
serverSocket.listen(1024);
74
75
serverSocket.setAcceptCallback([&](
76
NetworkSocket fd,
77
const SocketAddress& peerAddress,
78
AcceptCallback::AcceptError error) {
79
if (error == AcceptCallback::AcceptError::NONE) {
80
cout << "接受到来自 " << peerAddress.getAddressStr() << " 的连接" << endl;
81
std::shared_ptr<AsyncSocket> clientSocket = std::make_shared<AsyncSocket>(&evb, fd);
82
std::shared_ptr<EchoReadCallback> readCallback = std::make_shared<EchoReadCallback>(clientSocket);
83
clientSocket->setReadCB(readCallback.get());
84
std::shared_ptr<EchoCloseCallback> closeCallback = std::make_shared<EchoCloseCallback>(clientSocket);
85
clientSocket->setCloseCallback(closeCallback.get());
86
} else {
87
cerr << "接受连接错误: " << (int)error << endl;
88
}
89
});
90
91
cout << "服务器已启动，监听端口 8080..." << endl;
92
evb.loopForever();
93
94
return 0;
95
}
编译和运行 (Compilation and Running):
编译并运行完整的 Echo 服务器代码。使用 telnet 连接到服务器，并发送数据，你将看到服务器会将你发送的数据原样返回。
1
g++ -std=c++17 simple_tcp_server.cpp -o simple_tcp_server -lfolly -lglog -lgflags -lssl -lcrypto -lz
2
./simple_tcp_server
3
服务器已启动，监听端口 8080...
在另一个终端窗口中使用 telnet 连接并发送数据：
1
telnet localhost 8080
2
Trying ::1...
3
Connected to localhost.
4
Escape character is '^]'.
5
Hello, Echo Server!
6
Hello, Echo Server!
7
This is a test message.
8
This is a test message.
服务器会将你发送的每一行数据都回显给你。至此，我们已经实现了一个基本的 TCP Echo 服务器，它可以处理客户端连接，接收数据，并回显数据。
3.4 超时管理 (Timeout Management)
在网络编程中，超时管理是一个至关重要的环节。网络环境复杂多变，连接可能会因为各种原因而hang住，例如网络拥塞、对端崩溃等。为了防止程序长时间阻塞等待，我们需要设置合理的超时机制。EventBase 提供了定时器事件，可以方便地实现各种超时管理功能。本节，我们将学习如何使用 EventBase 的定时器事件来实现连接超时和读写超时。
3.4.1 定时器事件 (Timer Events)
EventBase 提供了 runAfterDelay(std::function<void()>, std::chrono::milliseconds delay) 方法用于注册定时器事件。该方法接受两个参数：
⚝ std::function<void()>： 定时器到期后要执行的回调函数。
⚝ std::chrono::milliseconds delay： 延迟时间，单位为毫秒。
runAfterDelay() 方法会返回一个 ScheduledDestruction::Token 对象，可以用于取消定时器事件。
3.4.2 连接超时 (Connection Timeout)
在 TCP 服务器中，我们可能需要设置连接超时，即如果在一定时间内没有客户端连接，就关闭监听 socket，释放资源。虽然通常服务器会一直监听连接，但在某些特定场景下，连接超时可能是有用的。
为了演示连接超时，我们修改服务器代码，在启动监听后，设置一个 30 秒的连接超时。如果在 30 秒内没有客户端连接，服务器将打印超时信息并退出。
修改 main() 函数如下：
1
int main() {
2
EventBase evb;
3
AsyncServerSocket serverSocket(&evb);
4
5
SocketAddress listenAddress;
6
listenAddress.setFromLocalPort(8080);
7
8
serverSocket.bind(listenAddress);
9
serverSocket.listen(1024);
10
11
serverSocket.setAcceptCallback([&](
12
NetworkSocket fd,
13
const SocketAddress& peerAddress,
14
AcceptCallback::AcceptError error) {
15
// ... (acceptCallback 代码不变) ...
16
});
17
18
cout << "服务器已启动，监听端口 8080..." << endl;
19
20
// ① 设置连接超时定时器 (Set connection timeout timer)
21
evb.runAfterDelay([&]() {
22
cout << "连接超时，服务器退出" << endl; // 打印超时信息 (Print timeout information)
23
serverSocket.close(); // 关闭监听 socket (Close listening socket)
24
evb.terminateLoopSoon(); // 终止事件循环 (Terminate event loop)
25
}, 30s); // 30 秒超时 (30 seconds timeout)
26
27
28
evb.loopForever();
29
30
return 0;
31
}
代码修改说明 (Code Modification Explanation):
① evb.runAfterDelay([&]() { ... }, 30s);： 在 evb.loopForever() 之前，我们调用 evb.runAfterDelay() 方法注册一个定时器事件。回调函数会在 30 秒后执行。回调函数中，我们打印超时信息，关闭 serverSocket，并调用 evb.terminateLoopSoon() 终止事件循环。evb.terminateLoopSoon() 方法会使 EventBase 在当前事件循环迭代结束后立即退出 loopForever() 方法。
运行测试 (Running Test):
编译并运行修改后的代码。如果在 30 秒内没有客户端连接，服务器将打印 "连接超时，服务器退出" 并自动退出。
3.4.3 读超时和写超时 (Read Timeout and Write Timeout)
更常见的超时场景是读超时和写超时。在与客户端通信过程中，我们可能需要设置读超时和写超时，防止客户端长时间不发送数据，或者服务器发送数据时网络阻塞。
为了实现读超时，我们可以在 EchoReadCallback 中添加一个定时器，每次成功读取到数据后，重置定时器。如果在定时器到期之前没有读取到新的数据，就认为读超时，关闭连接。
修改 EchoReadCallback 类如下：
1
class EchoReadCallback : public ReadCallback {
2
public:
3
explicit EchoReadCallback(std::shared_ptr<AsyncSocket> sock) : sock_(sock) {
4
resetReadTimeout(); // ① 初始化读超时定时器 (Initialize read timeout timer)
5
}
6
7
void getReadBuffer(void** bufReturn, size_t* lenReturn) override {
8
*bufReturn = readBuffer_.writableData();
9
*lenReturn = readBuffer_.capacity();
10
}
11
12
void readDataAvailable(size_t len) override {
13
readBuffer_.append(len);
14
cout << "接收到数据: " << readBuffer_.coalesce() << endl;
15
std::unique_ptr<IOBuf> writeBuf = IOBuf::copyBuffer(readBuffer_.coalesce());
16
sock_->write(std::move(writeBuf));
17
readBuffer_.clear();
18
resetReadTimeout(); // ② 重置读超时定时器 (Reset read timeout timer)
19
}
20
21
void readEOF() override {
22
cout << "客户端关闭连接" << endl;
23
sock_->close();
24
cancelReadTimeout(); // ③ 取消读超时定时器 (Cancel read timeout timer)
25
}
26
27
void readErr(const AsyncSocketException& ex) override {
28
cerr << "读取数据错误: " << ex.what() << endl;
29
sock_->close();
30
cancelReadTimeout(); // ③ 取消读超时定时器 (Cancel read timeout timer)
31
}
32
33
private:
34
void resetReadTimeout() {
35
cancelReadTimeout(); // 取消之前的定时器 (Cancel previous timer)
36
// ④ 设置新的读超时定时器 (Set new read timeout timer)
37
readTimeoutToken_ = sock_->getEventBase()->runAfterDelay([this]() {
38
cout << "读超时，关闭连接" << endl; // 打印读超时信息 (Print read timeout information)
39
sock_->close(); // 关闭 socket (Close socket)
40
}, 10s); // 10 秒读超时 (10 seconds read timeout)
41
}
42
43
void cancelReadTimeout() {
44
if (readTimeoutToken_.hasValue()) {
45
readTimeoutToken_.value().cancel(); // 取消定时器 (Cancel timer)
46
readTimeoutToken_.reset(); // 重置 Token (Reset Token)
47
}
48
}
49
50
private:
51
std::shared_ptr<AsyncSocket> sock_;
52
IOBuf readBuffer_{IOBuf::CREATE, 8192};
53
Optional<ScheduledDestruction::Token> readTimeoutToken_; // 读超时定时器 Token (Read timeout timer Token)
54
};
代码修改说明 (Code Modification Explanation):
① resetReadTimeout();： 在 EchoReadCallback 的构造函数中，调用 resetReadTimeout() 方法初始化读超时定时器。
② resetReadTimeout();： 在 readDataAvailable() 方法中，每次成功读取到数据后，调用 resetReadTimeout() 方法重置读超时定时器。
③ cancelReadTimeout();： 在 readEOF() 和 readErr() 方法中，调用 cancelReadTimeout() 方法取消读超时定时器，因为连接已经关闭，不再需要超时检测。
④ readTimeoutToken_ = sock_->getEventBase()->runAfterDelay([this]() { ... }, 10s);： 在 resetReadTimeout() 方法中，使用 sock_->getEventBase()->runAfterDelay() 方法设置一个新的读超时定时器，超时时间为 10 秒。定时器回调函数中，打印读超时信息并关闭 socket。readTimeoutToken_ 用于保存定时器事件的 Token，以便后续取消定时器。
运行测试 (Running Test):
编译并运行修改后的代码。使用 telnet 连接到服务器，并发送一些数据。如果在 10 秒内没有发送任何数据，服务器将打印 "读超时，关闭连接" 并关闭连接。
写超时的实现方式与读超时类似，可以在发送数据时设置写超时定时器，如果在定时器到期之前数据没有发送完成，就认为写超时，关闭连接。由于本例中的 Echo 服务器发送数据量较小，写操作通常不会阻塞，因此我们暂时不实现写超时。在实际应用中，如果需要发送大量数据，或者网络环境不稳定，写超时也是需要考虑的重要因素。
总结 (Summary):
本节，我们学习了如何使用 EventBase 的定时器事件来实现超时管理，包括连接超时和读超时。超时管理是构建健壮的网络应用的关键技术之一，合理地设置超时时间，可以有效地防止程序长时间阻塞等待，提高系统的可用性和稳定性。在实际应用中，需要根据具体的业务场景和网络环境，选择合适的超时策略和超时时间。
END_OF_CHAPTER
4. chapter 4： EventBase 高级应用 (Advanced Applications of EventBase)
4.1 集成异步任务 (Integrating Asynchronous Tasks)
在现代高性能应用程序的开发中，异步任务处理扮演着至关重要的角色。尤其是在事件驱动编程模型中，有效地集成异步任务能够显著提升程序的响应性和资源利用率。folly::EventBase 不仅擅长处理 I/O 事件，也提供了强大的机制来集成和管理异步任务，使得开发者能够构建更加复杂和高效的应用程序。
异步任务的重要性
异步任务（Asynchronous Tasks）指的是那些不会立即完成的操作，例如网络请求、数据库查询、文件 I/O 等。在传统的同步编程模型中，当程序执行到一个耗时的操作时，会阻塞等待操作完成才能继续执行后续代码。这种阻塞式的处理方式在高并发和需要快速响应的场景下是不可接受的。
事件驱动编程模型通过非阻塞 I/O 和事件循环机制，允许程序在等待 I/O 操作完成时继续处理其他事件，从而提高了程序的并发性和响应速度。然而，仅仅依靠事件循环处理 I/O 事件有时仍然不足以应对复杂的业务逻辑，例如需要进行计算密集型操作或者需要协调多个异步操作的场景。这时，就需要将异步任务集成到事件驱动的程序中。
EventBase 与异步任务的集成
EventBase 本身就是一个事件循环的核心，它负责监听和分发各种事件。为了集成异步任务，我们需要一种机制将异步任务的结果通知给 EventBase，以便在任务完成后能够继续执行相应的事件处理逻辑。
一种常见的集成方式是使用回调函数（Callback Functions）。当一个异步任务启动时，我们为其注册一个回调函数。当任务完成时，任务执行者会调用这个回调函数，并将任务结果传递给它。在回调函数中，我们可以将任务结果传递给 EventBase，或者直接在回调函数中执行与 EventBase 相关的操作。
另一种更现代和强大的方式是使用 Folly::Future/Promise 机制。Folly::Future 代表一个尚未完成的异步操作的结果，而 Folly::Promise 则用于设置 Future 的结果。通过 Future/Promise，我们可以更加优雅地管理异步任务，并将其与 EventBase 集成。
使用 Folly::Futures 简化异步编程
Folly::Futures 是 Facebook 开源的 Folly 库中提供的一个强大的异步编程工具。它基于 Promise 和 Future 的概念，提供了一种声明式、链式调用的方式来处理异步操作。Futures 可以很好地与 EventBase 集成，使得异步任务的管理更加简洁和高效。
以下是使用 Folly::Futures 集成异步任务的基本步骤：
① 创建 Promise 对象：在异步任务开始之前，创建一个 Folly::Promise<T> 对象，其中 T 是异步任务返回结果的类型。Promise 对象用于设置异步任务的结果。
② 获取 Future 对象：通过 promise.getFuture() 方法获取与 Promise 关联的 Folly::Future<T> 对象。Future 对象代表异步任务的结果，可以用于注册回调函数或者进行链式操作。
③ 执行异步任务：启动异步任务，例如提交到线程池或者执行非阻塞 I/O 操作。
④ 设置 Promise 结果：当异步任务完成时，在任务执行者中调用 promise.setValue(result) 方法设置 Promise 的结果，或者在任务执行失败时调用 promise.setException(exception) 方法设置异常。
⑤ 在 Future 上注册回调：在 Future 对象上可以使用 then()、thenValue()、thenError() 等方法注册回调函数。这些回调函数会在 Future 变为 ready 状态（即异步任务完成）时被 EventBase 事件循环调度执行。
实战代码示例：使用 Futures 集成异步文件读取
假设我们需要实现一个异步文件读取的功能，可以使用 Folly::Futures 和 EventBase 来完成。
1
#include <folly/EventBase.h>
2
#include <folly/futures/Future.h>
3
#include <folly/futures/Promise.h>
4
#include <folly/io/async/EventBaseFileReader.h>
5
#include <folly/io/IOExecutor.h>
6
#include <iostream>
7
#include <string>
8
9
using namespace folly;
10
using namespace std;
11
12
Future<string> asyncReadFile(EventBase& evb, const string& filename) {
13
Promise<string> promise;
14
Future<string> future = promise.getFuture();
15
16
EventBaseFileReader* reader = new EventBaseFileReader(&evb);
17
reader->open(filename);
18
19
reader->read([promise = std::move(promise), reader](
20
IOExecutor* executor,
21
EventBaseFileReader& r,
22
folly::Optional<IOBufQueue> data,
23
folly::Optional<exception_wrapper> ex) mutable {
24
if (ex.has_value()) {
25
promise.setException(ex.value());
26
} else if (data.has_value()) {
27
string content;
28
for (const auto& buf : *data) {
29
content.append((const char*)buf.data(), buf.length());
30
}
31
promise.setValue(content);
32
} else {
33
promise.setValue(""); // 文件为空
34
}
35
delete reader; // 记得释放资源
36
});
37
38
return future;
39
}
40
41
int main() {
42
EventBase evb;
43
44
string filename = "example.txt";
45
// 假设 example.txt 文件存在并包含一些文本
46
47
auto future = asyncReadFile(evb, filename);
48
49
future.thenValue([](const string& content) {
50
cout << "File content:\n" << content << endl;
51
}).thenError([](const exception_wrapper& ew) {
52
cerr << "Error reading file: " << ew.what() << endl;
53
});
54
55
evb.loop(); // 启动事件循环
56
57
return 0;
58
}
代码解析：
⚝ asyncReadFile 函数接受一个 EventBase 对象和一个文件名作为参数，返回一个 Future<string> 对象，代表异步文件读取的结果。
⚝ 在函数内部，我们创建了一个 Promise<string> 和一个 EventBaseFileReader 对象。
⚝ EventBaseFileReader::read 方法启动异步读取操作，并注册一个 lambda 回调函数。
⚝ 在回调函数中，根据读取结果设置 Promise 的值或异常。
⚝ 在 main 函数中，我们调用 asyncReadFile 获取 Future，并使用 thenValue 和 thenError 注册成功和失败的回调函数。
⚝ 最后，启动 EventBase 的事件循环，等待异步任务完成并处理结果。
Futures 的优势
使用 Folly::Futures 集成异步任务具有以下优势：
⚝ 链式调用 (Chaining)：Futures 支持链式调用，可以将多个异步操作串联起来，形成清晰的异步流程。例如，可以使用 future1.thenValue([](result1){ return asyncOp2(result1); }).thenValue([](result2){ /* ... */ }) 这样的链式调用来处理依赖于前一个异步操作结果的后续操作。
⚝ 错误处理 (Error Handling)：Futures 提供了统一的错误处理机制，可以使用 thenError() 方法捕获和处理异步操作中的异常，避免了回调地狱中复杂的错误处理逻辑。
⚝ 组合操作 (Composition)：Futures 提供了 Folly::collectAll()、Folly::collectAny() 等方法，可以将多个 Future 对象组合成一个新的 Future，方便处理并发的异步操作。
⚝ 与 EventBase 无缝集成：Futures 的回调函数会在 EventBase 的事件循环中被调度执行，保证了异步操作与事件驱动模型的良好协同。
通过 Folly::Futures，我们可以更加高效、清晰地管理和集成异步任务，构建出更加健壮和可维护的 EventBase 应用程序。
4.2 多线程 EventBase (Multi-threaded EventBase)
EventBase 默认是单线程的，所有的事件处理都在同一个线程中进行。在很多场景下，单线程的 EventBase 已经足够高效。然而，当应用程序需要处理大量的计算密集型任务，或者需要充分利用多核处理器的性能时，单线程的 EventBase 可能会成为瓶颈。这时，就需要考虑使用多线程 EventBase。
单线程 EventBase 的局限性
单线程 EventBase 的优势在于其简单性和高效性。由于所有的事件处理都在同一个线程中，避免了线程切换和同步的开销，性能很高。但是，单线程也限制了其处理能力。
① CPU 密集型任务：如果事件处理逻辑中包含大量的 CPU 密集型计算，单线程 EventBase 会被这些计算任务阻塞，导致事件循环无法及时处理其他事件，影响程序的响应性。
② 多核处理器利用率：单线程程序只能利用一个 CPU 核心，无法充分利用多核处理器的并行计算能力。
③ 阻塞 I/O 操作：虽然 EventBase 擅长处理非阻塞 I/O，但在某些情况下，仍然可能需要执行阻塞 I/O 操作（例如访问某些遗留系统或第三方库）。在单线程 EventBase 中执行阻塞 I/O 操作会完全阻塞事件循环，导致程序卡顿。
多线程 EventBase 的必要性
为了克服单线程 EventBase 的局限性，可以使用多线程 EventBase。多线程 EventBase 可以将事件处理任务分散到多个线程中并行执行，从而提高程序的并发性和吞吐量，并充分利用多核处理器的性能。
多线程 EventBase 的实现方式
实现多线程 EventBase 有多种方式，常见的包括：
① 主从 Reactor 模式 (Master-Worker Reactor)：
▮▮▮▮⚝ 主 Reactor (Master Reactor)：负责监听和接受新的连接，并将连接分配给从 Reactor。主 Reactor 通常是单线程的。
▮▮▮▮⚝ 从 Reactor (Worker Reactor)：每个从 Reactor 运行在一个独立的线程中，负责处理分配给它的连接上的 I/O 事件和业务逻辑。
这种模式的优点是结构清晰，主 Reactor 负责连接管理，从 Reactor 负责事件处理，职责分离。缺点是连接分配可能不均，导致某些从 Reactor 负载过高，而另一些则空闲。
② 多 Reactor 模式 (Multi-Reactor)：
▮▮▮▮⚝ 每个 Reactor 运行在一个独立的线程中，负责监听一部分连接或者一部分事件源。
▮▮▮▮⚝ 可以使用 Hash 算法或者其他负载均衡策略将连接或事件源分配到不同的 Reactor。
这种模式的优点是负载均衡性更好，每个 Reactor 负责一部分事件，可以更均匀地利用多核处理器的性能。缺点是结构相对复杂，需要考虑 Reactor 之间的协作和数据共享。
③ 线程池 + EventBase 模式：
▮▮▮▮⚝ 主线程运行一个 EventBase，负责监听和接受事件。
▮▮▮▮⚝ 将事件处理任务提交到线程池中执行。
▮▮▮▮⚝ 线程池中的线程可以执行 CPU 密集型任务或者阻塞 I/O 操作，而不会阻塞主线程的事件循环。
这种模式的优点是实现简单，易于与现有的线程池技术集成。缺点是事件处理任务需要在线程之间切换，有一定的开销。
Folly::EventBase 的多线程支持
Folly::EventBase 本身并没有直接提供多线程 Reactor 的实现，但它可以很好地支持多线程应用。开发者可以根据自己的需求，选择合适的线程模型，并结合 Folly::EventBase 构建多线程事件驱动程序。
实战代码示例：线程池 + EventBase 模式
以下示例演示了如何使用线程池和 EventBase 实现一个简单的多线程 TCP 服务器。
1
#include <folly/EventBase.h>
2
#include <folly/io/async/AsyncServerSocket.h>
3
#include <folly/io/async/AsyncSocket.h>
4
#include <folly/io/IOExecutor.h>
5
#include <folly/executors/ThreadPoolExecutor.h>
6
#include <iostream>
7
#include <memory>
8
9
using namespace folly;
10
using namespace std;
11
12
class Connection : public AsyncSocket::ReadCallback {
13
public:
14
Connection(EventBase* evb, std::unique_ptr<AsyncSocket> sock, ThreadPoolExecutor* executor)
15
: evb_(evb), sock_(std::move(sock)), executor_(executor) {
16
sock_->setReadCB(this);
17
}
18
19
~Connection() override {
20
sock_->close();
21
}
22
23
void getReadBuffer(void** bufReturn, size_t* lenReturn) override {
24
*bufReturn = readBuffer_;
25
*lenReturn = kBufferSize;
26
}
27
28
void readDataAvailable(size_t len) override {
29
executor_->add([this, len]() { // 将处理任务提交到线程池
30
processData(len);
31
});
32
}
33
34
void readEOF() override {
35
delete this; // 连接关闭，释放资源
36
}
37
38
void readErr(const AsyncSocketException& ex) override {
39
cerr << "Read error: " << ex.what() << endl;
40
delete this; // 发生错误，释放资源
41
}
42
43
private:
44
void processData(size_t len) {
45
string data(readBuffer_, len);
46
cout << "Received data: " << data << " from " << sock_->getPeerAddress() << endl;
47
48
// 模拟 CPU 密集型处理
49
std::this_thread::sleep_for(std::chrono::milliseconds(100));
50
51
string response = "Echo: " + data;
52
sock_->write(response.c_str(), response.length());
53
}
54
55
private:
56
EventBase* evb_;
57
std::unique_ptr<AsyncSocket> sock_;
58
ThreadPoolExecutor* executor_;
59
char readBuffer_[kBufferSize];
60
static constexpr size_t kBufferSize = 1024;
61
};
62
63
class ServerSocket : public AsyncServerSocket::AcceptCallback {
64
public:
65
ServerSocket(EventBase* evb, ThreadPoolExecutor* executor) : evb_(evb), executor_(executor) {}
66
67
void connectionAccepted(std::unique_ptr<AsyncSocket> sock) override {
68
cout << "Connection accepted from " << sock->getPeerAddress() << endl;
69
new Connection(evb_, std::move(sock), executor_); // 创建 Connection 对象处理连接
70
}
71
72
void acceptError(const AsyncSocketException& ex) override {
73
cerr << "Accept error: " << ex.what() << endl;
74
}
75
76
private:
77
EventBase* evb_;
78
ThreadPoolExecutor* executor_;
79
};
80
81
int main() {
82
EventBase evb;
83
ThreadPoolExecutor executor(4); // 创建一个包含 4 个线程的线程池
84
85
AsyncServerSocket serverSocket(&evb);
86
serverSocket.setAcceptCB(std::make_unique<ServerSocket>(&evb, &executor));
87
88
SocketAddress address;
89
address.setFromLocalPort(8080);
90
91
serverSocket.bind(address);
92
serverSocket.listen(128);
93
serverSocket.startAccepting();
94
95
cout << "Server listening on port 8080" << endl;
96
97
evb.loopForever(); // 启动事件循环
98
99
return 0;
100
}
代码解析：
⚝ Connection 类负责处理客户端连接，ServerSocket 类负责接受新的连接。
⚝ 在 Connection::readDataAvailable 方法中，我们将数据处理任务 processData 提交到 ThreadPoolExecutor 线程池中执行。
⚝ processData 方法模拟 CPU 密集型处理，并向客户端发送响应。
⚝ main 函数中创建了一个 ThreadPoolExecutor 对象，并将其传递给 ServerSocket 和 Connection 对象。
⚝ 主线程的 EventBase 负责监听连接和 I/O 事件，而线程池中的线程负责执行数据处理任务。
多线程 EventBase 的注意事项
使用多线程 EventBase 需要注意以下几点：
① 线程安全 (Thread Safety)：EventBase 本身不是完全线程安全的。在多线程环境下使用 EventBase 时，需要注意线程安全问题。例如，在多个线程中同时操作同一个 EventBase 对象可能会导致竞争条件。通常，每个线程应该拥有自己的 EventBase 对象。
② 同步与协作 (Synchronization and Coordination)：多线程程序需要考虑线程之间的同步和协作。例如，如果多个线程需要共享数据，需要使用锁、互斥量等同步机制来保护共享数据的访问。Folly::Synchronized 和 Folly::SharedMutex 等工具可以帮助简化多线程同步。
③ 上下文切换开销 (Context Switching Overhead)：多线程虽然可以提高并发性，但线程切换本身也有一定的开销。线程数量不宜过多，过多的线程反而可能降低性能。需要根据实际应用场景和硬件资源，合理设置线程数量。
④ 调试难度 (Debugging Complexity)：多线程程序的调试难度比单线程程序更高。需要使用专门的调试工具和技术来定位和解决多线程问题。
合理地使用多线程 EventBase 可以显著提升应用程序的性能和可扩展性，但同时也需要仔细考虑线程安全、同步和调试等问题。
4.3 自定义事件源 (Custom Event Sources)
EventBase 默认支持的文件描述符事件、定时器事件和信号事件已经能够满足大部分应用场景的需求。然而，在某些特殊情况下，我们可能需要处理一些非标准的事件源，例如来自硬件设备、消息队列、或者其他自定义系统的事件。这时，就需要使用 EventBase 的自定义事件源功能。
自定义事件源的需求
默认的事件源类型虽然通用，但无法覆盖所有可能的事件来源。例如：
① 硬件设备事件：某些应用程序需要监听硬件设备的状态变化，例如传感器数据、设备状态信号等。这些硬件设备通常有自己的事件通知机制，需要将其集成到 EventBase 的事件循环中。
② 消息队列事件：应用程序可能需要监听消息队列（例如 Kafka、RabbitMQ）中的消息到达事件。消息队列客户端库通常提供异步接收消息的接口，需要将其与 EventBase 集成。
③ 自定义系统事件：应用程序内部可能存在一些自定义的事件源，例如状态机状态变化事件、配置更新事件等。这些事件需要能够被 EventBase 监控和处理。
EventHandler 接口
EventBase 提供了 EventHandler 抽象类，用于定义自定义事件处理器的接口。要实现自定义事件源，需要创建一个继承自 EventHandler 的类，并实现其虚函数。
EventHandler 类定义了以下关键的虚函数：
⚝ void processEvent(uint16_t events)：当事件源上有事件发生时，EventBase 会调用这个函数。events 参数指示了发生的事件类型，例如可读事件、可写事件等。
⚝ void registerForEvents(uint16_t events)：当需要开始监听事件源上的某些事件时，EventBase 会调用这个函数。自定义事件处理器需要在该函数中注册事件监听，例如向操作系统注册文件描述符事件，或者启动一个定时器。
⚝ void unregisterForEvents(uint16_t events)：当需要停止监听事件源上的某些事件时，EventBase 会调用这个函数。自定义事件处理器需要在该函数中取消事件监听，例如取消文件描述符事件注册，或者停止定时器。
⚝ void destroy() noexcept override：当 EventHandler 对象被销毁时，EventBase 会调用这个函数。自定义事件处理器需要在该函数中释放资源，例如关闭文件描述符，释放内存等。
创建自定义事件源的步骤
创建自定义事件源通常包括以下步骤：
① 定义事件源：确定自定义事件源的类型和事件通知机制。例如，可以是基于文件描述符的事件源，也可以是基于定时器的事件源，或者其他自定义的事件通知方式。
② 实现 EventHandler 子类：创建一个继承自 EventHandler 的类，并实现 processEvent、registerForEvents、unregisterForEvents 和 destroy 等虚函数。在这些函数中，实现自定义事件源的事件监听和处理逻辑。
③ 注册事件处理器：创建自定义 EventHandler 对象，并使用 EventBase::addHandler() 方法将其注册到 EventBase 中。
④ 触发事件：在适当的时机，触发自定义事件源上的事件。触发事件的方式取决于具体的事件源类型。例如，对于基于文件描述符的事件源，可以通过写入文件描述符来触发事件；对于基于定时器的事件源，可以通过定时器到期来触发事件；对于其他自定义事件源，需要根据其事件通知机制来触发事件。
实战代码示例：自定义定时器事件源
以下示例演示了如何创建一个自定义的定时器事件源。这个自定义定时器事件源会在指定的时间间隔触发事件，并执行用户指定的回调函数。
1
#include <folly/EventBase.h>
2
#include <folly/EventHandler.h>
3
#include <iostream>
4
#include <chrono>
5
#include <functional>
6
7
using namespace folly;
8
using namespace std;
9
10
class CustomTimerHandler : public EventHandler {
11
public:
12
using Callback = std::function<void()>;
13
14
CustomTimerHandler(EventBase* evb, std::chrono::milliseconds interval, Callback cb)
15
: EventHandler(evb), interval_(interval), callback_(cb), timerEvent_(evb) {}
16
17
~CustomTimerHandler() override {
18
timerEvent_.cancel(); // 取消定时器事件
19
}
20
21
void registerForEvents(uint16_t events) override {
22
timerEvent_.scheduleTimeout([this]() {
23
processTimerEvent();
24
}, interval_);
25
}
26
27
void unregisterForEvents(uint16_t events) override {
28
timerEvent_.cancel();
29
}
30
31
void processEvent(uint16_t events) override {
32
// 本例中定时器事件不需要 processEvent
33
}
34
35
void destroy() noexcept override {
36
// 无需额外资源释放
37
}
38
39
private:
40
void processTimerEvent() {
41
if (callback_) {
42
callback_(); // 执行用户回调函数
43
}
44
registerForEvents(EventHandler::READ); // 重新注册定时器事件，实现周期性触发
45
}
46
47
private:
48
std::chrono::milliseconds interval_;
49
Callback callback_;
50
ScheduledEvent timerEvent_;
51
};
52
53
int main() {
54
EventBase evb;
55
56
auto timerCallback = []() {
57
cout << "Custom timer event triggered at "
58
<< std::chrono::system_clock::now() << endl;
59
};
60
61
CustomTimerHandler timerHandler(&evb, std::chrono::seconds(2), timerCallback);
62
evb.addHandler(&timerHandler); // 注册自定义事件处理器
63
64
evb.loopForever(); // 启动事件循环
65
66
return 0;
67
}
代码解析：
⚝ CustomTimerHandler 类继承自 EventHandler，实现了自定义定时器事件源。
⚝ 构造函数接受 EventBase 对象、定时器间隔和回调函数作为参数。
⚝ registerForEvents 方法使用 ScheduledEvent::scheduleTimeout 注册定时器事件，定时器到期后会调用 processTimerEvent 方法。
⚝ processTimerEvent 方法执行用户回调函数，并重新注册定时器事件，实现周期性触发。
⚝ main 函数中创建了一个 CustomTimerHandler 对象，并将其注册到 EventBase 中。
自定义事件源的应用场景
自定义事件源可以应用于各种需要处理非标准事件的场景，例如：
⚝ 监控系统：可以使用自定义事件源监控系统资源（例如 CPU 使用率、内存使用率）的变化，并在资源使用率超过阈值时触发事件。
⚝ 游戏服务器：可以使用自定义事件源处理游戏逻辑事件，例如玩家操作事件、游戏状态变化事件等。
⚝ 物联网 (IoT) 应用：可以使用自定义事件源处理来自各种物联网设备的事件，例如传感器数据、设备状态报告等。
通过自定义事件源，EventBase 的事件处理能力得到了极大的扩展，可以应用于更加广泛和复杂的应用场景。
4.4 性能调优与最佳实践 (Performance Tuning and Best Practices)
EventBase 本身是一个高性能的事件循环库，但要充分发挥其性能，并构建高效、稳定的应用程序，还需要进行合理的性能调优和遵循最佳实践。
性能调优的关键因素
影响 EventBase 应用程序性能的关键因素包括：
① 事件处理函数效率：事件处理函数（例如 EventHandler::processEvent、定时器回调函数、信号处理函数等）的执行效率直接影响事件循环的性能。如果事件处理函数执行时间过长，会阻塞事件循环，导致程序响应延迟。
② 事件源数量：注册到 EventBase 的事件源数量越多，事件循环需要处理的事件就越多，性能也会受到影响。需要合理控制事件源的数量，避免不必要的事件监听。
③ 事件分发机制：EventBase 支持多种事件分发机制（例如 epoll、kqueue、select 等）。不同的事件分发机制在不同的操作系统和场景下性能表现不同。需要根据实际情况选择合适的事件分发机制。
④ 内存管理：EventBase 应用程序的内存管理也会影响性能。频繁的内存分配和释放会增加系统开销。需要合理地管理内存，避免内存泄漏和内存碎片。
⑤ 线程模型：对于多线程 EventBase 应用程序，线程模型的选择和线程间的协作方式也会影响性能。需要根据应用场景选择合适的线程模型，并优化线程间的同步和通信。
性能调优技巧
以下是一些常用的 EventBase 性能调优技巧：
① 优化事件处理函数：
▮▮▮▮⚝ 避免阻塞操作：事件处理函数中应尽量避免执行阻塞操作，例如阻塞 I/O、长时间计算等。如果必须执行耗时操作，应将其放到异步任务或者线程池中执行，避免阻塞事件循环。
▮▮▮▮⚝ 减少计算量：尽量减少事件处理函数中的计算量，将复杂的计算逻辑放到其他线程或者进程中执行。
▮▮▮▮⚝ 使用高效的数据结构和算法：在事件处理函数中使用高效的数据结构和算法，例如哈希表、平衡树等，提高数据处理效率。
▮▮▮▮⚝ 避免不必要的内存分配：尽量避免在事件处理函数中频繁地分配和释放内存。可以使用对象池、内存池等技术来减少内存分配开销。
② 减少事件源数量：
▮▮▮▮⚝ 只监听必要的事件：只监听应用程序真正需要的事件，避免监听不必要的事件。
▮▮▮▮⚝ 合并事件源：如果多个事件源可以合并处理，尽量将其合并为一个事件源，减少事件源的数量。
▮▮▮▮⚝ 动态注册和注销事件源：根据应用程序的运行状态，动态地注册和注销事件源，只在需要时才监听事件。
③ 选择合适的事件分发机制：
▮▮▮▮⚝ epoll (Linux)：epoll 是 Linux 系统下性能最好的事件分发机制，应优先选择 epoll。
▮▮▮▮⚝ kqueue (macOS, FreeBSD)：kqueue 是 macOS 和 FreeBSD 系统下性能最好的事件分发机制，应优先选择 kqueue。
▮▮▮▮⚝ select (通用)：select 是通用的事件分发机制，但性能相对较差，应尽量避免使用 select，除非在没有 epoll 或 kqueue 的系统上。
▮▮▮▮⚝ EventBase::setLibeventDispatchMethod()：可以使用 EventBase::setLibeventDispatchMethod() 方法手动设置 EventBase 使用的事件分发机制。
④ 优化内存管理：
▮▮▮▮⚝ 使用对象池/内存池：对于频繁创建和销毁的对象，可以使用对象池或内存池来管理内存，减少内存分配和释放的开销。
▮▮▮▮⚝ 避免内存泄漏：仔细检查代码，确保所有分配的内存都得到正确释放，避免内存泄漏。
▮▮▮▮⚝ 使用智能指针：使用 std::unique_ptr、std::shared_ptr 等智能指针来管理内存，自动释放资源，减少内存泄漏的风险。
⑤ 优化线程模型：
▮▮▮▮⚝ 合理设置线程数量：对于多线程 EventBase 应用程序，需要根据应用场景和硬件资源，合理设置线程数量。线程数量不宜过多，过多的线程反而可能降低性能。
▮▮▮▮⚝ 减少线程间同步开销：尽量减少线程间的同步操作，例如锁竞争。可以使用无锁数据结构、原子操作等技术来减少同步开销。
▮▮▮▮⚝ 优化线程调度：合理地调度线程，避免线程饥饿和线程优先级反转等问题。
最佳实践
以下是一些 EventBase 应用程序的最佳实践：
① 清晰的事件处理逻辑：保持事件处理函数的简洁和高效，避免在事件处理函数中执行复杂的业务逻辑。将复杂的业务逻辑放到单独的模块或者服务中处理。
② 合理的错误处理：在事件处理函数中进行充分的错误处理，例如处理 I/O 错误、协议错误等。使用异常处理或者错误码来报告错误，并进行适当的错误恢复。
③ 资源管理：合理地管理资源，例如文件描述符、内存、网络连接等。及时释放不再使用的资源，避免资源泄漏。
④ 日志记录：添加详细的日志记录，方便调试和性能分析。记录关键事件、错误信息、性能指标等。
⑤ 监控与告警：对 EventBase 应用程序进行监控，监控关键性能指标，例如事件处理延迟、事件循环负载、资源使用率等。设置告警机制，及时发现和处理性能问题和错误。
⑥ 代码审查与测试：进行代码审查和充分的测试，确保代码质量和稳定性。进行单元测试、集成测试、性能测试等，验证应用程序的功能和性能。
通过遵循这些性能调优技巧和最佳实践，可以构建出高性能、稳定可靠的 EventBase 应用程序，充分发挥 EventBase 的优势，满足各种复杂应用场景的需求。
性能分析工具
可以使用以下工具进行 EventBase 应用程序的性能分析：
⚝ perf (Linux)：Linux 性能分析工具，可以分析 CPU 使用率、函数调用关系、热点函数等。
⚝ gprof (GNU Profiler)：GNU 性能分析工具，可以分析函数调用次数和执行时间。
⚝ valgrind (Memory Profiler)：内存分析工具，可以检测内存泄漏、内存错误等。
⚝ FlameGraph (火焰图)：可视化性能分析工具，可以将性能数据以火焰图的形式展示，直观地展示程序的热点路径。
⚝ 自定义监控指标：在应用程序中添加自定义监控指标，例如事件处理延迟、事件循环负载等，使用监控系统（例如 Prometheus、Grafana）进行监控和可视化。
通过使用这些性能分析工具，可以深入了解 EventBase 应用程序的性能瓶颈，并有针对性地进行性能调优。
END_OF_CHAPTER
5. chapter 5： EventBase API 全面解析 (Comprehensive API Analysis of EventBase)
5.1 EventBase 类详解 (Detailed Explanation of EventBase Class)
EventBase 类是 folly/EventBase.h 库的核心，它代表了事件循环（Event Loop）的实例，是所有事件处理机制的中心枢纽。理解 EventBase 类及其 API 是掌握 folly/EventBase.h 的关键一步。本节将深入剖析 EventBase 类的各个方面，从其基本概念到高级用法，帮助读者全面理解和应用它。
5.1.1 EventBase 的角色与职责 (Role and Responsibilities of EventBase)
EventBase 的核心职责是管理和调度事件。在事件驱动编程模型中，程序不再是按照预定的线性流程执行，而是等待各种事件的发生，例如文件描述符上的数据就绪、定时器超时、信号到达等。EventBase 就像一个交通警察，监听着各种事件源，一旦事件发生，就通知相应的事件处理器（EventHandler）进行处理。
EventBase 主要负责以下几个方面的职责：
① 事件循环管理 (Event Loop Management)：
EventBase 维护着一个事件循环，这是事件驱动程序的核心。事件循环不断地轮询注册的事件源，检查是否有事件发生。当事件发生时，事件循环负责将事件分发给相应的事件处理器。EventBase 提供了启动、停止和控制事件循环的方法。
② 事件注册与分发 (Event Registration and Dispatch)：
EventBase 允许用户注册各种类型的事件，例如文件描述符事件、定时器事件和信号事件。用户需要将事件源（例如文件描述符、定时器）和事件处理器（EventHandler 的子类实例）关联起来，注册到 EventBase 中。当事件发生时，EventBase 负责将事件分发给注册的事件处理器进行处理。
③ 事件处理器生命周期管理 (Event Handler Lifecycle Management)：
EventBase 负责管理注册到其中的 EventHandler 实例的生命周期。当事件不再需要监听时，可以从 EventBase 中移除相应的 EventHandler。EventBase 提供了添加、修改和移除事件处理器的方法。
④ 线程管理 (Thread Management)：
EventBase 通常运行在它自己的线程中，称为 EventBase 线程。这使得事件循环和事件处理与主程序逻辑分离，提高了程序的并发性和响应性。EventBase 提供了在 EventBase 线程中执行任务的方法，以及判断当前代码是否在 EventBase 线程中执行的方法。
⑤ 时间管理 (Time Management)：
EventBase 提供了高精度的时间管理功能，用于处理定时器事件和超时管理。它能够精确地触发定时器事件，并提供获取当前时间的方法。
5.1.2 EventBase 类的主要 API (Main APIs of EventBase Class)
EventBase 类提供了丰富的 API 来实现上述职责。以下是 EventBase 类中一些常用的重要 API，我们将分类进行详细介绍。
5.1.2.1 构造函数与析构函数 (Constructors and Destructors)
⚝ EventBase(): 默认构造函数，创建一个新的 EventBase 实例。通常情况下，使用默认构造函数即可。
⚝ ~EventBase(): 析构函数，销毁 EventBase 实例。析构函数会自动清理所有注册到该 EventBase 的事件处理器和资源。
1
#include <folly/EventBase.h>
2
3
int main() {
4
folly::EventBase evb; // 创建 EventBase 实例
5
// ... 使用 evb ...
6
return 0; // evb 实例在 main 函数结束时自动析构
7
}
5.1.2.2 事件循环控制 (Event Loop Control)
⚝ loop(): 启动事件循环并阻塞当前线程，直到事件循环被显式终止。这是最常用的启动事件循环的方法。
⚝ loopForever(): 类似于 loop()，但事件循环会一直运行下去，直到程序退出。通常用于服务器程序的主循环。
⚝ loopOnce(): 执行事件循环一次。即使没有事件发生，也会立即返回。通常用于测试或需要手动控制事件循环的场景。
⚝ terminateLoopSoon(): 请求事件循环在当前迭代完成后尽快终止。事件循环会在处理完当前就绪的事件后退出。
⚝ waitUntilLoopExits(): 阻塞当前线程，直到事件循环退出。通常在调用 terminateLoopSoon() 后调用，等待事件循环完全退出。
1
#include <folly/EventBase.h>
2
#include <iostream>
3
4
void timerCallback() {
5
std::cout << "Timer expired!" << std::endl;
6
}
7
8
int main() {
9
folly::EventBase evb;
10
folly::TimerHandler timer(&evb, timerCallback);
11
timer.startTimeout(std::chrono::seconds(1)); // 1 秒后触发定时器
12
13
std::thread loopThread([&evb]() {
14
evb.loop(); // 在新线程中启动事件循环
15
std::cout << "Event loop exited." << std::endl;
16
});
17
18
std::this_thread::sleep_for(std::chrono::seconds(3));
19
evb.terminateLoopSoon(); // 请求事件循环终止
20
loopThread.join(); // 等待事件循环线程退出
21
22
return 0;
23
}
5.1.2.3 任务调度 (Task Scheduling)
⚝ runInLoop(Func func): 将函数 func 提交到 EventBase 线程中执行。func 会在事件循环的下一次迭代中被调用。这是在 EventBase 线程中执行任务的主要方式。
⚝ runInEventBaseThread(Func func): 类似于 runInLoop()，但如果当前线程已经是 EventBase 线程，则会立即执行 func，否则会将 func 提交到 EventBase 线程中异步执行。
⚝ runAfterDelay(Func func, Duration delay): 延迟 delay 时间后，在 EventBase 线程中执行函数 func。
1
#include <folly/EventBase.h>
2
#include <iostream>
3
4
void taskInEventBaseThread() {
5
std::cout << "Task executed in EventBase thread." << std::endl;
6
}
7
8
int main() {
9
folly::EventBase evb;
10
11
std::thread loopThread([&evb]() {
12
evb.loop();
13
});
14
15
evb.runInLoop(taskInEventBaseThread); // 提交任务到 EventBase 线程
16
17
std::this_thread::sleep_for(std::chrono::seconds(1));
18
evb.terminateLoopSoon();
19
loopThread.join();
20
21
return 0;
22
}
5.1.2.4 线程信息查询 (Thread Information Query)
⚝ getLoopThreadId(): 返回 EventBase 线程的线程 ID。
⚝ isInLoopThread(): 判断当前线程是否是 EventBase 线程。
1
#include <folly/EventBase.h>
2
#include <iostream>
3
#include <thread>
4
5
int main() {
6
folly::EventBase evb;
7
std::thread loopThread([&evb]() {
8
std::cout << "EventBase thread ID: " << evb.getLoopThreadId() << std::endl;
9
std::cout << "Is in EventBase thread (inside loop thread): " << evb.isInLoopThread() << std::endl;
10
evb.loop();
11
});
12
13
std::cout << "Is in EventBase thread (outside loop thread): " << evb.isInLoopThread() << std::endl;
14
evb.runInLoop([&evb]() {
15
std::cout << "Is in EventBase thread (inside runInLoop callback): " << evb.isInLoopThread() << std::endl;
16
});
17
18
std::this_thread::sleep_for(std::chrono::seconds(1));
19
evb.terminateLoopSoon();
20
loopThread.join();
21
return 0;
22
}
5.1.2.5 时间相关 API (Time-related APIs)
⚝ getUptime(): 返回 EventBase 实例的运行时间，以 std::chrono::microseconds 为单位。
⚝ now(): 返回当前时间点，通常用于高精度时间戳。
1
#include <folly/EventBase.h>
2
#include <iostream>
3
#include <chrono>
4
5
int main() {
6
folly::EventBase evb;
7
auto startTime = std::chrono::steady_clock::now();
8
9
std::thread loopThread([&evb]() {
10
evb.loop();
11
});
12
13
std::this_thread::sleep_for(std::chrono::seconds(2));
14
auto uptime = evb.getUptime();
15
auto endTime = std::chrono::steady_clock::now();
16
auto expectedUptime = endTime - startTime;
17
18
std::cout << "EventBase uptime: " << std::chrono::duration_cast<std::chrono::milliseconds>(uptime).count() << " ms" << std::endl;
19
std::cout << "Expected uptime: " << std::chrono::duration_cast<std::chrono::milliseconds>(expectedUptime).count() << " ms" << std::endl;
20
21
evb.terminateLoopSoon();
22
loopThread.join();
23
return 0;
24
}
5.1.2.6 名称与调试 (Name and Debugging)
⚝ getName(): 获取 EventBase 实例的名称。名称通常用于调试和日志记录。
⚝ setName(std::string name): 设置 EventBase 实例的名称。
1
#include <folly/EventBase.h>
2
#include <iostream>
3
4
int main() {
5
folly::EventBase evb;
6
std::cout << "Initial EventBase name: " << evb.getName() << std::endl;
7
8
evb.setName("MyEventBase");
9
std::cout << "Updated EventBase name: " << evb.getName() << std::endl;
10
11
return 0;
12
}
5.1.2.7 底层 libevent 访问 (Underlying libevent Access)
⚝ getLibeventBase(): 返回底层 libevent 库的 event_base 指针。允许直接访问和操作 libevent 的 API，通常在需要更底层控制或与 libevent 库的其他组件集成时使用。谨慎使用此 API，因为它绕过了 folly::EventBase 的封装，可能导致不可预测的行为。
1
#include <folly/EventBase.h>
2
#include <iostream>
3
4
int main() {
5
folly::EventBase evb;
6
event_base* libeventBase = evb.getLibeventBase();
7
if (libeventBase != nullptr) {
8
std::cout << "Successfully obtained underlying libevent base." << std::endl;
9
// 可以使用 libeventBase 操作 libevent API，例如 event_base_get_method(libeventBase)
10
} else {
11
std::cerr << "Failed to obtain underlying libevent base." << std::endl;
12
}
13
return 0;
14
}
5.1.3 EventBase 的线程安全性 (Thread Safety of EventBase)
EventBase 类 不是线程安全的。这意味着，只能从创建 EventBase 实例的线程（即 EventBase 线程）中调用 EventBase 的方法。如果在其他线程中直接调用 EventBase 的方法，可能会导致数据竞争和未定义的行为。
为了在其他线程中与 EventBase 交互，应该使用 runInLoop() 或 runInEventBaseThread() 方法将任务提交到 EventBase 线程中执行。EventBase 会保证提交的任务在 EventBase 线程中串行执行，从而避免线程安全问题。
1
#include <folly/EventBase.h>
2
#include <iostream>
3
#include <thread>
4
5
void unsafeOperation(folly::EventBase& evb) {
6
// 错误示例：在非 EventBase 线程中直接调用 EventBase 方法
7
// evb.terminateLoopSoon(); // ❌ 线程不安全！
8
std::cerr << "Unsafe operation attempted from non-EventBase thread." << std::endl;
9
}
10
11
void safeOperation(folly::EventBase& evb) {
12
// 正确示例：使用 runInLoop 在 EventBase 线程中执行操作
13
evb.runInLoop([&evb]() {
14
evb.terminateLoopSoon(); // ✅ 线程安全
15
std::cout << "Safe operation executed in EventBase thread." << std::endl;
16
});
17
}
18
19
int main() {
20
folly::EventBase evb;
21
std::thread loopThread([&evb]() {
22
evb.loop();
23
});
24
25
std::thread unsafeThread(unsafeOperation, std::ref(evb));
26
std::thread safeThread(safeOperation, std::ref(evb));
27
28
unsafeThread.join();
29
safeThread.join();
30
loopThread.join();
31
32
return 0;
33
}
5.1.4 异常处理 (Exception Handling)
EventBase 自身对异常处理做了很好的封装。通常情况下，在事件处理器（EventHandler）的回调函数中抛出的异常会被 EventBase 捕获并处理，防止程序崩溃。但是，默认情况下，EventBase 对捕获的异常只是简单地打印错误日志，并不会重新抛出或传播异常。
如果需要自定义异常处理逻辑，例如记录更详细的错误信息、发送告警或进行其他操作，可以通过继承 EventBase 类并重写 onException() 虚函数来实现。onException() 函数会在事件循环捕获到异常时被调用，可以在其中实现自定义的异常处理逻辑。
1
#include <folly/EventBase.h>
2
#include <iostream>
3
#include <stdexcept>
4
5
class MyEventBase : public folly::EventBase {
6
public:
7
MyEventBase() : folly::EventBase() {}
8
9
protected:
10
void onException(const std::exception& ex) noexcept override {
11
std::cerr << "Custom exception handler caught exception: " << ex.what() << std::endl;
12
// 可以添加更复杂的异常处理逻辑，例如记录日志、发送告警等
13
}
14
};
15
16
void throwingCallback() {
17
throw std::runtime_error("Exception from event handler");
18
}
19
20
int main() {
21
MyEventBase evb;
22
folly::TimerHandler timer(&evb, throwingCallback);
23
timer.startTimeout(std::chrono::milliseconds(100));
24
25
std::thread loopThread([&evb]() {
26
evb.loop();
27
});
28
29
loopThread.join();
30
return 0;
31
}
5.1.5 总结 (Summary)
EventBase 类是 folly/EventBase.h 库的核心，它提供了事件循环、事件注册与分发、任务调度、时间管理等关键功能。理解 EventBase 的 API 和线程安全模型是使用 folly/EventBase.h 进行事件驱动编程的基础。本节详细介绍了 EventBase 类的主要 API，包括构造函数、事件循环控制、任务调度、线程信息查询、时间相关 API、名称与调试以及底层 libevent 访问。同时，强调了 EventBase 的线程安全性以及自定义异常处理的方法。掌握这些知识，可以为后续深入学习 EventHandler 类族以及构建复杂的事件驱动应用打下坚实的基础。
5.2 EventHandler 类族 (EventHandler Class Family)
EventHandler 类是 folly/EventBase.h 库中用于处理事件的核心抽象类。它定义了事件处理器的通用接口，用户需要通过继承 EventHandler 并实现其虚函数来定义具体的事件处理逻辑。EventHandler 类族包含了一系列预定义的事件处理器基类，例如 ReadEventHandler, WriteEventHandler, TimerEventHandler, SignalHandler, UserEventHandler 等，分别用于处理不同类型的事件。本节将深入探讨 EventHandler 类族的设计理念、继承关系、以及各种预定义事件处理器的使用方法。
5.2.1 EventHandler 的设计理念 (Design Philosophy of EventHandler)
EventHandler 的设计遵循面向对象的设计原则，通过抽象基类和虚函数机制，实现了事件处理逻辑的解耦和扩展性。其核心设计理念包括：
① 抽象接口 (Abstract Interface)：
EventHandler 是一个抽象基类，定义了一组虚函数，例如 readReady(), writeReady(), timerExpired(), signalReceived() 等，这些虚函数代表了不同类型的事件。用户需要继承 EventHandler 并根据需要重写这些虚函数，来实现具体的事件处理逻辑。
② 多态性 (Polymorphism)：
通过使用 EventHandler 指针或引用，可以指向不同类型的事件处理器对象（例如 ReadEventHandler, TimerHandler 等）。在事件发生时，EventBase 可以通过统一的接口调用相应的事件处理器的虚函数，实现多态调用，从而简化了事件分发和处理的流程。
③ 组合优于继承 (Composition over Inheritance)：
虽然 EventHandler 类族使用了继承，但其设计也体现了组合的思想。例如，TimerHandler 和 SignalHandler 内部组合了 EventHandler 的功能，并提供了更高级别的 API 来简化定时器和信号事件的处理。在实际应用中，可以根据需要组合不同的事件处理器，构建更复杂的事件处理逻辑。
④ 生命周期管理 (Lifecycle Management)：
EventHandler 的生命周期由 EventBase 管理。当事件处理器被添加到 EventBase 时，其生命周期开始；当从 EventBase 中移除或 EventBase 销毁时，其生命周期结束。EventHandler 提供了 destroy() 虚函数，允许用户在事件处理器销毁前执行一些清理操作。
5.2.2 EventHandler 的继承关系 (Inheritance Hierarchy of EventHandler)
EventHandler 类族呈现出清晰的继承关系，方便用户根据不同的事件类型选择合适的基类。其主要的继承关系如下：
1
EventHandler
2
├── ReadEventHandler
3
├── WriteEventHandler
4
├── TimerEventHandler (also inherits from EventHandler)
5
├── SignalHandler (also inherits from EventHandler)
6
└── UserEventHandler
⚝ EventHandler: 抽象基类，定义了事件处理器的通用接口。
⚝ ReadEventHandler: 用于处理文件描述符上的读就绪事件。
⚝ WriteEventHandler: 用于处理文件描述符上的写就绪事件。
⚝ TimerEventHandler: 用于处理定时器事件。注意：TimerHandler 实际上是 EventHandler 的一个子类，但通常以 TimerHandler 的名字出现，为了表述清晰，这里使用 TimerEventHandler 指代定时器事件处理器。
⚝ SignalHandler: 用于处理信号事件。类似地，SignalHandler 也继承自 EventHandler，这里使用 SignalHandler 指代信号事件处理器。
⚝ UserEventHandler: 用于处理用户自定义事件。
5.2.3 EventHandler 的虚函数 (Virtual Functions of EventHandler)
EventHandler 类定义了一系列虚函数，用户需要根据需要重写这些虚函数来实现具体的事件处理逻辑。以下是 EventHandler 类中常用的虚函数：
⚝ virtual void readReady(uint16_t events) noexcept: 当关联的文件描述符可读时被调用。events 参数指示了就绪的事件类型，例如 EventHandler::READ, EventHandler::WRITE, EventHandler::ERROR 等。通常在 ReadEventHandler 中重写。
⚝ virtual void writeReady(uint16_t events) noexcept: 当关联的文件描述符可写时被调用。events 参数指示了就绪的事件类型。通常在 WriteEventHandler 中重写。
⚝ virtual void timerExpired() noexcept: 当定时器超时时被调用。通常在 TimerEventHandler 中重写。
⚝ virtual void signalReceived() noexcept: 当注册的信号到达时被调用。通常在 SignalHandler 中重写。
⚝ virtual void userEventReady() noexcept: 当用户自定义事件就绪时被调用。通常在 UserEventHandler 中重写。
⚝ virtual void eventReady(uint16_t events) noexcept: 通用的事件就绪回调函数。当任何类型的事件就绪时都会被调用。events 参数指示了就绪的事件类型。可以根据 events 参数判断具体事件类型，并进行相应的处理。
⚝ virtual void destroy() noexcept: 当 EventHandler 对象即将被销毁时被调用。可以在此函数中释放资源或执行清理操作。
1
#include <folly/EventBase.h>
2
#include <folly/EventHandler.h>
3
#include <iostream>
4
#include <sys/types.h>
5
#include <sys/socket.h>
6
#include <netinet/in.h>
7
#include <unistd.h>
8
9
class MyReadHandler : public folly::ReadEventHandler {
10
public:
11
MyReadHandler(folly::EventBase* evb, int fd) : folly::ReadEventHandler(evb, fd) {}
12
13
void readReady(uint16_t events) noexcept override {
14
if (events & EventHandler::READ) {
15
char buffer[1024];
16
ssize_t bytesRead = ::recv(fd_, buffer, sizeof(buffer), 0);
17
if (bytesRead > 0) {
18
std::cout << "Received data: " << std::string(buffer, bytesRead) << std::endl;
19
} else if (bytesRead == 0) {
20
std::cout << "Connection closed by peer." << std::endl;
21
getEventBase()->removeHandler(this); // 移除事件处理器
22
delete this; // 销毁事件处理器
23
::close(fd_); // 关闭文件描述符
24
} else {
25
perror("recv");
26
getEventBase()->removeHandler(this);
27
delete this;
28
::close(fd_);
29
}
30
} else if (events & EventHandler::ERROR) {
31
std::cerr << "Error on socket." << std::endl;
32
getEventBase()->removeHandler(this);
33
delete this;
34
::close(fd_);
35
}
36
}
37
38
void destroy() noexcept override {
39
std::cout << "MyReadHandler destroyed." << std::endl;
40
}
41
};
42
43
int main() {
44
folly::EventBase evb;
45
int listenFd = socket(AF_INET, SOCK_STREAM, 0);
46
if (listenFd < 0) {
47
perror("socket");
48
return 1;
49
}
50
51
sockaddr_in serverAddr;
52
serverAddr.sin_family = AF_INET;
53
serverAddr.sin_addr.s_addr = INADDR_ANY;
54
serverAddr.sin_port = htons(8080);
55
56
if (bind(listenFd, (sockaddr*)&serverAddr, sizeof(serverAddr)) < 0) {
57
perror("bind");
58
::close(listenFd);
59
return 1;
60
}
61
62
if (listen(listenFd, 5) < 0) {
63
perror("listen");
64
::close(listenFd);
65
return 1;
66
}
67
68
std::thread loopThread([&evb]() {
69
evb.loop();
70
});
71
72
while (true) {
73
sockaddr_in clientAddr;
74
socklen_t clientAddrLen = sizeof(clientAddr);
75
int clientFd = accept(listenFd, (sockaddr*)&clientAddr, &clientAddrLen);
76
if (clientFd < 0) {
77
perror("accept");
78
continue;
79
}
80
new MyReadHandler(&evb, clientFd); // 创建 MyReadHandler 并自动添加到 EventBase
81
}
82
83
evb.terminateLoopSoon();
84
loopThread.join();
85
::close(listenFd);
86
return 0;
87
}
5.2.4 预定义的 EventHandler 子类 (Predefined EventHandler Subclasses)
folly/EventBase.h 提供了多个预定义的 EventHandler 子类，方便用户处理常见的事件类型。
5.2.4.1 ReadEventHandler 和 WriteEventHandler
ReadEventHandler 和 WriteEventHandler 分别用于处理文件描述符上的读就绪和写就绪事件。它们是基于文件描述符事件处理的基础类。
⚝ ReadEventHandler(EventBase* evb, int fd, EventHandler::EventHandlerFlags flags = EventHandler::READ_PERSIST): ReadEventHandler 的构造函数。evb 是关联的 EventBase 实例，fd 是文件描述符，flags 是事件标志，默认为 READ_PERSIST，表示持续监听读就绪事件。
⚝ WriteEventHandler(EventBase* evb, int fd, EventHandler::EventHandlerFlags flags = EventHandler::WRITE_PERSIST): WriteEventHandler 的构造函数。参数含义与 ReadEventHandler 类似，默认为 WRITE_PERSIST，表示持续监听写就绪事件。
常用标志 (Common Flags):
⚝ EventHandler::READ: 监听读就绪事件。
⚝ EventHandler::WRITE: 监听写就绪事件。
⚝ EventHandler::PERSIST: 事件就绪后，事件处理器不会被自动移除，会持续监听该事件。通常与 READ 或 WRITE 组合使用，例如 READ_PERSIST 或 WRITE_PERSIST。
⚝ EventHandler::ONE_SHOT: 事件就绪一次后，事件处理器会被自动移除。通常用于处理一次性事件。
⚝ EventHandler::ET: 使用边缘触发 (Edge-Triggered) 模式。默认情况下，EventBase 使用水平触发 (Level-Triggered) 模式。边缘触发模式需要更谨慎的处理，以避免事件丢失。
1
#include <folly/EventBase.h>
2
#include <folly/EventHandler.h>
3
#include <iostream>
4
#include <sys/types.h>
5
#include <sys/socket.h>
6
#include <netinet/in.h>
7
#include <unistd.h>
8
9
class EchoHandler : public folly::ReadEventHandler, public folly::WriteEventHandler {
10
public:
11
EchoHandler(folly::EventBase* evb, int fd)
12
: folly::ReadEventHandler(evb, fd, folly::EventHandler::READ_PERSIST),
13
folly::WriteEventHandler(evb, fd, folly::EventHandler::WRITE_PERSIST),
14
fd_(fd) {}
15
16
void readReady(uint16_t events) noexcept override {
17
if (events & EventHandler::READ) {
18
char buffer[1024];
19
ssize_t bytesRead = ::recv(fd_, buffer, sizeof(buffer), 0);
20
if (bytesRead > 0) {
21
// 将接收到的数据回显
22
::send(fd_, buffer, bytesRead, 0);
23
} else if (bytesRead == 0) {
24
std::cout << "Connection closed by peer." << std::endl;
25
closeConnection();
26
} else {
27
perror("recv");
28
closeConnection();
29
}
30
} else if (events & EventHandler::ERROR) {
31
std::cerr << "Error on socket." << std::endl;
32
closeConnection();
33
}
34
}
35
36
void writeReady(uint16_t events) noexcept override {
37
// 在本例中，回显服务器不需要显式处理写就绪事件，
38
// 因为 send 操作通常不会阻塞，除非发送缓冲区满。
39
// 在更复杂的场景中，可能需要在写就绪事件中发送数据。
40
}
41
42
void destroy() noexcept override {
43
std::cout << "EchoHandler destroyed." << std::endl;
44
}
45
46
private:
47
void closeConnection() {
48
getEventBase()->removeHandler(this);
49
delete this;
50
::close(fd_);
51
}
52
53
private:
54
int fd_;
55
};
56
57
58
int main() {
59
folly::EventBase evb;
60
int listenFd = socket(AF_INET, SOCK_STREAM, 0);
61
// ... (socket, bind, listen 代码与上例相同) ...
62
63
std::thread loopThread([&evb]() {
64
evb.loop();
65
});
66
67
while (true) {
68
sockaddr_in clientAddr;
69
socklen_t clientAddrLen = sizeof(clientAddr);
70
int clientFd = accept(listenFd, (sockaddr*)&clientAddr, &clientAddrLen);
71
if (clientFd < 0) {
72
perror("accept");
73
continue;
74
}
75
new EchoHandler(&evb, clientFd); // 创建 EchoHandler
76
}
77
78
evb.terminateLoopSoon();
79
loopThread.join();
80
::close(listenFd);
81
return 0;
82
}
5.2.4.2 TimerHandler 和 SignalHandler
TimerHandler 和 SignalHandler 是专门用于处理定时器事件和信号事件的类，将在下一节详细介绍。
5.2.4.3 UserEventHandler
UserEventHandler 用于处理用户自定义事件。用户可以通过 EventBase::setUserEvent() 和 EventBase::clearUserEvent() API 手动触发和清除用户事件。这为在 EventBase 线程中处理自定义逻辑提供了一种机制。
⚝ UserEventHandler(EventBase* evb): UserEventHandler 的构造函数。evb 是关联的 EventBase 实例。
1
#include <folly/EventBase.h>
2
#include <folly/EventHandler.h>
3
#include <iostream>
4
5
class MyUserEventHandler : public folly::UserEventHandler {
6
public:
7
MyUserEventHandler(folly::EventBase* evb) : folly::UserEventHandler(evb) {}
8
9
void userEventReady() noexcept override {
10
std::cout << "User event ready!" << std::endl;
11
// 处理用户自定义事件逻辑
12
}
13
};
14
15
int main() {
16
folly::EventBase evb;
17
MyUserEventHandler userEventHandler(&evb);
18
19
std::thread loopThread([&evb]() {
20
evb.loop();
21
});
22
23
std::this_thread::sleep_for(std::chrono::seconds(1));
24
evb.setUserEvent(&userEventHandler); // 触发用户事件
25
26
std::this_thread::sleep_for(std::chrono::seconds(1));
27
evb.clearUserEvent(&userEventHandler); // 清除用户事件
28
29
std::this_thread::sleep_for(std::chrono::seconds(1));
30
evb.terminateLoopSoon();
31
loopThread.join();
32
return 0;
33
}
5.2.5 自定义 EventHandler (Custom EventHandler)
除了使用预定义的 EventHandler 子类，用户还可以根据需要自定义 EventHandler。自定义 EventHandler 的步骤如下：
① 继承 EventHandler 类。
② 重写需要处理的事件对应的虚函数，例如 readReady(), writeReady(), timerExpired(), signalReceived(), userEventReady() 或 eventReady()。
③ 在构造函数中调用 EventHandler 的构造函数，并传入 EventBase 实例和相关参数（例如文件描述符）。
④ 在事件处理函数中实现具体的事件处理逻辑。
⑤ 在适当的时候，使用 getEventBase()->removeHandler(this) 移除事件处理器，并使用 delete this 销毁事件处理器，同时关闭相关的文件描述符或其他资源。
5.2.6 总结 (Summary)
EventHandler 类族是 folly/EventBase.h 库中用于处理各种事件的核心组件。本节详细介绍了 EventHandler 的设计理念、继承关系、虚函数以及预定义的 EventHandler 子类，包括 ReadEventHandler, WriteEventHandler, 和 UserEventHandler。通过学习本节内容，读者应该能够理解 EventHandler 的工作原理，掌握如何使用预定义的 EventHandler 子类处理常见事件，以及如何自定义 EventHandler 来满足特定的需求。掌握 EventHandler 类族是深入理解和应用 folly/EventBase.h 的关键。
5.3 TimerHandler 和 SignalHandler (TimerHandler and SignalHandler)
TimerHandler 和 SignalHandler 是 folly/EventBase.h 库中用于处理定时器事件和信号事件的专用类。它们都继承自 EventHandler，并提供了更高级别的 API 来简化定时器和信号事件的处理。本节将详细介绍 TimerHandler 和 SignalHandler 的使用方法、API 以及应用场景。
5.3.1 TimerHandler 详解 (Detailed Explanation of TimerHandler)
TimerHandler 用于在 EventBase 中注册和管理定时器事件。定时器事件会在指定的时间点或周期性地触发，并调用用户定义的回调函数。
5.3.1.1 TimerHandler 的构造与启动 (Construction and Startup of TimerHandler)
⚝ TimerHandler(EventBase* evb, std::function<void()> callback): TimerHandler 的构造函数。evb 是关联的 EventBase 实例，callback 是定时器超时时要调用的回调函数，类型为 std::function<void()>。
⚝ void startTimeout(std::chrono::milliseconds timeout): 启动单次定时器，在 timeout 毫秒后触发回调函数。
⚝ void startTimeout(std::chrono::milliseconds timeout, std::chrono::milliseconds repeatInterval): 启动周期性定时器，在 timeout 毫秒后首次触发回调函数，之后每隔 repeatInterval 毫秒触发一次。
1
#include <folly/EventBase.h>
2
#include <folly/TimerHandler.h>
3
#include <iostream>
4
5
void singleTimerCallback() {
6
std::cout << "Single timer expired!" << std::endl;
7
}
8
9
void periodicTimerCallback() {
10
static int count = 0;
11
std::cout << "Periodic timer expired, count: " << ++count << std::endl;
12
if (count >= 5) {
13
std::cout << "Stopping periodic timer." << std::endl;
14
// 在回调函数中停止定时器
15
folly::TimerHandler* timer = folly::TimerHandler::currentTimerHandler();
16
if (timer) {
17
timer->stopTimeout();
18
}
19
}
20
}
21
22
int main() {
23
folly::EventBase evb;
24
25
// 单次定时器
26
folly::TimerHandler singleTimer(&evb, singleTimerCallback);
27
singleTimer.startTimeout(std::chrono::seconds(1));
28
29
// 周期性定时器
30
folly::TimerHandler periodicTimer(&evb, periodicTimerCallback);
31
periodicTimer.startTimeout(std::chrono::seconds(2), std::chrono::seconds(1)); // 2秒后首次触发，之后每隔1秒触发
32
33
std::thread loopThread([&evb]() {
34
evb.loop();
35
});
36
37
loopThread.join();
38
return 0;
39
}
5.3.1.2 TimerHandler 的停止与重置 (Stopping and Resetting TimerHandler)
⚝ void stopTimeout(): 停止定时器。如果定时器正在运行，则停止计时，并取消后续的超时事件。
⚝ void rescheduleTimeout(std::chrono::milliseconds timeout): 重置单次定时器，将超时时间设置为 timeout 毫秒，并重新开始计时。如果定时器已经启动，则会取消之前的超时设置，并使用新的超时时间。
⚝ void rescheduleTimeout(std::chrono::milliseconds timeout, std::chrono::milliseconds repeatInterval): 重置周期性定时器，将首次超时时间设置为 timeout 毫秒，周期设置为 repeatInterval 毫秒，并重新开始计时。
1
#include <folly/EventBase.h>
2
#include <folly/TimerHandler.h>
3
#include <iostream>
4
5
void timerCallback() {
6
static int count = 0;
7
std::cout << "Timer expired, count: " << ++count << std::endl;
8
}
9
10
int main() {
11
folly::EventBase evb;
12
folly::TimerHandler timer(&evb, timerCallback);
13
14
timer.startTimeout(std::chrono::seconds(1)); // 启动定时器，1秒后触发
15
16
std::this_thread::sleep_for(std::chrono::milliseconds(500));
17
timer.rescheduleTimeout(std::chrono::seconds(2)); // 0.5秒后，重置定时器为2秒后触发
18
19
std::this_thread::sleep_for(std::chrono::seconds(3));
20
timer.stopTimeout(); // 3.5秒后，停止定时器
21
22
std::thread loopThread([&evb]() {
23
evb.loop();
24
});
25
26
loopThread.join();
27
return 0;
28
}
5.3.1.3 TimerHandler 的静态方法 (Static Methods of TimerHandler)
⚝ static TimerHandler* currentTimerHandler(): 静态方法，返回当前正在执行的定时器回调函数所关联的 TimerHandler 实例的指针。只能在 TimerHandler 的回调函数内部调用。如果当前不在 TimerHandler 的回调函数中，则返回 nullptr。
1
#include <folly/EventBase.h>
2
#include <folly/TimerHandler.h>
3
#include <iostream>
4
5
void timerCallback() {
6
folly::TimerHandler* timer = folly::TimerHandler::currentTimerHandler();
7
if (timer) {
8
std::cout << "Timer callback executed by TimerHandler: " << timer << std::endl;
9
} else {
10
std::cout << "Timer callback executed, but currentTimerHandler() returned nullptr." << std::endl;
11
}
12
}
13
14
int main() {
15
folly::EventBase evb;
16
folly::TimerHandler timer(&evb, timerCallback);
17
timer.startTimeout(std::chrono::seconds(1));
18
19
std::thread loopThread([&evb]() {
20
evb.loop();
21
});
22
23
loopThread.join();
24
return 0;
25
}
5.3.1.4 TimerHandler 的应用场景 (Application Scenarios of TimerHandler)
⚝ 定期任务 (Periodic Tasks)：例如，定时发送心跳包、定期清理缓存、定时轮询状态等。可以使用周期性定时器来实现。
⚝ 延迟执行 (Delayed Execution)：例如，延迟一段时间后执行某个操作，可以使用单次定时器来实现。
⚝ 超时管理 (Timeout Management)：例如，设置网络请求的超时时间，如果在指定时间内没有收到响应，则触发超时处理。可以使用单次定时器来监控操作的超时。
⚝ 动画和游戏 (Animation and Games)：在图形界面程序和游戏中，可以使用定时器来驱动动画效果或游戏逻辑的更新。
5.3.2 SignalHandler 详解 (Detailed Explanation of SignalHandler)
SignalHandler 用于在 EventBase 中注册和处理信号事件。信号是操作系统用于通知进程发生了某些事件的机制，例如用户按下 Ctrl+C 产生的 SIGINT 信号、进程接收到 SIGTERM 信号等。
5.3.2.1 SignalHandler 的构造与注册 (Construction and Registration of SignalHandler)
⚝ SignalHandler(EventBase* evb, std::function<void()> callback): SignalHandler 的构造函数。evb 是关联的 EventBase 实例，callback 是信号到达时要调用的回调函数，类型为 std::function<void()>。
⚝ void registerSignalHandler(int signal): 注册信号处理器，监听指定的信号 signal。可以多次调用 registerSignalHandler() 注册多个信号的处理。
1
#include <folly/EventBase.h>
2
#include <folly/SignalHandler.h>
3
#include <iostream>
4
#include <csignal>
5
6
void sigintCallback() {
7
std::cout << "SIGINT received!" << std::endl;
8
folly::EventBase* evb = folly::EventBase::current();
9
if (evb) {
10
evb->terminateLoopSoon(); // 收到 SIGINT 信号后终止事件循环
11
}
12
}
13
14
void sigtermCallback() {
15
std::cout << "SIGTERM received!" << std::endl;
16
folly::EventBase* evb = folly::EventBase::current();
17
if (evb) {
18
evb->terminateLoopSoon(); // 收到 SIGTERM 信号后终止事件循环
19
}
20
}
21
22
int main() {
23
folly::EventBase evb;
24
25
folly::SignalHandler sigintHandler(&evb, sigintCallback);
26
sigintHandler.registerSignalHandler(SIGINT); // 注册 SIGINT 信号处理器
27
28
folly::SignalHandler sigtermHandler(&evb, sigtermCallback);
29
sigtermHandler.registerSignalHandler(SIGTERM); // 注册 SIGTERM 信号处理器
30
31
std::thread loopThread([&evb]() {
32
evb.loop();
33
});
34
35
std::cout << "Waiting for signals (SIGINT or SIGTERM)..." << std::endl;
36
loopThread.join();
37
std::cout << "Event loop exited." << std::endl;
38
return 0;
39
}
5.3.2.2 SignalHandler 的注销 (Unregistration of SignalHandler)
⚝ void unregisterSignalHandler(int signal): 注销信号处理器，停止监听指定的信号 signal。
1
#include <folly/EventBase.h>
2
#include <folly/SignalHandler.h>
3
#include <iostream>
4
#include <csignal>
5
6
void signalCallback() {
7
std::cout << "Signal received!" << std::endl;
8
}
9
10
int main() {
11
folly::EventBase evb;
12
folly::SignalHandler signalHandler(&evb, signalCallback);
13
14
signalHandler.registerSignalHandler(SIGUSR1); // 注册 SIGUSR1 信号处理器
15
std::cout << "Registered SIGUSR1 handler." << std::endl;
16
17
std::this_thread::sleep_for(std::chrono::seconds(5));
18
signalHandler.unregisterSignalHandler(SIGUSR1); // 注销 SIGUSR1 信号处理器
19
std::cout << "Unregistered SIGUSR1 handler." << std::endl;
20
21
std::cout << "Sending SIGUSR1 signal to self (after unregistration)..." << std::endl;
22
::kill(::getpid(), SIGUSR1); // 发送 SIGUSR1 信号给自己，此时应该不会触发回调函数
23
24
std::thread loopThread([&evb]() {
25
evb.loop();
26
});
27
28
std::this_thread::sleep_for(std::chrono::seconds(1));
29
evb.terminateLoopSoon();
30
loopThread.join();
31
return 0;
32
}
5.3.2.3 SignalHandler 的静态方法 (Static Methods of SignalHandler)
⚝ static SignalHandler* currentSignalHandler(): 静态方法，返回当前正在执行的信号回调函数所关联的 SignalHandler 实例的指针。只能在 SignalHandler 的回调函数内部调用。如果当前不在 SignalHandler 的回调函数中，则返回 nullptr。
1
#include <folly/EventBase.h>
2
#include <folly/SignalHandler.h>
3
#include <iostream>
4
#include <csignal>
5
6
void signalCallback() {
7
folly::SignalHandler* signalHandler = folly::SignalHandler::currentSignalHandler();
8
if (signalHandler) {
9
std::cout << "Signal callback executed by SignalHandler: " << signalHandler << std::endl;
10
} else {
11
std::cout << "Signal callback executed, but currentSignalHandler() returned nullptr." << std::endl;
12
}
13
}
14
15
int main() {
16
folly::EventBase evb;
17
folly::SignalHandler signalHandler(&evb, signalCallback);
18
signalHandler.registerSignalHandler(SIGUSR2);
19
20
std::thread loopThread([&evb]() {
21
evb.loop();
22
});
23
24
std::cout << "Sending SIGUSR2 signal to self..." << std::endl;
25
::kill(::getpid(), SIGUSR2); // 发送 SIGUSR2 信号给自己
26
27
std::this_thread::sleep_for(std::chrono::seconds(1));
28
evb.terminateLoopSoon();
29
loopThread.join();
30
return 0;
31
}
5.3.2.4 SignalHandler 的应用场景 (Application Scenarios of SignalHandler)
⚝ 程序优雅退出 (Graceful Shutdown)： 监听 SIGINT 和 SIGTERM 信号，在收到信号后执行清理操作，例如关闭网络连接、释放资源等，然后优雅地退出程序。
⚝ 信号处理 (Signal Handling)： 处理各种操作系统信号，例如 SIGHUP (配置重载)、SIGCHLD (子进程状态变化) 等，根据信号类型执行相应的操作。
⚝ 进程间通信 (Inter-Process Communication)： 使用用户自定义信号 (例如 SIGUSR1, SIGUSR2) 进行进程间通信。
5.3.3 总结 (Summary)
TimerHandler 和 SignalHandler 是 folly/EventBase.h 库中用于处理定时器事件和信号事件的重要组件。TimerHandler 提供了方便的 API 来创建、启动、停止和重置定时器，适用于各种需要定时执行任务的场景。SignalHandler 允许程序监听和处理操作系统信号，实现优雅退出、信号处理和进程间通信等功能。本节详细介绍了 TimerHandler 和 SignalHandler 的 API、使用方法和应用场景，帮助读者掌握如何使用这两个类来处理定时器事件和信号事件。
5.4 文件描述符操作 API (File Descriptor Operation APIs)
folly/EventBase.h 提供了直接操作文件描述符事件的 API，允许用户更灵活地控制文件描述符事件的注册、修改和移除。这些 API 主要通过 EventBase 类的方法来实现，例如 addHandler(), modHandler(), removeHandler() 等。本节将详细介绍这些文件描述符操作 API 的使用方法、事件标志以及错误处理。
5.4.1 添加文件描述符事件处理器 (addHandler())
⚝ void addHandler(EventHandler* handler, int fd, EventHandler::EventHandlerFlags flags): 将事件处理器 handler 关联到文件描述符 fd，并注册到 EventBase 中。flags 参数指定了要监听的事件类型和行为。
参数说明:
⚝ handler: 指向 EventHandler 派生类实例的指针。该事件处理器将负责处理文件描述符 fd 上的事件。
⚝ fd: 要监听的文件描述符。
⚝ flags: 事件标志，用于指定要监听的事件类型和行为。常用的标志包括：
▮▮▮▮⚝ EventHandler::READ: 监听读就绪事件。
▮▮▮▮⚝ EventHandler::WRITE: 监听写就绪事件。
▮▮▮▮⚝ EventHandler::PERSIST: 事件就绪后，事件处理器不会被自动移除，会持续监听该事件。
▮▮▮▮⚝ EventHandler::ONE_SHOT: 事件就绪一次后，事件处理器会被自动移除。
▮▮▮▮⚝ EventHandler::ET: 使用边缘触发模式。
1
#include <folly/EventBase.h>
2
#include <folly/EventHandler.h>
3
#include <iostream>
4
#include <sys/types.h>
5
#include <sys/socket.h>
6
#include <netinet/in.h>
7
#include <unistd.h>
8
9
class MyFDHandler : public folly::EventHandler {
10
public:
11
MyFDHandler(folly::EventBase* evb, int fd) : folly::EventHandler(evb), fd_(fd) {}
12
13
void eventReady(uint16_t events) noexcept override {
14
if (events & EventHandler::READ) {
15
char buffer[1024];
16
ssize_t bytesRead = ::recv(fd_, buffer, sizeof(buffer), 0);
17
if (bytesRead > 0) {
18
std::cout << "Received data: " << std::string(buffer, bytesRead) << std::endl;
19
} else if (bytesRead == 0) {
20
std::cout << "Connection closed by peer." << std::endl;
21
closeConnection();
22
} else {
23
perror("recv");
24
closeConnection();
25
}
26
} else if (events & EventHandler::ERROR) {
27
std::cerr << "Error on socket." << std::endl;
28
closeConnection();
29
}
30
}
31
32
void destroy() noexcept override {
33
std::cout << "MyFDHandler destroyed." << std::endl;
34
}
35
36
private:
37
void closeConnection() {
38
getEventBase()->removeHandler(this);
39
delete this;
40
::close(fd_);
41
}
42
43
private:
44
int fd_;
45
};
46
47
48
int main() {
49
folly::EventBase evb;
50
int listenFd = socket(AF_INET, SOCK_STREAM, 0);
51
// ... (socket, bind, listen 代码与之前示例相同) ...
52
53
std::thread loopThread([&evb]() {
54
evb.loop();
55
});
56
57
while (true) {
58
sockaddr_in clientAddr;
59
socklen_t clientAddrLen = sizeof(clientAddr);
60
int clientFd = accept(listenFd, (sockaddr*)&clientAddr, &clientAddrLen);
61
if (clientFd < 0) {
62
perror("accept");
63
continue;
64
}
65
MyFDHandler* fdHandler = new MyFDHandler(&evb, clientFd);
66
evb.addHandler(fdHandler, clientFd, folly::EventHandler::READ_PERSIST); // 使用 addHandler 添加事件处理器
67
}
68
69
evb.terminateLoopSoon();
70
loopThread.join();
71
::close(listenFd);
72
return 0;
73
}
5.4.2 修改文件描述符事件处理器 (modHandler())
⚝ void modHandler(EventHandler* handler, EventHandler::EventHandlerFlags flags): 修改已注册的事件处理器 handler 的事件标志 flags。通常用于动态地改变事件处理器监听的事件类型或行为。
参数说明:
⚝ handler: 指向要修改的 EventHandler 实例的指针。该事件处理器必须已经通过 addHandler() 注册到 EventBase 中。
⚝ flags: 新的事件标志。
1
#include <folly/EventBase.h>
2
#include <folly/EventHandler.h>
3
#include <iostream>
4
#include <sys/types.h>
5
#include <sys/socket.h>
6
#include <netinet/in.h>
7
#include <unistd.h>
8
9
class RWHandler : public folly::EventHandler {
10
public:
11
RWHandler(folly::EventBase* evb, int fd) : folly::EventHandler(evb), fd_(fd), state_(State::READING) {}
12
13
enum class State {
14
READING,
15
WRITING
16
};
17
18
void eventReady(uint16_t events) noexcept override {
19
if (state_ == State::READING && (events & EventHandler::READ)) {
20
char buffer[1024];
21
ssize_t bytesRead = ::recv(fd_, buffer, sizeof(buffer), 0);
22
if (bytesRead > 0) {
23
std::cout << "Received data: " << std::string(buffer, bytesRead) << std::endl;
24
// 接收到数据后，切换到写状态，开始监听写就绪事件
25
state_ = State::WRITING;
26
getEventBase()->modHandler(this, folly::EventHandler::WRITE_PERSIST); // 修改为监听写就绪事件
27
} else if (bytesRead == 0) {
28
std::cout << "Connection closed by peer." << std::endl;
29
closeConnection();
30
} else {
31
perror("recv");
32
closeConnection();
33
}
34
} else if (state_ == State::WRITING && (events & EventHandler::WRITE)) {
35
const char* message = "Hello from server!\n";
36
ssize_t bytesSent = ::send(fd_, message, strlen(message), 0);
37
if (bytesSent > 0) {
38
std::cout << "Sent message to client." << std::endl;
39
// 发送数据后，切换回读状态，继续监听读就绪事件
40
state_ = State::READING;
41
getEventBase()->modHandler(this, folly::EventHandler::READ_PERSIST); // 修改为监听读就绪事件
42
} else {
43
perror("send");
44
closeConnection();
45
}
46
} else if (events & EventHandler::ERROR) {
47
std::cerr << "Error on socket." << std::endl;
48
closeConnection();
49
}
50
}
51
52
void destroy() noexcept override {
53
std::cout << "RWHandler destroyed." << std::endl;
54
}
55
56
private:
57
void closeConnection() {
58
getEventBase()->removeHandler(this);
59
delete this;
60
::close(fd_);
61
}
62
63
private:
64
int fd_;
65
State state_;
66
};
67
68
69
int main() {
70
folly::EventBase evb;
71
int listenFd = socket(AF_INET, SOCK_STREAM, 0);
72
// ... (socket, bind, listen 代码与之前示例相同) ...
73
74
std::thread loopThread([&evb]() {
75
evb.loop();
76
});
77
78
while (true) {
79
sockaddr_in clientAddr;
80
socklen_t clientAddrLen = sizeof(clientAddr);
81
int clientFd = accept(listenFd, (sockaddr*)&clientAddr, &clientAddrLen);
82
if (clientFd < 0) {
83
perror("accept");
84
continue;
85
}
86
RWHandler* rwHandler = new RWHandler(&evb, clientFd);
87
evb.addHandler(rwHandler, clientFd, folly::EventHandler::READ_PERSIST); // 初始监听读就绪事件
88
}
89
90
evb.terminateLoopSoon();
91
loopThread.join();
92
::close(listenFd);
93
return 0;
94
}
5.4.3 移除文件描述符事件处理器 (removeHandler())
⚝ void removeHandler(EventHandler* handler): 从 EventBase 中移除已注册的事件处理器 handler。移除后，EventBase 将不再监听与该事件处理器关联的文件描述符上的事件。
参数说明:
⚝ handler: 指向要移除的 EventHandler 实例的指针。该事件处理器必须已经通过 addHandler() 注册到 EventBase 中。
注意： removeHandler() 只会从 EventBase 中移除事件处理器，不会销毁 EventHandler 对象本身，也不会关闭文件描述符。用户需要手动 delete handler 销毁事件处理器对象，并使用 ::close(fd) 关闭文件描述符（如果需要）。通常在事件处理器的 destroy() 虚函数或事件处理回调函数中进行清理操作。
5.4.4 文件描述符操作的错误处理 (Error Handling for File Descriptor Operations)
文件描述符操作可能会遇到各种错误，例如文件描述符无效、资源不足等。folly/EventBase.h 并没有提供专门的错误处理 API，错误通常会通过以下方式报告：
⚝ eventReady() 回调函数的 events 参数: eventReady() 回调函数的 events 参数会包含 EventHandler::ERROR 标志，表示文件描述符上发生了错误。事件处理器应该检查 events 参数，如果包含 EventHandler::ERROR 标志，则进行相应的错误处理，例如关闭连接、释放资源等。
⚝ 系统调用错误: 底层的系统调用（例如 recv(), send(), poll() 等）可能会返回错误，例如 recv() 返回 -1 并设置 errno。事件处理器应该检查系统调用的返回值，如果发生错误，则使用 perror() 输出错误信息，并进行相应的错误处理。
5.4.5 文件描述符操作 API 的应用场景 (Application Scenarios of File Descriptor Operation APIs)
⚝ 网络编程 (Network Programming)： 使用 addHandler(), modHandler(), removeHandler() API 可以灵活地管理网络连接的读写事件，实现高性能的网络服务器和客户端。
⚝ 管道和 FIFO (Pipes and FIFOs)： 可以使用文件描述符操作 API 监听管道和 FIFO 的读写事件，实现进程间通信。
⚝ 终端设备 (Terminal Devices)： 可以监听终端设备的文件描述符，处理用户输入事件。
⚝ 自定义事件源 (Custom Event Sources)： 可以将自定义的文件描述符（例如由 eventfd() 或 pipe() 创建的文件描述符）与 EventBase 集成，实现自定义的事件源。
5.4.6 总结 (Summary)
folly/EventBase.h 提供的文件描述符操作 API (addHandler(), modHandler(), removeHandler()) 允许用户直接操作文件描述符事件，提供了更底层的控制能力和灵活性。本节详细介绍了这些 API 的使用方法、事件标志、错误处理以及应用场景。掌握这些 API 可以帮助读者构建更复杂、更高效的事件驱动应用程序，尤其是在网络编程和系统编程领域。通过灵活运用文件描述符操作 API，可以充分发挥 folly/EventBase.h 的性能优势，构建高性能的事件驱动系统。
END_OF_CHAPTER
6. chapter 6： EventBase 与 Folly 库其他组件集成 (Integration of EventBase with other Folly Library Components)
6.1 使用 Folly Futures 简化异步编程 (Simplifying Asynchronous Programming with Folly Futures)
在现代高性能 C++ 应用开发中，异步编程范式占据着至关重要的地位。folly::EventBase 作为强大的事件循环库，为构建事件驱动的应用提供了坚实的基础。然而，纯粹的事件回调方式在处理复杂的异步流程时，容易陷入“回调地狱（Callback Hell）”，代码可读性和维护性都会急剧下降。为了解决这个问题，folly::Future 应运而生，它提供了一种更优雅、更易于组合和管理的异步编程模型。本节将深入探讨 EventBase 如何与 Future 协同工作，以简化异步编程，提升代码质量。
6.1.1 Futures 简介 (Introduction to Futures)
Future 是一种表示异步操作结果的对象。它代表着一个可能尚未完成的计算结果，并提供了一种在结果可用时访问它的机制。Future 的核心思想是将异步操作的结果抽象化，使得我们可以像处理同步操作一样，以链式调用的方式处理异步操作，从而避免了传统回调方式的嵌套和复杂性。
① 核心概念：
⚝ Promise（承诺）：Promise 负责设置 Future 的值。异步操作发起时，会创建一个 Promise 对象，并将与其关联的 Future 对象返回给调用者。当异步操作完成时，Promise 会被“兑现（fulfilled）”或“拒绝（rejected）”，从而设置 Future 的结果或错误状态。
⚝ Future（未来）：Future 代表异步操作的最终结果。调用者可以通过 Future 对象查询操作是否完成，并在操作完成后获取结果。Future 是只读的，一旦被设置值，就不能再修改。
⚝ Executor（执行器）：Executor 负责执行异步任务。在 Folly 中，EventBase 本身就充当了一个 Executor 的角色，可以将任务提交到 EventBase 的事件循环中执行。
② Futures 的优势：
⚝ 线性化异步流程：通过链式调用 .then()、.thenValue()、.thenError() 等操作，可以将复杂的异步流程线性化，使得代码更易于理解和维护。
⚝ 错误处理集中化：Future 提供了统一的错误处理机制，可以使用 .thenError() 或 .catch() 捕获和处理异步操作中的错误，避免了错误处理分散在各个回调函数中的情况。
⚝ 组合性：Future 提供了丰富的组合操作，例如 Future::collect()、Future::race() 等，可以将多个 Future 组合成更复杂的异步流程。
⚝ 与同步代码的桥梁：Future 可以方便地与同步代码进行交互，例如可以使用 .get() 方法阻塞等待 Future 的结果（但应谨慎使用，避免阻塞事件循环）。
6.1.2 EventBase 与 Futures 的集成原理 (Integration Principle of EventBase and Futures)
EventBase 与 Future 的集成是 Folly 异步编程框架的核心组成部分。EventBase 提供了事件循环和事件分发机制，而 Future 提供了异步编程的抽象和组合能力。两者结合，可以构建高效、可维护的异步应用。
① EventBase 作为 Executor：
EventBase 天然地可以作为 Future 的 Executor。通过 EventBase::runInEventBaseThread() 或 EventBase::schedule() 等方法，可以将需要在 EventBase 线程中执行的任务提交给 Future 执行。
② via 操作符：
Folly 提供了 via 操作符，用于将 Future 的后续操作切换到指定的 Executor 上执行。通过 future.via(eventBase)，可以将 Future 的后续操作切换到 eventBase 关联的事件循环线程中执行，从而实现 Future 与 EventBase 的无缝集成。
③ 事件到 Future 的转换：
可以将 EventBase 的事件（例如文件描述符事件、定时器事件、信号事件）转换为 Future。例如，可以使用 AsyncSocket 的 connect() 方法返回一个 Future<Unit>，表示连接操作的完成。
6.1.3 使用 via 将 EventBase 事件转换为 Futures (Using via to Convert EventBase Events to Futures)
via 操作符是连接 EventBase 事件和 Future 的关键桥梁。它允许我们将 Future 的后续操作调度到指定的 EventBase 上执行，确保异步操作在正确的线程和事件循环中进行。
1
#include <folly/EventBase.h>
2
#include <folly/futures/Future.h>
3
#include <iostream>
4
5
using namespace folly;
6
7
Future<int> asyncTask() {
8
// 模拟一个异步任务
9
return via(EventBase::current(), [] {
10
// 假设这里有一些耗时的操作
11
std::cout << "Async task running in EventBase thread." << std::endl;
12
return 42;
13
});
14
}
15
16
int main() {
17
EventBase evb;
18
19
auto futureResult = asyncTask();
20
21
futureResult.thenValue([](int result) {
22
std::cout << "Async task completed with result: " << result << std::endl;
23
}).via(&evb); // 确保 .thenValue() 在 evb 的事件循环中执行
24
25
evb.loop(); // 启动事件循环
26
27
return 0;
28
}
代码解释：
⚝ asyncTask() 函数使用 via(EventBase::current(), ...) 将 lambda 表达式提交到当前 EventBase 线程执行。EventBase::current() 获取当前线程关联的 EventBase 对象。
⚝ futureResult.thenValue(...) 定义了当 asyncTask() 完成时要执行的操作。
⚝ .via(&evb) 确保 .thenValue() 的回调函数在 evb 的事件循环中执行，这对于访问线程安全资源或执行需要在特定 EventBase 上运行的操作至关重要。
⚝ evb.loop() 启动事件循环，使得异步任务得以执行，并处理 Future 完成后的回调。
6.1.4 链式 Futures 操作 (Chaining Futures Operations)
Future 的强大之处在于其链式操作能力。通过 .then()、.thenValue()、.thenError() 等方法，可以将多个异步操作串联起来，形成一个清晰的异步流程。
1
#include <folly/EventBase.h>
2
#include <folly/futures/Future.h>
3
#include <iostream>
4
5
using namespace folly;
6
7
Future<int> task1() {
8
return via(EventBase::current(), [] {
9
std::cout << "Task 1 running." << std::endl;
10
return 10;
11
});
12
}
13
14
Future<int> task2(int input) {
15
return via(EventBase::current(), [input] {
16
std::cout << "Task 2 running with input: " << input << std::endl;
17
return input * 2;
18
});
19
}
20
21
int main() {
22
EventBase evb;
23
24
task1()
25
.thenValue(task2) // 将 task1 的结果传递给 task2
26
.thenValue([](int result) {
27
std::cout << "Final result: " << result << std::endl;
28
})
29
.via(&evb);
30
31
evb.loop();
32
33
return 0;
34
}
代码解释：
⚝ task1() 和 task2() 都是异步任务，返回 Future<int>。
⚝ task1().thenValue(task2) 将 task1() 的结果作为输入传递给 task2()。当 task1() 完成并返回结果后，task2() 会被自动调用，并将 task1() 的结果作为参数传入。
⚝ 整个异步流程被线性地串联起来，代码逻辑清晰易懂。
6.1.5 错误处理 (Error Handling)
Future 提供了完善的错误处理机制，可以使用 .thenError() 和 .catch() 方法捕获和处理异步操作中的错误。
1
#include <folly/EventBase.h>
2
#include <folly/futures/Future.h>
3
#include <folly/exception/UserException.h>
4
#include <stdexcept>
5
#include <iostream>
6
7
using namespace folly;
8
9
Future<int> mayFailTask(bool shouldFail) {
10
return via(EventBase::current(), [shouldFail] {
11
if (shouldFail) {
12
throw UserException("Task failed intentionally.");
13
}
14
return 100;
15
});
16
}
17
18
int main() {
19
EventBase evb;
20
21
mayFailTask(true) // 模拟任务失败
22
.thenValue([](int result) {
23
std::cout << "Task succeeded with result: " << result << std::endl; // 不会被执行
24
})
25
.thenError([](const UserException& e) {
26
std::cerr << "UserException caught: " << e.what() << std::endl;
27
})
28
.catch_exception_type<std::runtime_error>([](const std::runtime_error& e) {
29
std::cerr << "std::runtime_error caught: " << e.what() << std::endl; // 不会被执行
30
})
31
.catch_exception([](const std::exception& e) {
32
std::cerr << "Generic exception caught: " << e.what() << std::endl; // 如果没有 UserException handler，会执行这里
33
})
34
.via(&evb);
35
36
evb.loop();
37
38
return 0;
39
}
代码解释：
⚝ mayFailTask(bool shouldFail) 函数模拟一个可能失败的异步任务。如果 shouldFail 为 true，则抛出 UserException。
⚝ .thenError([](const UserException& e) { ... }) 专门处理 UserException 类型的错误。
⚝ .catch_exception_type<std::runtime_error>(...) 处理特定类型的异常，这里是 std::runtime_error。
⚝ .catch_exception([](const std::exception& e) { ... }) 处理所有 std::exception 类型的异常，作为最后的错误处理兜底。
⚝ 通过这些错误处理方法，可以清晰地定义不同类型错误的应对策略，增强程序的健壮性。
6.1.6 实战案例：基于 Futures 的异步 TCP 客户端 (Practical Case: Asynchronous TCP Client based on Futures)
下面是一个简单的基于 Future 和 EventBase 的异步 TCP 客户端示例，演示了如何使用 Future 简化异步网络编程。
1
#include <folly/EventBase.h>
2
#include <folly/futures/Future.h>
3
#include <folly/io/async/AsyncSocket.h>
4
#include <folly/io/Address.h>
5
#include <iostream>
6
7
using namespace folly;
8
using namespace folly::io;
9
10
Future<Unit> sendData(AsyncSocket& sock, std::string data) {
11
Promise<Unit> promise;
12
sock.write(std::move(data)).then([promise = std::move(promise)](Try<Unit>&& result) mutable {
13
if (result.hasException()) {
14
promise.setException(result.exception());
15
} else {
16
promise.setValue();
17
}
18
});
19
return promise.getFuture();
20
}
21
22
Future<std::string> recvData(AsyncSocket& sock) {
23
Promise<std::string> promise;
24
sock.read().then([promise = std::move(promise)](Try<IOBufQueue>&& result) mutable {
25
if (result.hasException()) {
26
promise.setException(result.exception());
27
} else {
28
auto buf = result.value().move();
29
if (buf) {
30
promise.setValue(buf->moveToFbString().toStdString());
31
} else {
32
promise.setException(std::runtime_error("Connection closed by server."));
33
}
34
}
35
});
36
return promise.getFuture();
37
}
38
39
Future<Unit> runClient(EventBase& evb, Address serverAddress) {
40
auto sock = AsyncSocket::UniquePtr(new AsyncSocket(&evb));
41
return sock->connect(serverAddress)
42
.thenValue([&sock](Unit) mutable {
43
std::cout << "Connected to server." << std::endl;
44
return sendData(*sock, "Hello from client!");
45
})
46
.thenValue([&sock](Unit) mutable {
47
std::cout << "Data sent." << std::endl;
48
return recvData(*sock);
49
})
50
.thenValue([&sock](std::string response) mutable {
51
std::cout << "Received response: " << response << std::endl;
52
sock->close();
53
})
54
.thenError([](const std::exception& e) {
55
std::cerr << "Error: " << e.what() << std::endl;
56
});
57
}
58
59
int main() {
60
EventBase evb;
61
SocketAddress serverAddr("127.0.0.1", 8080); // 替换为实际服务器地址
62
63
runClient(evb, serverAddr).via(&evb);
64
65
evb.loop();
66
67
return 0;
68
}
代码解释：
⚝ sendData() 和 recvData() 函数将 AsyncSocket 的异步 write() 和 read() 操作封装成返回 Future 的函数。
⚝ runClient() 函数使用 Future 链式调用，清晰地表达了客户端的异步流程：连接服务器 -> 发送数据 -> 接收数据 -> 关闭连接。
⚝ 错误处理也通过 .thenError() 集中处理。
⚝ 整个客户端逻辑简洁明了，易于理解和维护。
6.2 与 IO 库的协同工作 (Working with IO Library)
Folly IO 库是构建高性能网络应用的重要组成部分，它提供了 AsyncSocket、AsyncServerSocket 等非阻塞 IO 组件。EventBase 与 IO 库的协同工作，是构建高效事件驱动网络应用的关键。本节将深入探讨 EventBase 如何与 IO 库集成，实现高性能的网络通信。
6.2.1 Folly IO 库概述 (Overview of Folly IO Library)
Folly IO 库提供了一系列用于网络编程的工具和抽象，其核心目标是提供高性能、非阻塞的 IO 操作。
① 核心组件：
⚝ AsyncTransport：AsyncTransport 是 IO 操作的基础接口，定义了读、写、关闭等基本操作。AsyncSocket 和 AsyncServerSocket 都继承自 AsyncTransport。
⚝ AsyncSocket：AsyncSocket 用于客户端网络编程，提供非阻塞的 TCP 连接和数据传输功能。
⚝ AsyncServerSocket：AsyncServerSocket 用于服务器端网络编程，监听端口，接受客户端连接。
⚝ IOBuf 和 IOBufQueue：IOBuf 是 Folly 中用于表示内存缓冲区的类，IOBufQueue 是 IOBuf 的队列，用于高效地管理和操作 IO 数据。
⚝ Address 和 SocketAddress：用于表示网络地址和套接字地址。
② IO 库的特点：
⚝ 非阻塞 IO：IO 库的所有操作都是非阻塞的，不会阻塞事件循环线程，保证了应用的响应性和吞吐量。
⚝ 事件驱动：IO 库与 EventBase 紧密集成，IO 事件（例如可读、可写、连接建立、连接关闭）都通过 EventBase 的事件循环进行处理。
⚝ 高性能：IO 库在设计上注重性能，使用了零拷贝、批量 IO 等技术，最大程度地提升网络通信效率。
⚝ 易用性：IO 库提供了简洁易用的 API，方便开发者构建复杂的网络应用。
6.2.2 使用 AsyncSocket 进行网络 IO (Using AsyncSocket for Network IO)
AsyncSocket 是 Folly IO 库中用于客户端网络编程的核心类。它提供了非阻塞的 TCP 连接、数据发送和接收功能，并与 EventBase 集成，实现事件驱动的网络通信。
① 创建 AsyncSocket：
1
EventBase evb;
2
AsyncSocket::UniquePtr sock(new AsyncSocket(&evb));
AsyncSocket 的构造函数需要一个 EventBase 对象，用于将 AsyncSocket 注册到指定的事件循环中。
② 连接服务器：
1
SocketAddress serverAddr("127.0.0.1", 8080);
2
sock->connect(serverAddr, connectCallback);
connect() 方法用于连接服务器。它接受服务器地址和一个连接回调函数 connectCallback。连接成功或失败时，connectCallback 会被 EventBase 调用。
③ 发送数据：
1
sock->write("Hello server!");
write() 方法用于发送数据。它接受一个 folly::StringPiece 或 IOBuf 对象作为数据。write() 操作是非阻塞的，数据会被放入发送缓冲区，并在 socket 可写时发送出去。
④ 接收数据：
1
sock->read(readCallback);
read() 方法用于接收数据。它接受一个读取回调函数 readCallback。当 socket 可读时，readCallback 会被 EventBase 调用，并传递接收到的数据。
⑤ 关闭连接：
1
sock->close();
close() 方法用于关闭连接。关闭连接后，socket 将不再接收和发送数据。
6.2.3 AsyncServerSocket 和服务器端编程 ( AsyncServerSocket and Server-side Programming)
AsyncServerSocket 是 Folly IO 库中用于服务器端网络编程的核心类。它用于监听端口，接受客户端连接，并创建 AsyncSocket 对象来处理客户端连接。
① 创建 AsyncServerSocket：
1
EventBase evb;
2
AsyncServerSocket::UniquePtr serverSock(new AsyncServerSocket(&evb));
AsyncServerSocket 的构造函数也需要一个 EventBase 对象。
② 绑定地址和监听端口：
1
SocketAddress listenAddr("0.0.0.0", 8080);
2
serverSock->bind(listenAddr);
3
serverSock->listen(1024); // backlog 队列长度
bind() 方法将 AsyncServerSocket 绑定到指定的地址和端口。listen() 方法开始监听端口，并设置 backlog 队列长度。
③ 接受客户端连接：
1
serverSock->setAcceptCallback(acceptCallback);
setAcceptCallback() 方法设置接受连接回调函数 acceptCallback。当有新的客户端连接到达时，acceptCallback 会被 EventBase 调用，并传递新创建的 AsyncSocket 对象。
④ 处理客户端连接：
在 acceptCallback 中，可以获取到新连接的 AsyncSocket 对象，并使用 AsyncSocket 的 read() 和 write() 方法与客户端进行数据交互。
6.2.4 与 EventBase 集成进行事件驱动 IO (Integrating with EventBase for Event-Driven IO)
AsyncSocket 和 AsyncServerSocket 与 EventBase 紧密集成，实现了事件驱动的 IO 操作。
① 事件注册：
当创建 AsyncSocket 或 AsyncServerSocket 对象时，它们会自动注册到指定的 EventBase 中。EventBase 负责监听 socket 上的 IO 事件（例如可读、可写、连接建立、连接关闭）。
② 事件分发：
当 socket 上发生 IO 事件时，EventBase 会将事件分发给 AsyncSocket 或 AsyncServerSocket 对象，并调用相应的回调函数（例如 connectCallback、readCallback、acceptCallback）。
③ 非阻塞操作：
AsyncSocket 和 AsyncServerSocket 的所有 IO 操作都是非阻塞的。当调用 connect()、write()、read() 等方法时，操作会立即返回，不会阻塞事件循环线程。IO 操作的完成状态通过回调函数通知。
④ 高效的事件循环：
EventBase 使用高效的事件循环机制（例如 epoll、kqueue）来监听和分发 IO 事件，保证了网络应用的性能和吞吐量。
6.2.5 IO 库的高级特性 (Advanced Features of IO Library)
Folly IO 库还提供了一些高级特性，进一步提升网络编程的效率和灵活性。
① 零拷贝 (Zero-copy)：
IOBuf 和 IOBufQueue 支持零拷贝操作，例如在发送大文件时，可以直接将文件内容映射到内存，并使用 IOBuf 封装，避免了数据在用户空间和内核空间之间的多次拷贝，提高了传输效率。
② 批量 IO (Batch IO)：
IO 库支持批量读写操作，例如 AsyncSocket::writev() 和 AsyncSocket::readv()，可以将多个 IOBuf 对象一次性写入或读取，减少了系统调用次数，提升了性能。
③ SSL/TLS 支持：
IO 库集成了 OpenSSL 库，提供了 SSL/TLS 加密支持，可以使用 SSLContext 和 SSLAsyncSocket 创建加密的 socket 连接，保障数据传输的安全性。
④ 超时管理：
AsyncSocket 和 AsyncServerSocket 提供了超时管理功能，可以设置连接超时、读超时、写超时等，防止连接hang住或长时间无响应。
6.2.6 实战案例：基于 IO 库和 EventBase 的高性能 HTTP 服务器 (Practical Case: High-Performance HTTP Server based on IO Library and EventBase)
下面是一个简化的基于 Folly IO 库和 EventBase 的 HTTP 服务器框架示例，展示了如何使用 IO 库构建高性能网络服务器。
1
#include <folly/EventBase.h>
2
#include <folly/io/async/AsyncServerSocket.h>
3
#include <folly/io/async/AsyncSocket.h>
4
#include <folly/io/IOBuf.h>
5
#include <folly/String.h>
6
#include <iostream>
7
8
using namespace folly;
9
using namespace folly::io;
10
11
class HttpServerConnection : public AsyncSocket::ReadCallback {
12
public:
13
HttpServerConnection(AsyncSocket::UniquePtr sock) : sock_(std::move(sock)) {}
14
15
void onReadDataAvailable(AsyncSocket* sock) noexcept override {
16
sock->readBufferAvailable();
17
while (auto buf = sock->getReadBuffer()) {
18
processRequest(buf->moveToFbString().toStdString());
19
sock->clearReadBuffer();
20
}
21
sock->readBufferEmpty();
22
}
23
24
void onReadEOF(AsyncSocket* sock) noexcept override {
25
std::cout << "Client disconnected." << std::endl;
26
delete this; // Self-delete when connection closed
27
}
28
29
void onReadError(AsyncSocket* sock, AsyncSocketException ex) noexcept override {
30
std::cerr << "Read error: " << ex.what() << std::endl;
31
delete this; // Self-delete on error
32
}
33
34
private:
35
void processRequest(const std::string& request) {
36
std::cout << "Received request: " << request << std::endl;
37
std::string response = "HTTP/1.1 200 OK\r\nContent-Length: 13\r\nConnection: close\r\n\r\nHello, Client!";
38
sock_->write(IOBuf::copyBuffer(response));
39
sock_->close(); // Simple server, close connection after response
40
}
41
42
private:
43
AsyncSocket::UniquePtr sock_;
44
};
45
46
class HttpServerAcceptCallback : public AsyncServerSocket::AcceptCallback {
47
public:
48
void connectionAccepted(
49
int fd,
50
const SocketAddress& clientAddr,
51
const SocketAddress& /* serverAddr */,
52
AcceptInfo /* acceptInfo */) noexcept override {
53
std::cout << "Accepted connection from " << clientAddr.getAddressStr() << ":" << clientAddr.getPort() << std::endl;
54
EventBase* evb = EventBase::current(); // Get current EventBase
55
AsyncSocket::UniquePtr sock(new AsyncSocket(evb, fd));
56
sock->setReadCallback(new HttpServerConnection(std::move(sock))); // Set read callback and pass ownership
57
sock->read(); // Start reading
58
}
59
60
void acceptError(const AsyncSocketException& ex) noexcept override {
61
std::cerr << "Accept error: " << ex.what() << std::endl;
62
}
63
};
64
65
int main() {
66
EventBase evb;
67
AsyncServerSocket::UniquePtr serverSock(new AsyncServerSocket(&evb));
68
SocketAddress listenAddr("0.0.0.0", 8080);
69
serverSock->bind(listenAddr);
70
serverSock->listen(1024);
71
serverSock->setAcceptCallback(new HttpServerAcceptCallback()); // Set accept callback and pass ownership
72
73
std::cout << "HTTP Server listening on port 8080..." << std::endl;
74
evb.loopForever(); // Start event loop
75
76
return 0;
77
}
代码解释：
⚝ HttpServerConnection 类作为 AsyncSocket::ReadCallback 处理客户端连接的数据读取和请求处理。
⚝ HttpServerAcceptCallback 类作为 AsyncServerSocket::AcceptCallback 处理新连接的接受，并创建 HttpServerConnection 对象来处理每个连接。
⚝ 服务器主循环使用 EventBase::loopForever() 持续监听和处理事件。
⚝ 这个示例展示了如何使用 AsyncServerSocket 和 AsyncSocket 构建一个简单的事件驱动的 HTTP 服务器框架。实际的 HTTP 服务器需要更复杂的请求解析、路由、响应生成等逻辑，但这框架提供了一个基本的起点。
6.3 结合 TaskQueue 实现任务调度 (Implementing Task Scheduling with TaskQueue)
在复杂的应用中，除了处理 IO 事件，还需要执行各种后台任务，例如定时任务、延迟任务、周期性任务等。folly::TaskQueue 提供了一种高效的任务调度机制，可以与 EventBase 协同工作，实现灵活的任务管理。本节将深入探讨 EventBase 如何与 TaskQueue 集成，实现任务调度和管理。
6.3.1 TaskQueue 简介 (Introduction to TaskQueue)
folly::TaskQueue 是一个用于管理和调度任务的类。它允许将任务提交到队列中，并按照一定的策略执行这些任务。TaskQueue 可以与 EventBase 集成，在 EventBase 的事件循环中执行任务，也可以独立于 EventBase 在单独的线程中运行。
① 核心概念：
⚝ Task（任务）：Task 是指需要执行的工作单元，通常是一个函数或 lambda 表达式。
⚝ TaskQueue（任务队列）：TaskQueue 是任务的容器，负责存储和调度任务。
⚝ Executor（执行器）：Executor 负责执行 TaskQueue 中的任务。EventBase 可以作为 TaskQueue 的 Executor。
② TaskQueue 的优势：
⚝ 任务调度：TaskQueue 提供了灵活的任务调度策略，可以控制任务的执行顺序、优先级、延迟执行等。
⚝ 资源管理：TaskQueue 可以限制并发执行的任务数量，防止资源过度消耗。
⚝ 与 EventBase 集成：TaskQueue 可以与 EventBase 无缝集成，在 EventBase 的事件循环中执行任务，避免了线程切换的开销。
⚝ 易用性：TaskQueue 提供了简洁易用的 API，方便开发者进行任务调度和管理。
6.3.2 TaskQueue 的基本用法 (Basic Usage of TaskQueue)
TaskQueue 的基本用法包括创建 TaskQueue 对象、提交任务、启动和停止 TaskQueue 等。
① 创建 TaskQueue：
1
TaskQueue queue; // 创建一个 TaskQueue 对象
TaskQueue 的构造函数可以接受一些参数，例如队列名称、最大并发任务数等。
② 提交任务：
1
queue.add([&]{
2
// 任务代码
3
std::cout << "Task executed." << std::endl;
4
});
add() 方法用于提交任务。它接受一个函数或 lambda 表达式作为参数。任务会被添加到队列末尾，等待执行。
③ 启动和停止 TaskQueue：
1
queue.start(); // 启动 TaskQueue
2
queue.stop(); // 停止 TaskQueue
start() 方法启动 TaskQueue，开始执行队列中的任务。stop() 方法停止 TaskQueue，不再执行新的任务，并等待正在执行的任务完成。
6.3.3 EventBase 与 TaskQueue 的集成 (Integration of EventBase and TaskQueue)
TaskQueue 可以与 EventBase 集成，在 EventBase 的事件循环中执行任务。这可以通过将 EventBase 设置为 TaskQueue 的 Executor 来实现。
① 使用 EventBase 作为 Executor：
1
EventBase evb;
2
TaskQueue queue(&evb); // 创建 TaskQueue，并指定 EventBase 作为 Executor
在创建 TaskQueue 对象时，可以将 EventBase 对象的指针传递给 TaskQueue 的构造函数。这样，TaskQueue 就会使用指定的 EventBase 来执行任务。
② 任务在 EventBase 线程中执行：
当使用 EventBase 作为 Executor 时，提交到 TaskQueue 的任务会在 EventBase 的事件循环线程中执行。这意味着任务可以安全地访问 EventBase 线程中的资源，例如 AsyncSocket 对象。
③ 避免线程切换：
将 TaskQueue 与 EventBase 集成，可以避免线程切换的开销，提高任务执行效率。特别是在需要频繁执行短小任务的场景下，集成 TaskQueue 可以显著提升性能。
6.3.4 使用 TaskQueue 进行延迟任务和周期性任务调度 (Using TaskQueue for Delayed and Periodic Task Scheduling)
TaskQueue 可以方便地实现延迟任务和周期性任务调度。
① 延迟任务：
可以使用 TaskQueue::addDelay() 方法提交延迟任务。
1
queue.addDelay([&]{
2
std::cout << "Delayed task executed after 1 second." << std::endl;
3
}, std::chrono::seconds(1));
addDelay() 方法接受一个任务和一个延迟时间作为参数。任务会在指定的延迟时间后被添加到队列中等待执行。
② 周期性任务：
可以使用 EventBase::runEveryNMilliseconds() 或 EventBase::runAfterDelay() 结合 TaskQueue::add() 实现周期性任务。
1
EventBase evb;
2
TaskQueue queue(&evb);
3
4
evb.runEveryNMilliseconds([&]{
5
queue.add([&]{
6
std::cout << "Periodic task executed." << std::endl;
7
});
8
}, 1000); // 每 1000 毫秒执行一次
使用 EventBase::runEveryNMilliseconds() 定期向 TaskQueue 提交任务，即可实现周期性任务调度。
6.3.5 多线程 TaskQueue (Multi-threaded TaskQueue)
TaskQueue 也支持多线程执行任务。可以通过创建多个 TaskQueue 对象，并在不同的线程中运行这些 TaskQueue，实现并行任务处理。
① 独立的 TaskQueue 线程：
可以创建一个独立的线程，并在该线程中运行 TaskQueue 的事件循环。
1
#include <thread>
2
3
void runTaskQueue() {
4
TaskQueue queue;
5
queue.start(); // 启动 TaskQueue 的事件循环
6
queue.add([&]{
7
std::cout << "Task in TaskQueue thread." << std::endl;
8
});
9
queue.waitUntilIdle(); // 等待所有任务完成
10
queue.stop();
11
}
12
13
int main() {
14
std::thread taskQueueThread(runTaskQueue);
15
taskQueueThread.join();
16
return 0;
17
}
在这个例子中，runTaskQueue() 函数创建并启动了一个 TaskQueue，并在独立的线程中运行。
② 线程池 Executor：
TaskQueue 可以使用线程池作为 Executor，实现多线程并行执行任务。Folly 提供了 ThreadPoolExecutor 类，可以作为 TaskQueue 的 Executor。
6.3.6 实战案例：使用 TaskQueue 和 EventBase 实现后台任务处理系统 (Practical Case: Implementing Background Task Processing System using TaskQueue and EventBase)
下面是一个简化的后台任务处理系统示例，使用 TaskQueue 和 EventBase 实现任务的提交、调度和执行。
1
#include <folly/EventBase.h>
2
#include <folly/executors/TaskQueue.h>
3
#include <iostream>
4
#include <chrono>
5
6
using namespace folly;
7
8
class BackgroundTaskProcessor {
9
public:
10
BackgroundTaskProcessor(EventBase& evb) : taskQueue_(&evb) {
11
taskQueue_.start();
12
}
13
14
~BackgroundTaskProcessor() {
15
taskQueue_.stop();
16
taskQueue_.waitUntilIdle();
17
}
18
19
void submitTask(std::function<void()> task) {
20
taskQueue_.add(std::move(task));
21
}
22
23
void submitDelayedTask(std::function<void()> task, std::chrono::milliseconds delay) {
24
taskQueue_.addDelay(std::move(task), delay);
25
}
26
27
private:
28
TaskQueue taskQueue_;
29
};
30
31
int main() {
32
EventBase evb;
33
BackgroundTaskProcessor processor(evb);
34
35
processor.submitTask([]{
36
std::cout << "Task 1: Processing data..." << std::endl;
37
std::this_thread::sleep_for(std::chrono::seconds(2)); // 模拟耗时任务
38
std::cout << "Task 1: Done." << std::endl;
39
});
40
41
processor.submitDelayedTask([]{
42
std::cout << "Delayed Task 2: Cleaning up..." << std::endl;
43
std::this_thread::sleep_for(std::chrono::seconds(1));
44
std::cout << "Delayed Task 2: Done." << std::endl;
45
}, std::chrono::milliseconds(1500));
46
47
evb.loop(); // Start EventBase loop
48
49
return 0;
50
}
代码解释：
⚝ BackgroundTaskProcessor 类封装了 TaskQueue，提供 submitTask() 和 submitDelayedTask() 方法用于提交任务。
⚝ 任务在 EventBase 的事件循环线程中执行。
⚝ 这个示例展示了如何使用 TaskQueue 和 EventBase 构建一个简单的后台任务处理系统，可以用于处理各种异步任务，例如数据处理、日志清理、定时任务等。
END_OF_CHAPTER
7. chapter 7： EventBase 源码剖析 (Source Code Analysis of EventBase)
7.1 EventLoop 的实现原理 (Implementation Principle of EventLoop)
EventLoop（事件循环）是 EventBase 的核心，它是一种程序结构，用于等待和分发程序中发生的事件或消息。理解 EventLoop 的实现原理是深入掌握 EventBase 的关键。本节将从原理层面剖析 EventLoop 的工作机制，并结合源码进行解读。
7.1.1 核心思想 (Core Idea)
EventLoop 的核心思想可以用一个简单的循环来概括：
1
while (true) {
2
// ① 检查是否有待处理的任务 (Check for pending tasks)
3
tasks = get_pending_tasks();
4
if (!tasks.empty()) {
5
// ② 处理任务 (Process tasks)
6
process_tasks(tasks);
7
} else {
8
// ③ 等待事件发生 (Wait for events to occur)
9
events = wait_for_events();
10
// ④ 处理事件 (Process events)
11
process_events(events);
12
}
13
}
这个循环不断地检查是否有待处理的任务（例如，由 runInLoop 提交的任务），如果没有，则等待文件描述符（File Descriptor, FD）、定时器或信号等事件的发生。一旦事件发生，EventLoop 就会调用相应的事件处理函数。
7.1.2 EventBase 中的 EventLoop (EventLoop in EventBase)
在 folly/EventBase.h 中，EventBase 类本身就代表了 EventLoop。它封装了事件循环的逻辑，并提供了注册、注销和处理各种事件的接口。EventBase 的 loop() 方法是事件循环的主入口点。
1
// folly/EventBase.h (simplified)
2
class EventBase {
3
public:
4
void loop(); // 事件循环主函数 (Event loop main function)
5
void loopForever(); // 无限循环事件循环 (Infinite loop event loop)
6
void loopOnce(); // 单次循环事件循环 (Single loop event loop)
7
8
// ... 事件注册和管理接口 (Event registration and management interfaces) ...
9
10
private:
11
void runInLoopImpl(Func func); // 在 EventLoop 线程中执行函数 (Execute function in EventLoop thread)
12
void processTimers(); // 处理定时器事件 (Process timer events)
13
void processSignals(); // 处理信号事件 (Process signal events)
14
void processFileDescriptors(); // 处理文件描述符事件 (Process file descriptor events)
15
16
// ... 内部数据结构和实现细节 (Internal data structures and implementation details) ...
17
};
EventBase 内部维护了用于管理不同类型事件的数据结构，例如：
⚝ 文件描述符事件：使用 EventHandlerMap 或类似的数据结构来管理文件描述符和对应的事件处理器。
⚝ 定时器事件：使用最小堆（min-heap）或优先级队列（priority queue）来高效地管理定时器事件，保证最近到期的定时器能够被优先处理。
⚝ 信号事件：使用信号处理器链表或类似结构来管理信号事件和对应的处理器。
⚝ 待处理任务队列：使用队列（queue）来存储通过 runInLoop 提交的任务，确保在事件循环中串行执行。
7.1.3 事件循环的步骤 (Steps of Event Loop)
EventBase::loop() 方法内部执行的事件循环大致包含以下步骤：
① 检查并处理待处理任务 (Check and process pending tasks)：
EventBase 首先检查是否有通过 runInLoop 等方法提交到 EventLoop 线程的任务队列中。如果有，则依次取出并执行这些任务。这保证了在事件处理之前，先处理需要在 EventLoop 线程中执行的任务。
② 处理定时器事件 (Process timer events)：
EventBase 检查是否有到期的定时器。如果有，则执行定时器事件的回调函数，并根据定时器的类型（单次或重复）决定是否重新注册定时器。通常使用高效的数据结构（如最小堆）来管理定时器，以便快速找到最近到期的定时器。
③ 处理信号事件 (Process signal events)：
EventBase 检查是否有待处理的信号。如果有，则执行相应的信号处理函数。信号处理通常需要谨慎，因为信号处理函数可能会中断正常的程序执行流程。
④ 处理文件描述符事件 (Process file descriptor events)：
这是 EventLoop 的核心部分。EventBase 使用底层的 I/O 多路复用机制（如 epoll, kqueue, select）来监听注册的文件描述符上的事件（如可读、可写）。当文件描述符上有事件发生时，EventBase 会找到与该文件描述符关联的 EventHandler，并调用其相应的事件处理方法（如 readReady, writeReady）。
⑤ 再次循环 (Loop again)：
完成上述事件处理后，EventBase 返回循环的开始，再次检查待处理任务、定时器、信号和文件描述符事件，进入下一轮循环。
7.1.4 代码示例 (Code Example)
虽然 EventBase::loop() 的具体实现细节比较复杂，但我们可以通过一个简化的伪代码来理解其核心流程：
1
void EventBase::loop() {
2
while (!exitLoop_) { // exitLoop_ 控制循环是否退出 (exitLoop_ controls loop exit)
3
// 1. 处理 runInLoop 提交的任务 (Process tasks submitted by runInLoop)
4
processPendingTasks();
5
6
// 2. 处理定时器事件 (Process timer events)
7
processTimers();
8
9
// 3. 处理信号事件 (Process signal events)
10
processSignals();
11
12
// 4. 使用 I/O 多路复用等待文件描述符事件 (Wait for file descriptor events using I/O multiplexing)
13
int timeoutMs = getNextTimerTimeout(); // 计算下一个定时器到期时间，作为 poll 的超时时间 (Calculate timeout for next timer, used as poll timeout)
14
std::vector<FDEvent> events = waitForFDs(timeoutMs); // 使用 epoll/kqueue/select 等 (Use epoll/kqueue/select etc.)
15
16
// 5. 处理文件描述符事件 (Process file descriptor events)
17
processFileDescriptorEvents(events);
18
}
19
}
这段伪代码展示了 EventBase::loop() 的基本框架，实际的实现会更加复杂，涉及到错误处理、性能优化、跨平台兼容性等诸多细节。在后续章节中，我们将深入源码，剖析 EventBase 的具体实现。
7.2 事件分发机制深入分析 (In-depth Analysis of Event Dispatch Mechanism)
事件分发机制是 EventBase 的核心组成部分，它负责高效、准确地将发生的事件传递给相应的事件处理器（EventHandler）。本节将深入分析 EventBase 的事件分发机制，包括事件的注册、检测、选择和分发过程。
7.2.1 事件注册 (Event Registration)
事件注册是指将感兴趣的事件类型（例如，文件描述符上的读写事件、定时器事件、信号事件）以及对应的事件处理器关联起来，告知 EventBase 需要监听哪些事件，以及当事件发生时应该如何处理。
EventBase 提供了多种方法来注册不同类型的事件：
⚝ 文件描述符事件注册：通常通过 EventBase::addHandler() 方法，将一个 EventHandler 对象与一个文件描述符关联起来，并指定感兴趣的事件类型（读、写、错误等）。
⚝ 定时器事件注册：通过 EventBase::runAfterDelay() 或 EventBase::runAt() 等方法，注册定时器事件，并指定定时器到期后的回调函数。
⚝ 信号事件注册：通过 EventBase::installSignalHandler() 方法，注册信号事件，并指定信号处理函数。
在事件注册过程中，EventBase 会将事件信息存储在内部的数据结构中，以便在事件循环中进行管理和分发。例如，文件描述符事件通常会存储在一个哈希表或映射表中，以文件描述符为键，EventHandler 对象为值。定时器事件则通常存储在最小堆中，以定时器到期时间为优先级。
7.2.2 事件检测 (Event Detection)
事件检测是指 EventBase 如何高效地检测到事件的发生。对于文件描述符事件，EventBase 依赖于操作系统提供的 I/O 多路复用机制，如 epoll (Linux)、kqueue (macOS, FreeBSD)、select (POSIX 标准)。
EventBase 会根据不同的平台选择最佳的 I/O 多路复用机制。在事件循环的每次迭代中，EventBase 调用 I/O 多路复用函数（例如 epoll_wait, kqueue, select）来等待文件描述符上的事件。这些函数会阻塞等待，直到有文件描述符就绪（例如，可读、可写）或超时。
对于定时器事件，事件检测是通过比较当前时间与已注册定时器的到期时间来实现的。由于定时器事件通常存储在最小堆中，EventBase 可以高效地找到最近到期的定时器。
对于信号事件，事件检测是由操作系统内核完成的。当进程接收到注册的信号时，内核会通知进程，EventBase 需要注册信号处理函数来捕获和处理这些信号。
7.2.3 事件选择 (Event Selection)
当 I/O 多路复用函数返回时，它会告知 EventBase 哪些文件描述符上发生了哪些事件。EventBase 需要根据返回的事件信息，选择需要处理的事件。
例如，对于一个文件描述符，可能同时发生了可读事件和可写事件。EventBase 需要根据注册时指定的事件类型，以及 EventHandler 的处理能力，来决定是否处理这些事件。通常，EventBase 会优先处理读事件，然后再处理写事件，以避免数据丢失或阻塞。
对于定时器事件和信号事件，事件选择相对简单。当定时器到期或接收到信号时，EventBase 就会选择处理相应的事件。
7.2.4 事件分发 (Event Dispatch)
事件分发是指 EventBase 将检测到的事件传递给相应的事件处理器进行处理。对于不同类型的事件，事件分发的方式略有不同：
⚝ 文件描述符事件分发：EventBase 根据发生事件的文件描述符，查找与之关联的 EventHandler 对象，并调用 EventHandler 相应的事件处理方法，例如 readReady, writeReady, error. EventHandler 子类需要重写这些方法来实现具体的事件处理逻辑。
⚝ 定时器事件分发：EventBase 执行定时器事件注册时指定的回调函数。如果定时器是重复的，EventBase 会重新注册定时器，以便在下一个到期时间再次触发。
⚝ 信号事件分发：EventBase 执行信号事件注册时指定的信号处理函数。信号处理函数通常需要执行一些简短、非阻塞的操作，以避免影响事件循环的性能。
事件分发是 EventBase 实现事件驱动编程模型的关键步骤。通过高效的事件分发机制，EventBase 能够及时响应各种事件，并调用相应的事件处理器进行处理，从而实现高性能、高并发的应用程序。
7.2.5 数据结构与算法 (Data Structures and Algorithms)
EventBase 的事件分发机制的效率很大程度上取决于其使用的数据结构和算法。
⚝ 文件描述符事件管理：通常使用哈希表（例如 std::unordered_map）或红黑树（例如 std::map）来存储文件描述符和 EventHandler 的映射关系，以便快速查找和访问。
⚝ 定时器事件管理：使用最小堆（例如 std::priority_queue）来存储定时器事件，可以高效地找到最近到期的定时器，时间复杂度为 \(O(1)\)。插入和删除定时器的时间复杂度为 \(O(logN)\)，其中 \(N\) 是定时器数量。
⚝ I/O 多路复用：EventBase 依赖于操作系统提供的高效 I/O 多路复用机制，例如 epoll 和 kqueue，它们的事件检测效率通常为 \(O(1)\) 或接近 \(O(1)\)。select 的效率相对较低，为 \(O(N)\)，其中 \(N\) 是监听的文件描述符数量。
通过合理选择数据结构和算法，以及利用操作系统提供的底层机制，EventBase 实现了高效的事件分发机制，能够支持高并发的网络应用。
7.3 跨平台兼容性处理 (Cross-platform Compatibility Handling)
跨平台兼容性是 EventBase 设计中一个重要的考虑因素。不同的操作系统提供了不同的事件通知机制和 API，例如 Linux 的 epoll，macOS 和 FreeBSD 的 kqueue，以及 POSIX 标准的 select 和 poll。为了在不同平台上提供一致的接口和功能，EventBase 需要进行跨平台兼容性处理。
7.3.1 平台差异性 (Platform Differences)
不同操作系统在事件处理方面的主要差异体现在以下几个方面：
① I/O 多路复用机制：
▮▮▮▮⚝ Linux: epoll 是 Linux 上高效的 I/O 多路复用机制，支持边缘触发（Edge-Triggered, ET）和水平触发（Level-Triggered, LT）模式，性能优秀。
▮▮▮▮⚝ macOS, FreeBSD: kqueue 是 macOS 和 FreeBSD 上高效的 I/O 多路复用机制，功能强大，支持文件事件、信号、进程事件等多种事件类型。
▮▮▮▮⚝ POSIX 标准: select 和 poll 是 POSIX 标准定义的 I/O 多路复用机制，跨平台性好，但性能相对较低，特别是 select 在监听大量文件描述符时效率会显著下降。
② API 接口：
不同平台的 I/O 多路复用机制的 API 接口有所不同，例如 epoll_create, epoll_ctl, epoll_wait (Linux), kqueue, kevent (macOS, FreeBSD), select, poll (POSIX)。
③ 事件类型和标志：
不同平台支持的事件类型和事件标志可能有所不同。例如，epoll 支持 EPOLLIN, EPOLLOUT, EPOLLERR, EPOLLHUP 等事件，kqueue 支持 EVFILT_READ, EVFILT_WRITE, EVFILT_PROC, EVFILT_SIGNAL 等事件过滤器。
7.3.2 条件编译与抽象层 (Conditional Compilation and Abstraction Layer)
为了处理平台差异性，EventBase 采用了条件编译和抽象层技术：
① 条件编译 (Conditional Compilation)：
EventBase 使用预处理器宏（如 #ifdef, #ifndef, #elif, #else, #endif）来根据不同的操作系统选择不同的代码路径。例如，根据宏 __linux__, __APPLE__, __FreeBSD__ 等来判断当前编译平台，并选择使用 epoll, kqueue 或 select 等不同的 I/O 多路复用机制。
1
#if defined(__linux__)
2
// 使用 epoll 的实现 (Implementation using epoll)
3
#elif defined(__APPLE__) || defined(__FreeBSD__)
4
// 使用 kqueue 的实现 (Implementation using kqueue)
5
#else
6
// 使用 select 或 poll 的实现 (Implementation using select or poll)
7
#endif
② 抽象层 (Abstraction Layer)：
EventBase 在 I/O 多路复用机制之上构建了一个抽象层，将平台相关的 API 封装起来，提供统一的接口供上层使用。例如，EventBase 可能会定义一个通用的 Poller 接口，然后针对不同的平台实现不同的 Poller 子类，如 EpollPoller, KqueuePoller, SelectPoller。
1
class Poller { // 抽象 Poller 接口 (Abstract Poller interface)
2
public:
3
virtual ~Poller() = default;
4
virtual int poll(int timeoutMs, std::vector<FDEvent>& events) = 0;
5
virtual void addFd(int fd, int eventTypes) = 0;
6
virtual void updateFd(int fd, int eventTypes) = 0;
7
virtual void removeFd(int fd) = 0;
8
};
9
10
class EpollPoller : public Poller { // EpollPoller 实现 (EpollPoller implementation)
11
public:
12
// ... epoll 相关的实现 (epoll related implementation) ...
13
};
14
15
class KqueuePoller : public Poller { // KqueuePoller 实现 (KqueuePoller implementation)
16
public:
17
// ... kqueue 相关的实现 (kqueue related implementation) ...
18
};
19
20
// ... 其他 Poller 实现 (Other Poller implementations) ...
21
22
std::unique_ptr<Poller> createPoller(); // 工厂函数，根据平台创建不同的 Poller 对象 (Factory function to create different Poller objects based on platform)
通过抽象层，EventBase 的上层代码可以不关心底层使用的具体 I/O 多路复用机制，只需要调用统一的 Poller 接口即可。这大大简化了跨平台开发的复杂性，提高了代码的可维护性和可移植性。
7.3.3 平台特性利用与权衡 (Platform Feature Utilization and Trade-offs)
在进行跨平台兼容性处理时，EventBase 不仅要保证功能在不同平台上都能正常工作，还要尽可能地利用各平台的特性，以达到最佳的性能。
⚝ 优先选择高性能机制：在支持 epoll 或 kqueue 的平台上，EventBase 会优先选择使用这些高性能的 I/O 多路复用机制，以获得更好的性能。
⚝ 兼容性与性能权衡：在某些平台上，可能只支持 select 或 poll 等性能相对较低的机制。在这种情况下，EventBase 需要在兼容性和性能之间进行权衡。通常会选择 poll 优于 select，因为 poll 在处理大量文件描述符时性能更好。
⚝ 平台特定优化：针对不同的平台，EventBase 可能会进行一些平台特定的优化。例如，在 Linux 上，可以利用 epoll 的边缘触发模式来提高性能；在 macOS 上，可以利用 kqueue 的多种事件过滤器来支持更丰富的事件类型。
7.3.4 代码示例 (Code Example)
以下是一个简化的代码示例，展示了 EventBase 如何使用条件编译来选择不同的 I/O 多路复用机制：
1
#include <vector>
2
3
class FDEvent {}; // 占位符，实际 FDEvent 定义可能更复杂 (Placeholder, actual FDEvent definition may be more complex)
4
5
#if defined(__linux__)
6
#include <sys/epoll.h>
7
#include <unistd.h>
8
9
class PollerImpl {
10
public:
11
PollerImpl() : epollFd_(epoll_create1(0)) {
12
if (epollFd_ == -1) {
13
// 错误处理 (Error handling)
14
}
15
}
16
~PollerImpl() {
17
close(epollFd_);
18
}
19
20
int poll(int timeoutMs, std::vector<FDEvent>& events) {
21
// 使用 epoll_wait 实现 poll (Implement poll using epoll_wait)
22
return 0; // 简化实现 (Simplified implementation)
23
}
24
25
private:
26
int epollFd_;
27
};
28
29
#elif defined(__APPLE__) || defined(__FreeBSD__)
30
#include <sys/event.h>
31
#include <unistd.h>
32
33
class PollerImpl {
34
public:
35
PollerImpl() : kq_(kqueue()) {
36
if (kq_ == -1) {
37
// 错误处理 (Error handling)
38
}
39
}
40
~PollerImpl() {
41
close(kq_);
42
}
43
44
int poll(int timeoutMs, std::vector<FDEvent>& events) {
45
// 使用 kqueue/kevent 实现 poll (Implement poll using kqueue/kevent)
46
return 0; // 简化实现 (Simplified implementation)
47
}
48
49
private:
50
int kq_;
51
};
52
53
#else // 其他平台默认使用 select (Default to select for other platforms)
54
#include <sys/select.h>
55
#include <unistd.h>
56
57
class PollerImpl {
58
public:
59
PollerImpl() {}
60
~PollerImpl() {}
61
62
int poll(int timeoutMs, std::vector<FDEvent>& events) {
63
// 使用 select 实现 poll (Implement poll using select)
64
return 0; // 简化实现 (Simplified implementation)
65
}
66
};
67
68
#endif
69
70
class Poller { // 抽象 Poller 类，内部使用 PollerImpl (Abstract Poller class, using PollerImpl internally)
71
public:
72
Poller() : impl_(std::make_unique<PollerImpl>()) {}
73
int poll(int timeoutMs, std::vector<FDEvent>& events) {
74
return impl_->poll(timeoutMs, events);
75
}
76
77
private:
78
std::unique_ptr<PollerImpl> impl_;
79
};
这个示例代码展示了如何使用条件编译和 PIMPL (Pointer to Implementation) 模式来实现跨平台兼容的 Poller 类。实际的 EventBase 实现会更加复杂，但基本思想是类似的。通过这些跨平台兼容性处理，EventBase 能够在不同的操作系统上提供一致、高效的事件驱动编程能力。
END_OF_CHAPTER
8. chapter 8： 案例分析与最佳实践 (Case Studies and Best Practices)
8.1 高并发网络服务器设计 (High-Concurrency Network Server Design)
在现代互联网应用中，高并发网络服务器是支撑大规模用户访问和数据处理的关键基础设施。设计一个能够有效处理数百万甚至数千万并发连接的网络服务器，需要深入理解事件驱动编程模型、非阻塞 I/O 以及高效的资源管理策略。EventBase 作为 folly 库的核心组件，为构建高性能、高并发的网络服务器提供了强大的基础。本节将深入探讨如何利用 EventBase 设计高并发网络服务器，并分享一些最佳实践。
8.1.1 高并发服务器的设计挑战 (Design Challenges of High-Concurrency Servers)
设计高并发服务器面临诸多挑战，主要包括：
① C10K/C100K/C1M 问题：随着互联网用户规模的爆炸式增长，服务器需要同时处理成千上万甚至百万级别的并发连接（C10K, C100K, C1M problem）。传统的线程池或进程池模型在面对如此大规模的并发时，会因为线程/进程上下文切换的开销而效率低下，资源消耗巨大。
② I/O 瓶颈：网络服务器的核心任务是处理网络 I/O。传统的阻塞 I/O 模型在处理大量并发连接时，会因为大量的线程阻塞在等待 I/O 操作完成而导致系统资源耗尽。非阻塞 I/O 和事件驱动模型是解决 I/O 瓶颈的关键。
③ 资源管理：高并发服务器需要高效地管理系统资源，包括 CPU、内存、文件描述符等。不合理的资源管理策略会导致服务器性能下降甚至崩溃。例如，文件描述符泄漏、内存泄漏等问题在高并发场景下会被迅速放大。
④ 请求处理效率：在高并发场景下，单个请求的处理效率至关重要。即使是微小的延迟累积起来也会对整体性能产生显著影响。因此，需要优化请求处理流程，减少不必要的计算和 I/O 操作。
⑤ 可扩展性与可维护性：服务器设计不仅要考虑当前的并发需求，还要具备良好的可扩展性，以应对未来用户规模的增长。同时，代码的可维护性也是长期稳定运行的关键。
8.1.2 EventBase 在高并发服务器设计中的优势 (Advantages of EventBase in High-Concurrency Server Design)
EventBase 基于事件驱动模型和非阻塞 I/O，天然适合构建高并发网络服务器。其主要优势包括：
① 高效的事件循环 (Event Loop)：EventBase 的核心是事件循环，它能够在一个单线程或少量线程中高效地管理大量的事件，避免了传统多线程模型中线程上下文切换的开销。事件循环只在有事件发生时才会被激活，大大提高了 CPU 的利用率。
② 非阻塞 I/O (Non-blocking I/O)：EventBase 结合非阻塞 I/O 操作，使得服务器在等待 I/O 操作完成时不会阻塞，而是可以继续处理其他事件。这极大地提高了服务器的并发处理能力。EventBase 封装了底层的 epoll (Linux)、kqueue (macOS, FreeBSD)、select/poll 等 I/O 多路复用机制，提供了统一的事件处理接口。
③ 灵活的事件类型 (Flexible Event Types)：EventBase 支持多种事件类型，包括文件描述符事件（读、写、错误）、定时器事件、信号事件等。这使得开发者可以方便地处理各种异步事件，构建复杂的网络应用。
④ 强大的定时器管理 (Powerful Timer Management)：EventBase 提供了高效的定时器管理机制，可以方便地设置和管理大量的定时任务，例如连接超时、心跳检测、延迟重试等。
⑤ 良好的跨平台性 (Cross-platform Compatibility)：EventBase 抽象了底层操作系统差异，提供了统一的 API，使得基于 EventBase 开发的网络服务器可以方便地在不同平台上部署和运行。
⑥ 与 folly 库的深度集成 (Deep Integration with Folly Library)：EventBase 与 folly 库的其他组件（如 Futures, IOBuf, Socket, TaskQueue 等）无缝集成，可以方便地构建功能丰富、性能卓越的网络应用。
8.1.3 基于 EventBase 的高并发 TCP 服务器设计 (Designing a High-Concurrency TCP Server with EventBase)
下面我们通过一个简化的 TCP 服务器示例，展示如何使用 EventBase 构建高并发网络服务器。
代码示例 8-1：基于 EventBase 的简单 TCP 服务器框架
1
#include <folly/EventBase.h>
2
#include <folly/SocketAddress.h>
3
#include <folly/io/async/AsyncServerSocket.h>
4
#include <folly/io/async/AsyncSocket.h>
5
#include <iostream>
6
7
using namespace folly;
8
using namespace std;
9
10
class EchoConnection : public AsyncSocket::ReadCallback {
11
public:
12
explicit EchoConnection(AsyncSocket* sock) : sock_(sock) {
13
sock_->setReadCB(this);
14
}
15
16
~EchoConnection() override {
17
sock_->close();
18
}
19
20
void getReadBuffer(void** bufReturn, size_t* lenReturn) override {
21
*bufReturn = buffer_;
22
*lenReturn = kBufferSize;
23
}
24
25
void readDataAvailable(size_t len) override {
26
if (len > 0) {
27
// Echo back the received data
28
sock_->write(buffer_, len, nullptr);
29
} else if (len == 0) {
30
// Connection closed by client
31
delete this;
32
}
33
}
34
35
void readEOF() override {
36
delete this;
37
}
38
39
void readErr(const AsyncSocketException& ex) override {
40
cerr << "Read error: " << ex.what() << endl;
41
delete this;
42
}
43
44
private:
45
AsyncSocket* sock_;
46
enum { kBufferSize = 1024 };
47
char buffer_[kBufferSize];
48
};
49
50
class EchoServerAcceptCallback : public AsyncServerSocket::AcceptCallback {
51
public:
52
void connectionAccepted(int fd, const SocketAddress& address) noexcept override {
53
cout << "Accepted connection from " << address.getAddressStr() << ":" << address.getPort() << endl;
54
AsyncSocket* sock = new AsyncSocket(&evb_);
55
sock->attachEventBase(&evb_);
56
sock->adoptFD(fd);
57
new EchoConnection(sock); // 管理连接的生命周期
58
}
59
60
void acceptError(const exception& ex) noexcept override {
61
cerr << "Accept error: " << ex.what() << endl;
62
}
63
64
EventBase evb_; // 每个 AcceptCallback 实例持有一个 EventBase
65
66
public:
67
EventBase& getEventBase() { return evb_; }
68
};
69
70
71
int main() {
72
SocketAddress address;
73
address.setFromLocalPort(8080);
74
75
auto acceptCallback = new EchoServerAcceptCallback();
76
AsyncServerSocket serverSocket;
77
serverSocket.setAcceptCB(acceptCallback);
78
79
EventBase& evb = acceptCallback->getEventBase(); // 获取 AcceptCallback 关联的 EventBase
80
81
serverSocket.bind(address);
82
serverSocket.listen(128);
83
serverSocket.startAccepting();
84
85
cout << "Echo server started on port " << address.getPort() << endl;
86
evb.loopForever(); // 启动事件循环
87
88
return 0;
89
}
代码解释：
① EchoConnection 类：
▮▮▮▮⚝ 实现了 AsyncSocket::ReadCallback 接口，用于处理客户端连接上的读事件。
▮▮▮▮⚝ getReadBuffer() 方法提供读取数据的缓冲区。
▮▮▮▮⚝ readDataAvailable() 方法在有数据可读时被调用，示例中实现了简单的回显功能。
▮▮▮▮⚝ readEOF() 和 readErr() 方法处理连接关闭和错误事件。
▮▮▮▮⚝ 使用 new EchoConnection(sock) 创建连接对象，并在事件处理完成后使用 delete this 释放资源，管理连接的生命周期。
② EchoServerAcceptCallback 类：
▮▮▮▮⚝ 实现了 AsyncServerSocket::AcceptCallback 接口，用于处理新的连接请求。
▮▮▮▮⚝ connectionAccepted() 方法在新连接建立时被调用。
▮▮▮▮⚝ 在此方法中，创建 AsyncSocket 对象，并将其与 EventBase 关联。
▮▮▮▮⚝ 使用 adoptFD() 方法接管监听 socket 返回的文件描述符。
▮▮▮▮⚝ 创建 EchoConnection 对象来处理新的连接。
▮▮▮▮⚝ 每个 EchoServerAcceptCallback 实例持有一个独立的 EventBase 对象，用于处理该监听 socket 上的事件。
③ main() 函数：
▮▮▮▮⚝ 创建 SocketAddress 对象，指定监听端口。
▮▮▮▮⚝ 创建 EchoServerAcceptCallback 对象，并设置为 AsyncServerSocket 的 accept 回调。
▮▮▮▮⚝ 创建 AsyncServerSocket 对象，并绑定地址、监听端口，开始接受连接。
▮▮▮▮⚝ 获取 EchoServerAcceptCallback 关联的 EventBase 对象，并启动事件循环 evb.loopForever()。
关键设计点：
⚝ 事件驱动模型：服务器完全基于事件驱动，所有的 I/O 操作都是非阻塞的，通过事件回调来处理 I/O 完成事件。
⚝ 单线程事件循环：示例中使用单线程 EventBase 来处理所有连接的事件，避免了线程切换的开销。在实际高并发场景中，可以考虑使用多线程 EventBase 或 Reactor 模式来进一步提升性能（将在后续章节讨论）。
⚝ 连接生命周期管理：EchoConnection 对象负责管理单个连接的生命周期，包括读取数据、发送数据、处理错误和关闭连接。当连接关闭或发生错误时，EchoConnection 对象会被删除，释放资源。
⚝ AcceptCallback 分离：使用 AcceptCallback 来处理连接接受事件，使得监听 socket 的事件处理逻辑与连接 socket 的事件处理逻辑分离，结构更清晰。
8.1.4 高并发服务器的最佳实践 (Best Practices for High-Concurrency Servers)
① 选择合适的事件处理模型：
▮▮▮▮⚝ 单线程事件循环：适用于 I/O 密集型且请求处理逻辑简单的场景。优点是简单高效，避免了线程同步开销。缺点是无法充分利用多核 CPU，单个事件循环的性能成为瓶颈。
▮▮▮▮⚝ 多线程事件循环 (Reactor 模式)：可以使用多个 EventBase 对象，每个 EventBase 运行在独立的线程中，负责处理一部分连接的事件。可以使用主线程负责 accept 新连接，然后将连接分配给不同的 EventBase 线程处理。这种模式可以充分利用多核 CPU，提高并发处理能力。
▮▮▮▮⚝ Proactor 模式：EventBase 实际上更接近 Reactor 模式，但通过结合 folly::Executor 和 Futures，可以实现类似 Proactor 模式的效果，将耗时的任务提交到线程池异步执行，避免阻塞事件循环。
② 优化事件处理逻辑：
▮▮▮▮⚝ 减少阻塞操作：在事件回调函数中，应尽量避免执行阻塞操作。如果需要执行耗时操作（如数据库查询、复杂计算），应将其异步化，例如提交到线程池或使用 folly::Futures。
▮▮▮▮⚝ 高效的数据处理：使用高效的数据结构和算法来处理请求数据。例如，使用 folly::IOBuf 来管理网络缓冲区，减少内存拷贝。
▮▮▮▮⚝ 避免内存分配：在高频调用的事件回调函数中，应尽量避免频繁的内存分配和释放，可以使用对象池或预分配缓冲区来提高性能。
③ 资源限制与保护：
▮▮▮▮⚝ 连接数限制：在高并发场景下，需要限制服务器的最大连接数，防止资源耗尽。可以使用操作系统的 ulimit 命令或在程序中设置连接数上限。
▮▮▮▮⚝ 文件描述符管理：注意文件描述符的泄漏问题，确保及时关闭不再使用的 socket 和文件描述符。可以使用 folly::File 等 RAII 封装来管理文件描述符的生命周期。
▮▮▮▮⚝ 内存管理：监控服务器的内存使用情况，防止内存泄漏。可以使用内存分析工具来检测和定位内存泄漏问题。
④ 监控与日志：
▮▮▮▮⚝ 性能监控：对服务器的关键性能指标（如吞吐量、延迟、CPU 使用率、内存使用率、连接数等）进行监控，及时发现性能瓶颈和异常情况。可以使用 folly::stats 或 Prometheus 等监控系统。
▮▮▮▮⚝ 详细日志：记录详细的服务器日志，包括请求日志、错误日志、事件日志等，方便问题排查和性能分析。可以使用 folly::logging 或其他日志库。
⑤ 安全考虑：
▮▮▮▮⚝ 防止 DoS/DDoS 攻击：采取措施防止拒绝服务攻击，例如连接速率限制、请求频率限制、IP 黑名单等。
▮▮▮▮⚝ 数据加密：对于敏感数据，应使用 TLS/SSL 等加密协议进行传输，保障数据安全。
▮▮▮▮⚝ 输入验证：对客户端输入的数据进行严格的验证，防止恶意输入导致安全漏洞。
通过合理地运用 EventBase 的特性，并结合上述最佳实践，可以设计出高性能、高可靠性的高并发网络服务器，满足现代互联网应用的需求。
8.2 构建高性能 RPC 框架 (Building High-Performance RPC Framework)
远程过程调用 (RPC, Remote Procedure Call) 框架是构建分布式系统的核心组件。一个高性能的 RPC 框架需要具备低延迟、高吞吐量、可扩展性强等特点。EventBase 凭借其高效的事件驱动模型和非阻塞 I/O 能力，成为构建高性能 RPC 框架的理想选择。本节将探讨如何利用 EventBase 构建高性能 RPC 框架，并深入分析关键的设计和优化策略。
8.2.1 RPC 框架的核心组件 (Core Components of RPC Framework)
一个典型的 RPC 框架通常包含以下核心组件：
① 服务定义 (Service Definition)：使用接口定义语言 (IDL, Interface Definition Language) (例如 Protocol Buffers, Thrift) 定义服务接口和数据结构。IDL 描述了服务提供的函数、参数类型、返回值类型等。
② 代码生成 (Code Generation)：根据 IDL 文件生成客户端和服务端的代码，包括接口定义、数据序列化/反序列化代码、客户端 Stub 代码、服务端 Skeleton 代码等。
③ 客户端 Stub (Client Stub)：客户端 Stub 是客户端应用程序调用的本地代理对象。它负责将客户端的函数调用转换为 RPC 请求，并通过网络发送给服务端。客户端 Stub 通常处理请求的序列化、网络传输、同步/异步调用、错误处理等。
④ 服务端 Skeleton (Server Skeleton)：服务端 Skeleton 接收客户端发送的 RPC 请求，并将其解包，调用实际的服务实现代码，并将服务端的响应打包后通过网络发送回客户端。服务端 Skeleton 通常处理请求的接收、反序列化、服务查找、服务调用、响应序列化、网络传输等。
⑤ 传输协议 (Transport Protocol)：定义客户端和服务端之间数据传输的协议，包括数据包格式、序列化方式、连接管理、错误处理等。常用的传输协议包括 TCP、UDP、HTTP/2 等。
⑥ 序列化/反序列化 (Serialization/Deserialization)：将数据结构转换为字节流 (序列化) 和将字节流转换回数据结构 (反序列化) 的过程。高效的序列化/反序列化是 RPC 性能的关键因素之一。常用的序列化协议包括 Protocol Buffers, Thrift, JSON, MessagePack 等。
⑦ 服务注册与发现 (Service Registry and Discovery)：在分布式环境中，服务提供者和服务消费者需要通过服务注册与发现机制来找到对方。服务注册中心 (Service Registry) 维护服务提供者的地址信息，服务消费者通过查询服务注册中心来发现服务提供者。常用的服务注册中心包括 ZooKeeper, etcd, Consul, Eureka 等。
⑧ 负载均衡 (Load Balancing)：当服务提供者有多个实例时，需要负载均衡机制将客户端的请求分发到不同的服务实例，以提高系统的整体性能和可用性。常用的负载均衡算法包括轮询、随机、加权轮询、最少连接数等。
⑨ 监控与Tracing (Monitoring and Tracing)：RPC 框架需要提供监控和 tracing 功能，用于收集性能指标、跟踪请求调用链、诊断性能问题等。常用的监控系统包括 Prometheus, Grafana, Zipkin, Jaeger 等。
8.2.2 EventBase 在 RPC 框架中的作用 (Role of EventBase in RPC Framework)
EventBase 在构建高性能 RPC 框架中扮演着至关重要的角色，主要体现在以下几个方面：
① 高效的网络 I/O：EventBase 提供了非阻塞 I/O 和事件驱动模型，使得 RPC 框架可以高效地处理大量的并发请求。客户端和服务端都可以使用 EventBase 来管理网络连接和 I/O 事件，实现低延迟、高吞吐量的网络通信。
② 异步编程模型：EventBase 天然支持异步编程，可以方便地实现异步 RPC 调用。客户端可以使用 folly::Futures 或回调函数来处理异步 RPC 调用的结果，避免阻塞主线程，提高应用程序的响应性。服务端可以使用 EventBase 来异步处理请求，提高并发处理能力。
③ 定时器管理：EventBase 的定时器功能可以用于实现 RPC 框架的超时控制、心跳检测、重试机制等。例如，可以为每个 RPC 请求设置超时时间，防止请求长时间无响应导致资源泄漏。可以使用心跳检测来监控客户端和服务端的连接状态，及时发现和处理连接异常。可以使用重试机制来提高 RPC 调用的可靠性。
④ 与 folly 库的集成：EventBase 与 folly 库的其他组件（如 Futures, IOBuf, Socket, TaskQueue 等）无缝集成，可以方便地构建功能丰富、性能卓越的 RPC 框架。例如，可以使用 folly::IOBuf 来高效地管理 RPC 请求和响应的数据缓冲区，使用 folly::Futures 来简化异步编程，使用 folly::TaskQueue 来实现任务调度。
8.2.3 基于 EventBase 构建高性能 RPC 框架的关键设计 (Key Designs for Building High-Performance RPC Framework with EventBase)
① 选择合适的传输协议：
▮▮▮▮⚝ TCP：TCP 协议提供可靠的、面向连接的传输，适用于对数据可靠性要求高的 RPC 场景。EventBase 提供了 AsyncSocket 和 AsyncServerSocket 等类，可以方便地构建基于 TCP 的 RPC 框架。
▮▮▮▮⚝ UDP：UDP 协议提供无连接的、不可靠的传输，适用于对延迟敏感、丢包容忍度高的 RPC 场景。EventBase 也支持 UDP socket，可以用于构建基于 UDP 的 RPC 框架。
▮▮▮▮⚝ HTTP/2：HTTP/2 协议基于 TCP，提供了多路复用、头部压缩等特性，可以提高 HTTP 传输的效率。folly 库提供了 folly/http 组件，可以用于构建基于 HTTP/2 的 RPC 框架。
② 高效的序列化/反序列化：
▮▮▮▮⚝ Protocol Buffers：Protocol Buffers 是 Google 开发的一种高效的序列化协议，具有性能高、体积小、跨语言等优点，是构建高性能 RPC 框架的常用选择。folly 库提供了对 Protocol Buffers 的支持。
▮▮▮▮⚝ Thrift：Thrift 是 Facebook 开发的一种跨语言的 RPC 框架，也包含高效的序列化协议。folly 库也提供了对 Thrift 的支持。
▮▮▮▮⚝ FlatBuffers：FlatBuffers 是 Google 开发的另一种高效的序列化协议，特点是零拷贝反序列化，适用于对性能要求极高的场景。
③ 异步调用与 Future：
▮▮▮▮⚝ 使用 folly::Futures 来实现异步 RPC 调用，可以提高客户端和服务端的并发处理能力。客户端发起 RPC 调用后，可以立即返回，继续执行其他任务，当 RPC 调用完成时，通过 Future 的回调函数来处理结果。服务端可以使用 folly::Futures 来异步处理请求，例如异步访问数据库、异步调用其他服务等。
④ 连接池与连接复用：
▮▮▮▮⚝ 在客户端，可以使用连接池来管理与服务端的连接，避免频繁地创建和销毁连接。连接池可以复用已建立的连接，减少连接建立的开销，提高 RPC 调用的效率。可以使用 folly::PooledAsyncSocket 或自定义连接池来实现连接管理。
▮▮▮▮⚝ 在 HTTP/2 协议中，天然支持连接复用，可以在单个 TCP 连接上 multiplex 多个 RPC 请求和响应，提高连接利用率。
⑤ 负载均衡与服务发现：
▮▮▮▮⚝ 集成服务注册与发现组件 (如 ZooKeeper, etcd, Consul) 来实现服务发现和服务注册。客户端通过查询服务注册中心来获取服务提供者的地址列表。
▮▮▮▮⚝ 实现负载均衡策略 (如轮询、随机、加权轮询) 来将客户端的请求分发到不同的服务提供者实例。可以使用客户端负载均衡或服务端负载均衡 (如使用 Nginx, HAProxy 等反向代理)。
⑥ 监控与 Tracing：
▮▮▮▮⚝ 集成监控系统 (如 Prometheus, Grafana) 来收集 RPC 框架的性能指标，例如请求量、延迟、错误率等。
▮▮▮▮⚝ 集成 tracing 系统 (如 Zipkin, Jaeger) 来跟踪 RPC 请求的调用链，分析请求的延迟分布，定位性能瓶颈。可以使用 folly::tracing 或 OpenTelemetry 等 tracing 库。
代码示例 8-2：简化的基于 EventBase 的 RPC 客户端 Stub 框架 (伪代码)
1
#include <folly/EventBase.h>
2
#include <folly/io/async/AsyncSocket.h>
3
#include <folly/io/IOBuf.h>
4
#include <folly/futures/Future.h>
5
#include <memory>
6
7
using namespace folly;
8
9
class RpcClientStub {
10
public:
11
RpcClientStub(EventBase& evb, const SocketAddress& serverAddress) : evb_(evb), serverAddress_(serverAddress) {}
12
13
Future<IOBuf> call(const std::string& methodName, const IOBuf& requestData) {
14
auto promise = std::make_shared<Promise<IOBuf>>();
15
AsyncSocket* sock = new AsyncSocket(&evb_);
16
sock->connect(nullptr, serverAddress_, 3000, [this, sock, methodName, requestData, promise](const AsyncSocketException* ex) {
17
if (ex) {
18
promise->setException(ex);
19
delete sock;
20
return;
21
}
22
// 连接成功，发送请求
23
sendRequest(sock, methodName, requestData, promise);
24
});
25
return promise->getFuture();
26
}
27
28
private:
29
void sendRequest(AsyncSocket* sock, const std::string& methodName, const IOBuf& requestData, std::shared_ptr<Promise<IOBuf>> promise) {
30
// 构造 RPC 请求 (methodName, requestData) 并序列化为 IOBuf
31
IOBuf request = serializeRequest(methodName, requestData);
32
33
sock->write(request.clone(), nullptr, [this, sock, promise](size_t bytesWritten) {
34
// 请求发送成功，开始接收响应
35
receiveResponse(sock, promise);
36
});
37
}
38
39
void receiveResponse(AsyncSocket* sock, std::shared_ptr<Promise<IOBuf>> promise) {
40
sock->setReadCB(new RpcClientReadCallback(sock, promise)); // 使用 ReadCallback 处理响应
41
}
42
43
IOBuf serializeRequest(const std::string& methodName, const IOBuf& requestData) {
44
// 序列化请求，例如使用 Protocol Buffers
45
// ...
46
return IOBuf::create("serialized request data"); // 示例
47
}
48
49
IOBuf deserializeResponse(const IOBuf& responseData) {
50
// 反序列化响应，例如使用 Protocol Buffers
51
// ...
52
return IOBuf::create("deserialized response data"); // 示例
53
}
54
55
56
class RpcClientReadCallback : public AsyncSocket::ReadCallback {
57
public:
58
RpcClientReadCallback(AsyncSocket* sock, std::shared_ptr<Promise<IOBuf>> promise) : sock_(sock), promise_(promise) {
59
sock_->setReadCB(this);
60
}
61
~RpcClientReadCallback() override { delete sock_; }
62
63
void getReadBuffer(void** bufReturn, size_t* lenReturn) override {
64
*bufReturn = buffer_;
65
*lenReturn = kBufferSize;
66
}
67
void readDataAvailable(size_t len) override {
68
if (len > 0) {
69
// 接收到响应数据
70
IOBuf responseData = IOBuf::copyBuffer(buffer_, len);
71
promise_->setValue(responseData); // 设置 Future 的值，完成异步调用
72
delete this; // 完成响应处理，删除 ReadCallback
73
} else if (len == 0) {
74
// 连接关闭
75
promise_->setException(std::runtime_error("Connection closed"));
76
delete this;
77
}
78
}
79
void readEOF() override {
80
promise_->setException(std::runtime_error("Read EOF"));
81
delete this;
82
}
83
void readErr(const AsyncSocketException& ex) override {
84
promise_->setException(ex);
85
delete this;
86
}
87
88
private:
89
AsyncSocket* sock_;
90
std::shared_ptr<Promise<IOBuf>> promise_;
91
enum { kBufferSize = 1024 };
92
char buffer_[kBufferSize];
93
};
94
95
96
private:
97
EventBase& evb_;
98
SocketAddress serverAddress_;
99
};
100
101
102
int main() {
103
EventBase evb;
104
SocketAddress serverAddress;
105
serverAddress.setFromString("127.0.0.1:9090");
106
RpcClientStub client(evb, serverAddress);
107
108
auto future = client.call("echo", IOBuf::create("hello server"));
109
future.then([](IOBuf response) {
110
cout << "Response received: " << response.moveToFbString() << endl;
111
}).onError([](const std::exception& ex) {
112
cerr << "RPC call failed: " << ex.what() << endl;
113
});
114
115
evb.loopForever();
116
return 0;
117
}
代码解释：
⚝ RpcClientStub 类：
▮▮▮▮⚝ 封装了 RPC 客户端 Stub 的基本框架。
▮▮▮▮⚝ call() 方法接受方法名和请求数据，发起异步 RPC 调用，并返回 Future<IOBuf> 对象。
▮▮▮▮⚝ 使用 AsyncSocket 进行网络通信，使用 folly::Promise 和 folly::Future 实现异步调用。
▮▮▮▮⚝ sendRequest() 方法构造 RPC 请求并发送。
▮▮▮▮⚝ receiveResponse() 方法设置 RpcClientReadCallback 来处理响应。
▮▮▮▮⚝ serializeRequest() 和 deserializeResponse() 方法是序列化和反序列化的占位符，实际应用中需要根据选择的序列化协议实现。
⚝ RpcClientReadCallback 类：
▮▮▮▮⚝ 实现了 AsyncSocket::ReadCallback 接口，用于处理 RPC 响应的读取事件。
▮▮▮▮⚝ readDataAvailable() 方法在接收到响应数据时被调用，将响应数据设置到 Promise 中，完成异步调用。
关键设计点：
⚝ 异步 RPC 调用：使用 folly::Futures 实现异步 RPC 调用，提高了客户端的并发性和响应性。
⚝ ReadCallback 处理响应：使用 AsyncSocket::ReadCallback 来异步处理 RPC 响应，避免阻塞事件循环。
⚝ 可扩展框架：示例代码只是一个简化的框架，实际的 RPC 框架需要考虑更多的细节，例如错误处理、超时控制、连接池、负载均衡、服务发现、监控 tracing 等。
通过结合 EventBase 的高效网络 I/O 能力和 folly 库的其他组件，可以构建出高性能、可扩展、易维护的 RPC 框架，为分布式系统提供强大的通信基础设施。
8.3 EventBase 在大型项目中的应用 (Application of EventBase in Large-scale Projects)
EventBase 作为 folly 库的核心组件，已经在 Facebook 等大型互联网公司的许多关键基础设施项目中得到广泛应用。其高性能、高可靠性、易用性等特点，使其成为构建大规模、高并发系统的理想选择。本节将探讨 EventBase 在大型项目中的应用场景，并分析其优势和挑战。
8.3.1 EventBase 的典型应用场景 (Typical Application Scenarios of EventBase)
① 高性能网络服务器：如 Web 服务器、反向代理服务器、负载均衡器、消息队列服务器、缓存服务器等。EventBase 的事件驱动模型和非阻塞 I/O 能力使其非常适合构建处理海量并发连接的网络服务器。例如，Facebook 的高性能 Web 服务器 Proxygen 就大量使用了 EventBase。
② RPC 框架：如 Facebook 的 fbthrift 框架。EventBase 为 RPC 框架提供了高效的网络通信基础，使得 RPC 框架可以实现低延迟、高吞吐量的远程调用。
③ 实时通信系统：如 IM (Instant Messaging) 服务器、在线游戏服务器、实时音视频服务器等。实时通信系统需要处理大量的并发连接和实时数据传输，EventBase 的事件驱动模型和高效的定时器管理功能非常适合这类应用。
④ 分布式系统基础设施：如分布式协调服务 (ZooKeeper, etcd, Consul 的客户端)、分布式数据库客户端、分布式缓存客户端等。这些基础设施组件通常需要与多个服务端节点进行通信，并处理大量的并发请求，EventBase 可以提供高效的网络通信能力。
⑤ 监控系统与日志系统：监控系统需要实时收集和处理大量的监控数据，日志系统需要实时接收和处理大量的日志数据。EventBase 可以用于构建高性能的数据收集和处理 pipeline。
⑥ 客户端应用程序：虽然 EventBase 主要用于服务端开发，但也可以用于构建需要处理网络 I/O 的客户端应用程序，例如网络爬虫、下载工具、P2P 客户端等。
8.3.2 EventBase 在大型项目中的优势 (Advantages of EventBase in Large-scale Projects)
① 高性能与高并发：EventBase 基于事件驱动模型和非阻塞 I/O，能够高效地处理大量的并发连接和事件，满足大型项目对性能和并发的要求。
② 资源效率：EventBase 使用单线程或少量线程来处理大量的事件，减少了线程上下文切换的开销，提高了 CPU 和内存的利用率，降低了资源消耗。
③ 可扩展性：基于 EventBase 构建的系统易于扩展。可以通过增加事件循环线程、使用多进程或分布式部署等方式来提高系统的处理能力。
④ 易用性与开发效率：EventBase 提供了简洁易用的 API，封装了底层操作系统差异，降低了网络编程的复杂性，提高了开发效率。folly 库提供了丰富的工具和组件，可以进一步简化开发工作。
⑤ 成熟稳定：EventBase 已经在 Facebook 等大型公司经过多年的生产环境验证，经历了大规模、高负载的考验，具有很高的成熟度和稳定性。
⑥ 良好的社区支持：folly 库是开源项目，拥有活跃的社区，可以获得及时的技术支持和问题解答。
8.3.3 EventBase 在大型项目中的挑战与应对 (Challenges and Solutions of EventBase in Large-scale Projects)
① 单点故障风险：在单线程 EventBase 模型中，如果事件循环线程崩溃，可能会导致整个服务不可用。
1
**应对方案**：
▮▮▮▮⚝ 多进程部署：可以使用多进程部署，每个进程运行一个 EventBase 实例，进程之间相互独立，一个进程崩溃不会影响其他进程。可以使用进程管理器 (如 systemd, supervisord) 来监控和管理进程。
▮▮▮▮⚝ 多线程 EventBase：可以使用多线程 EventBase 模型，将事件循环分布到多个线程中，提高系统的可用性和容错性。
② 复杂性管理：随着项目规模的增大，基于事件驱动模型的异步编程可能会变得复杂，容易出现回调地狱 (Callback Hell) 和错误处理困难等问题。
1
**应对方案**：
▮▮▮▮⚝ 使用 folly::Futures：folly::Futures 提供了更高级的异步编程抽象，可以有效地解决回调地狱问题，简化异步代码的编写和维护。
▮▮▮▮⚝ 模块化设计：将系统拆分成多个模块，每个模块负责一部分功能，降低系统的复杂性。
▮▮▮▮⚝ 良好的代码组织和文档：保持代码的清晰结构和良好的注释，编写详细的文档，方便团队协作和维护。
③ 调试与性能分析：异步程序的调试和性能分析相对复杂，需要使用专门的工具和方法。
1
**应对方案**：
▮▮▮▮⚝ 使用调试工具：可以使用 GDB 等调试工具来调试 EventBase 程序，设置断点、单步执行、查看变量等。
▮▮▮▮⚝ 性能分析工具：可以使用 perf, FlameGraph 等性能分析工具来分析 EventBase 程序的性能瓶颈，例如 CPU 使用率、I/O 延迟、内存分配等。
▮▮▮▮⚝ 日志与监控：详细的日志和实时的监控数据可以帮助定位问题和分析性能。
④ 学习曲线：EventBase 和事件驱动编程模型对于初学者来说可能有一定的学习曲线。
1
**应对方案**：
▮▮▮▮⚝ 提供完善的文档和教程：本书旨在提供全面、深入的 EventBase 指南，帮助读者快速入门和掌握 EventBase 的使用。
▮▮▮▮⚝ 提供示例代码和最佳实践：提供丰富的示例代码和最佳实践，帮助读者理解和应用 EventBase。
▮▮▮▮⚝ 社区支持：积极参与 folly 社区，与其他开发者交流学习，共同解决问题。
总而言之，EventBase 在大型项目中具有显著的优势，但也存在一些挑战。通过合理的架构设计、最佳实践应用和工具支持，可以有效地应对这些挑战，充分发挥 EventBase 的潜力，构建高性能、高可靠性的大规模系统。
案例分析：Facebook Proxygen
Proxygen 是 Facebook 开源的高性能 HTTP 代理服务器，它基于 folly 库构建，大量使用了 EventBase。Proxygen 被广泛应用于 Facebook 的基础设施中，例如 Web 服务器、负载均衡器、CDN 边缘节点等。Proxygen 的成功应用充分证明了 EventBase 在构建大型、高并发网络系统方面的能力。
Proxygen 的一些关键特性和 EventBase 的应用：
⚝ 事件驱动架构：Proxygen 完全基于事件驱动架构，使用 EventBase 来管理所有的网络 I/O 和事件处理。
⚝ 异步非阻塞：Proxygen 的所有 I/O 操作都是非阻塞的，避免了线程阻塞，提高了并发处理能力。
⚝ 多协议支持：Proxygen 支持 HTTP/1.1, HTTP/2, SPDY 等多种协议，并使用 EventBase 的事件循环来统一处理不同协议的事件。
⚝ 高性能连接管理：Proxygen 使用 EventBase 的定时器功能来实现连接超时管理、Keep-Alive 连接管理等，提高了连接的利用率和服务器的性能。
⚝ 可扩展性：Proxygen 可以通过增加 EventBase 事件循环线程或多进程部署来扩展处理能力，满足不断增长的流量需求。
Proxygen 的成功案例表明，EventBase 是构建高性能、高可靠性的大型网络系统的强大工具。通过深入理解 EventBase 的原理和最佳实践，开发者可以构建出类似 Proxygen 这样优秀的系统，应对各种复杂的网络应用场景。
END_OF_CHAPTER
9. chapter 9： EventBase 的未来展望 (Future Prospects of EventBase)
9.1 EventBase 的发展趋势 (Development Trend of EventBase)
随着技术的不断演进，EventBase 作为 Folly 库中的核心组件，其发展趋势也紧密跟随异步编程和高性能网络编程领域的前沿动态。展望未来，EventBase 可能会在以下几个关键方向上持续演进和发展：
① 更强大的跨平台能力：
EventBase 已经具备良好的跨平台特性，支持 Linux、macOS、Windows 等主流操作系统。未来，为了适应更多样化的部署环境，例如嵌入式系统、移动平台等，EventBase 可能会进一步增强其跨平台兼容性，减少平台差异带来的开发和维护成本。这可能包括更深层次的操作系统抽象，以及对新兴平台和架构的支持。
② 与新型硬件的深度融合：
硬件加速技术，如 IO 卸载（IO offload）、网络加速卡（SmartNIC）等，正在成为提升网络应用性能的关键。EventBase 未来可能会探索与这些新型硬件的深度融合，例如利用 IO 卸载技术减少 CPU 负载，或者利用 SmartNIC 实现更高效的网络事件处理。这将有助于 EventBase 构建的应用在硬件层面获得更高的性能和效率。
③ 更精细化的性能调优工具：
随着应用规模和复杂度的提升，性能调优变得越来越重要。EventBase 未来可能会提供更精细化的性能监控和调优工具，例如更详细的事件循环统计信息、更灵活的事件优先级控制、以及更智能的资源管理策略。这些工具将帮助开发者更深入地了解 EventBase 的运行状况，并针对性地进行性能优化。
④ 更易用和更高层次的抽象：
为了降低 EventBase 的学习曲线，并提升开发效率，未来可能会在 EventBase 之上构建更高层次的抽象层。例如，可以提供更简洁的 API 来处理常见的网络编程任务，或者集成更高级的并发模型，如 Actor 模型、CSP 模型等。这将使得开发者能够更专注于业务逻辑的实现，而无需过多关注底层事件循环的细节。
⑤ 与人工智能和机器学习的结合：
人工智能（AI）和机器学习（ML）技术正在渗透到各个领域，网络编程也不例外。EventBase 未来可能会探索与 AI/ML 技术的结合，例如利用机器学习算法进行智能流量调度、异常检测、以及自适应的性能优化。这将使得基于 EventBase 构建的应用能够更加智能和高效地运行。
⑥ 对新网络协议和技术的支持：
网络技术日新月异，新的网络协议和技术不断涌现，例如 QUIC、HTTP/3、eBPF 等。EventBase 需要及时跟进这些新技术的发展，并提供相应的支持。例如，可以增加对 QUIC 协议的支持，或者利用 eBPF 技术实现更高效的网络事件监控和处理。这将确保 EventBase 始终能够满足不断变化的网络编程需求。
⑦ 更强大的调试和诊断能力：
对于复杂的异步程序，调试和诊断往往是一项挑战。EventBase 未来可能会增强其调试和诊断能力，例如提供更完善的日志记录、更强大的追踪工具、以及更易于理解的错误信息。这将帮助开发者更快速地定位和解决问题，提高开发效率和应用稳定性。
总而言之，EventBase 的未来发展将紧密围绕提升性能、增强易用性、扩展应用场景等方面展开。作为一个成熟且活跃的开源项目，EventBase 有望在未来的异步编程领域继续发挥重要作用，并为构建高性能、高可靠性的网络应用提供坚实的基础。
9.2 与其他事件循环库的比较 (Comparison with other Event Loop Libraries)
EventBase 并非孤立存在，在异步事件驱动编程领域，还有许多其他优秀的事件循环库可供选择。了解 EventBase 与其他库的异同，有助于开发者根据具体需求选择最合适的工具。以下将 EventBase 与几个常见的事件循环库进行比较：libevent、libuv 和 ASIO。
| 特性 (Feature) | EventBase (Folly) | libevent | libuv | ASIO (Boost.Asio / standalone ASIO) |
|---|---|---|---|---|
| 起源 (Origin) | Facebook (现 Meta) | 开源社区 | Node.js 社区 | Boost C++ 库 / standalone |
| 编程语言 (Language) | C++ | C | C | C++ |
| 跨平台性 (Platform) | 优秀 (Linux, macOS, Windows) | 优秀 (Linux, macOS, Windows, 更多 POSIX 系统) | 优秀 (Linux, macOS, Windows, 更多平台) | 优秀 (高度跨平台，依赖于底层操作系统和编译器支持) |
| 核心特性 (Core Features) | 高性能网络编程，集成 Folly 库，C++ 现代化特性 | 轻量级，高性能，成熟稳定，广泛应用 | 专注于 I/O，跨平台抽象，Node.js 底层库 | 强大的异步 I/O 模型，灵活的 Proactor 模式，C++ 标准库风格，可扩展性强 |
| 易用性 (Ease of Use) | 相对复杂，需要理解 Folly 库，C++ 进阶知识 | 相对简单，C 风格 API，学习曲线平缓 | 适中，C 风格 API，但抽象程度较高，易于上手 | 灵活但复杂，C++ 模板编程，概念较多，学习曲线陡峭 |
| 性能 (Performance) | 非常优秀，针对高性能网络应用优化，零拷贝等技术 | 非常优秀，成熟的事件循环实现，性能卓越 | 优秀，针对 I/O 密集型应用优化，性能良好 | 优秀，基于操作系统底层 API，性能可调优 |
| 扩展性 (Extensibility) | 良好，支持自定义事件源，易于集成 Folly 库其他组件 | 良好，支持多种事件通知机制，可扩展性强 | 良好，插件式架构，可扩展性较好 | 非常优秀，高度可扩展，支持自定义 I/O 对象，服务，执行器等 |
| 社区支持 (Community) | 活跃，Facebook 内部广泛使用，Folly 社区支持 | 庞大且活跃，广泛应用于各种开源项目和商业产品 | 活跃，Node.js 生态系统，libuv 社区支持 | 庞大且活跃，Boost 社区，ASIO 独立版本社区 |
| 适用场景 (Use Cases) | 高性能网络服务器，大型分布式系统，需要与 Folly 库集成 | 网络服务器，代理服务器，协议处理，各种网络应用 | I/O 密集型应用，Node.js 应用，跨平台应用开发 | 高性能网络应用，网络协议栈，游戏服务器，需要高度定制和灵活性的应用 |
总结 (Summary)：
⚝ EventBase: 作为 Folly 库的一部分，EventBase 深度融合了 Folly 的各种组件，例如 Futures、IO 库等，更适合于使用 Folly 库构建大型 C++ 项目的场景。其性能非常出色，尤其在 Facebook 内部的大规模应用中得到了充分验证。但相对而言，学习曲线较陡峭，需要对 C++ 和 Folly 库有一定的了解。
⚝ libevent: 作为一个经典的事件循环库，libevent 以其轻量级、高性能和稳定性而闻名。libevent 的 API 简洁明了，学习曲线平缓，社区支持非常活跃。它被广泛应用于各种开源项目和商业产品中，是构建高性能网络应用的可靠选择。但 libevent 主要以 C 语言编写，对于 C++ 开发者而言，可能需要进行一定的封装和适配。
⚝ libuv: libuv 是 Node.js 的底层库，专注于提供跨平台的异步 I/O 能力。libuv 的 API 设计简洁易用，抽象程度较高，易于上手。它在跨平台方面做得非常出色，支持多种操作系统和平台。libuv 更适合于构建 I/O 密集型应用，尤其是在 Node.js 生态系统中。对于 C++ 开发者而言，libuv 也是一个不错的跨平台异步 I/O 解决方案。
⚝ ASIO: ASIO (Asynchronous Input/Output) 是一个 C++ 网络编程库，最初是 Boost 库的一部分，现在也有独立的版本。ASIO 采用了现代 C++ 的编程范式，例如模板、泛型编程等，提供了非常灵活和强大的异步 I/O 模型。ASIO 的 Proactor 模式能够充分利用操作系统提供的异步 I/O 接口，实现高性能的网络编程。ASIO 的学习曲线较为陡峭，但一旦掌握，将能够构建高度定制化和高性能的网络应用。
如何选择 (How to Choose)：
选择哪个事件循环库，取决于具体的项目需求和团队的技术栈。
⚝ 如果项目已经使用了 Folly 库，或者需要深度集成 Folly 的其他组件，那么 EventBase 是一个自然的选择。
⚝ 如果追求轻量级、稳定性和成熟度，且项目主要使用 C 语言或者对 C++ 的现代化特性要求不高，libevent 是一个非常好的选择。
⚝ 如果需要构建跨平台的 I/O 密集型应用，或者项目使用了 Node.js 技术栈，libuv 是一个值得考虑的方案。
⚝ 如果项目需要高度的灵活性和可定制性，并且团队熟悉现代 C++ 编程，ASIO 能够提供强大的功能和性能。
在实际应用中，也可以根据项目的具体需求，将不同的事件循环库进行组合使用，或者基于现有的库进行二次开发，以满足特定的场景需求。
appendix A： 常用术语表 (Glossary of Common Terms)
| 术语 (Term) | 解释 (Explanation) by default, the user wants me to write chapter 9, appendix A, and appendix B. I will write them step by step.## 9. chapter 9： EventBase 的未来展望 (Future Prospects of EventBase)
9.1 EventBase 的发展趋势 (Development Trend of EventBase)
随着异步编程范式的日益普及和网络技术的飞速发展，EventBase 作为高性能网络编程的基础组件，其未来发展充满了机遇与挑战。展望未来，EventBase 的发展趋势可能体现在以下几个关键方面：
① 持续优化性能与效率：
性能始终是网络编程的核心关注点。EventBase 作为高性能库，将持续在性能优化上发力。这包括：
⚝ 零拷贝技术 (Zero-copy Techniques)：更深入地应用零拷贝技术，例如 splice、sendfile 等系统调用，减少数据在内核态和用户态之间的拷贝，提升数据传输效率。
⚝ 内核旁路 (Kernel Bypass)：探索内核旁路技术，例如 DPDK、XDP 等，绕过内核协议栈，直接在用户态处理网络数据包，进一步降低延迟，提升吞吐量。
⚝ 硬件加速 (Hardware Acceleration)：充分利用硬件加速特性，例如 CPU 指令集优化、网络适配器硬件卸载（TCP Offload Engine）等，将计算密集型任务卸载到硬件，释放 CPU 资源。
⚝ 更高效的事件分发机制 (Efficient Event Dispatch Mechanism)：持续优化事件分发机制，例如采用更高效的数据结构、更优化的调度算法，减少事件处理的开销。
② 增强对新型网络协议的支持：
互联网协议不断演进，新的协议层出不穷。EventBase 需要紧跟时代步伐，积极拥抱和支持新型网络协议，例如：
⚝ QUIC 协议：QUIC 协议作为下一代互联网传输协议，具有低延迟、高可靠性、安全等特点，是未来网络应用的重要发展方向。EventBase 需要加强对 QUIC 协议的支持，为构建基于 QUIC 的应用提供基础设施。
⚝ HTTP/3：基于 QUIC 协议的 HTTP/3 协议，将成为未来 Web 应用的主流协议。EventBase 需要支持 HTTP/3，以便开发者能够构建更高效的 Web 服务。
⚝ gRPC：gRPC 是一种高性能、通用的 RPC 框架，基于 HTTP/2 协议。EventBase 可以更好地支持 gRPC，方便开发者构建微服务架构。
⚝ 新型数据传输协议：随着应用场景的不断扩展，可能会涌现出更多针对特定场景优化的数据传输协议。EventBase 需要保持开放性和可扩展性，以便能够快速支持这些新型协议。
③ 提升易用性和开发效率：
EventBase 在提供高性能的同时，也需要不断提升易用性，降低开发门槛，提高开发效率。这可以从以下几个方面入手：
⚝ 更简洁的 API 设计 (Simplified API Design)：在保持功能强大的前提下，简化 API 设计，提供更易于理解和使用的接口，减少开发者的学习成本。
⚝ 更完善的文档和示例 (Comprehensive Documentation and Examples)：提供更全面、更清晰的文档，以及更丰富的示例代码，帮助开发者快速上手和解决问题。
⚝ 更强大的调试工具 (Powerful Debugging Tools)：提供更强大的调试工具，例如事件追踪、性能分析、内存泄漏检测等，方便开发者定位和解决问题。
⚝ 集成开发环境 (IDE) 支持：加强与主流集成开发环境的集成，提供代码自动完成、语法检查、调试等功能，提升开发体验。
④ 拓展应用场景：
EventBase 的应用场景不应局限于传统的网络服务器开发。未来，可以进一步拓展其应用领域，例如：
⚝ 物联网 (IoT)：物联网设备数量庞大，对网络连接和数据处理能力提出了更高的要求。EventBase 可以应用于物联网网关、边缘计算节点等场景，提供高效的事件驱动处理能力。
⚝ 实时音视频 (Real-time Audio/Video)：实时音视频应用对延迟和带宽要求非常高。EventBase 可以应用于实时音视频服务器、流媒体服务器等场景，提供低延迟、高吞吐量的数据传输能力。
⚝ 游戏服务器 (Game Servers)：游戏服务器需要处理大量的并发连接和实时事件。EventBase 可以应用于游戏服务器后端开发，提供高性能、高可靠性的网络通信基础设施。
⚝ 金融交易系统 (Financial Trading Systems)：金融交易系统对延迟和稳定性要求极其苛刻。EventBase 可以应用于高频交易系统、交易所平台等场景，提供毫秒级的事件处理能力。
⑤ 加强社区合作与生态建设：
开源社区是 EventBase 发展的重要力量。未来，需要进一步加强社区合作，共同推动 EventBase 的发展：
⚝ 吸引更多开发者参与 (Attract More Developers)：通过举办技术交流活动、发布技术博客、参与开源社区等方式，吸引更多开发者参与到 EventBase 的开发和维护中来。
⚝ 建立更完善的社区治理机制 (Improved Community Governance)：建立更加开放、透明、高效的社区治理机制，鼓励社区成员积极参与项目决策和贡献代码。
⚝ 拓展生态系统 (Ecosystem Expansion)：围绕 EventBase 构建更完善的生态系统，例如开发基于 EventBase 的网络库、应用框架、工具集等，方便开发者更高效地使用 EventBase。
⚝ 与其他开源项目合作 (Collaboration with Other Open Source Projects)：加强与 Folly 库内其他组件以及其他开源项目的合作，例如 libevent、libuv、ASIO 等，共同推动异步编程技术的发展。
总而言之，EventBase 的未来发展将围绕高性能、新协议、易用性、多场景和社区生态等方面展开。通过不断的技术创新和社区合作，EventBase 有望在未来的异步编程领域继续保持领先地位，并为构建更高效、更可靠的网络应用提供强有力的支持。
9.2 与其他事件循环库的比较 (Comparison with other Event Loop Libraries)
在异步事件驱动编程领域，EventBase 并非唯一的选择。为了帮助读者更好地理解 EventBase 的特点和适用场景，本节将 EventBase 与其他几个流行的事件循环库进行对比分析，包括 libevent、libuv 和 ASIO。
| 特性 (Feature) | EventBase (Folly) | libevent | libuv | ASIO (Boost.Asio / standalone ASIO) |
|---|---|---|---|---|
| 编程语言 (Language) | C++ (现代 C++ 特性) | C (兼容 C++) | C (兼容 C++) | C++ (现代 C++ 模板) |
| 设计目标 (Design Goal) | 高性能网络应用，与 Folly 库深度集成，企业级应用需求 | 轻量级，高性能，通用事件通知库，广泛适用性 | 跨平台 I/O 抽象，Node.js 底层库，通用异步 I/O | 高度灵活的异步 I/O 框架，Proactor 模式，C++ 标准化方向，可扩展性强 |
| 跨平台性 (Platform) | 优秀 (Linux, macOS, Windows, 移动平台) | 优秀 (Linux, macOS, Windows, *BSD, Solaris, ...) | 优秀 (Linux, macOS, Windows, *BSD, Android, iOS, ...) | 优秀 (高度跨平台，依赖于操作系统和编译器支持) |
| 核心模型 (Core Model) | Reactor 模式，基于 epoll/kqueue/select/iocp | Reactor 模式，基于 epoll/kqueue/select/poll/devpoll/win32 | Reactor 模式，基于 epoll/kqueue/select/poll/iocp/event ports | Proactor 模式为主，Reactor 模式为辅，基于操作系统异步 I/O 接口 (epoll, kqueue, IOCP) |
| 易用性 (Ease of Use) | 中等偏上，C++ 风格，需要熟悉 Folly 库，概念较多 | 简单，C 风格 API，学习曲线平缓，文档完善 | 简单，C 风格 API，抽象程度高，易于上手，文档友好 | 复杂，C++ 模板编程，概念多，学习曲线陡峭，但灵活性极高 |
| 性能 (Performance) | 非常优秀，针对高性能网络应用优化，零拷贝，高效调度 | 非常优秀，成熟稳定，经过长期优化，性能卓越 | 优秀，针对 I/O 密集型应用优化，性能良好 | 优秀，基于操作系统底层异步 I/O，性能可调优，潜力巨大 |
| 扩展性 (Extensibility) | 良好，支持自定义事件源，易于集成 Folly 组件 | 良好，支持多种事件通知机制，可扩展性强，插件机制 | 良好，插件式架构，可扩展性较好，libuv 插件 | 非常优秀，高度可扩展，支持自定义 I/O 对象，服务，执行器，协程集成 |
| 社区活跃度 (Community Activity) | 活跃，Meta 内部广泛使用，Folly 社区支持 | 庞大且活跃，广泛应用于各种开源项目和商业产品 | 活跃，Node.js 生态系统，libuv 社区支持 | 庞大且活跃，Boost 社区，ASIO 独立版本社区，C++ 标准委员会影响 |
| 适用场景 (Use Cases) | 高性能网络服务器，大型分布式系统，需要 Folly 集成 | 网络服务器，代理服务器，协议处理，各种网络应用 | I/O 密集型应用，Node.js 应用，跨平台应用开发 | 高性能网络应用，网络协议栈，游戏服务器，需要高度定制和灵活性的应用，现代 C++ 开发 |
对比分析 (Comparative Analysis)：
⚝ EventBase: EventBase 作为 Folly 库的核心组件，与 Folly 库的其他部分（如 Futures、IO 库、Concurrency 库等）紧密集成，能够充分发挥 Folly 库的整体优势。EventBase 采用现代 C++ 风格编写，性能非常出色，尤其在 Meta 内部的大规模应用中得到了广泛验证。但其学习曲线相对较陡峭，需要对 C++ 和 Folly 库有一定的了解。EventBase 更适合于构建高性能、企业级的网络应用，尤其是在已经使用或计划使用 Folly 库的项目中。
⚝ libevent: libevent 是一个久经考验的事件通知库，以其轻量级、高性能和稳定性而著称。libevent 的 API 简洁明了，学习曲线平缓，文档完善，社区支持非常活跃。它被广泛应用于各种开源项目和商业产品中，是构建高性能网络应用的可靠选择。libevent 主要以 C 语言编写，对于 C++ 开发者而言，可能需要进行一定的封装和适配。libevent 适用于各种网络应用场景，尤其适合对性能和稳定性有较高要求的项目。
⚝ libuv: libuv 是 Node.js 的底层库，专注于提供跨平台的异步 I/O 能力。libuv 的 API 设计简洁易用，抽象程度较高，易于上手，文档友好。它在跨平台方面做得非常出色，支持多种操作系统和平台。libuv 更侧重于 I/O 密集型应用，尤其是在 Node.js 生态系统中。对于 C++ 开发者而言，libuv 也是一个不错的跨平台异步 I/O 解决方案，尤其适合需要快速开发跨平台应用的场景。
⚝ ASIO: ASIO (Asynchronous Input/Output) 是一个 C++ 网络编程库，最初是 Boost 库的一部分，现在也有独立的 standalone 版本。ASIO 采用了现代 C++ 的编程范式，例如模板、泛型编程等，提供了非常灵活和强大的异步 I/O 模型。ASIO 的 Proactor 模式能够充分利用操作系统提供的异步 I/O 接口，实现高性能的网络编程。ASIO 的学习曲线较为陡峭，但一旦掌握，将能够构建高度定制化和高性能的网络应用。ASIO 更适合于需要高度灵活性和可定制性，并且团队熟悉现代 C++ 编程的项目。同时，ASIO 也积极参与 C++ 标准化进程，其设计理念和技术对 C++ 标准库的异步编程方向产生了重要影响。
选择建议 (Selection Recommendations)：
选择哪个事件循环库，应综合考虑项目需求、团队技术栈、性能要求、开发周期等因素。
⚝ 优先选择 EventBase 的场景：
▮▮▮▮⚝ 项目已经或计划使用 Folly 库，需要与 Folly 库的其他组件深度集成。
▮▮▮▮⚝ 项目对性能要求极高，需要充分利用 Folly 库的高性能特性。
▮▮▮▮⚝ 团队熟悉 C++ 和 Folly 库，能够应对 EventBase 相对复杂的学习曲线。
▮▮▮▮⚝ 项目需要构建企业级、大型分布式系统。
⚝ 优先选择 libevent 的场景：
▮▮▮▮⚝ 项目对稳定性、成熟度要求较高，需要一个久经考验的事件循环库。
▮▮▮▮⚝ 项目对性能有较高要求，但不需要极致的性能优化。
▮▮▮▮⚝ 团队熟悉 C 语言或 C++，希望使用 API 简洁、学习曲线平缓的库。
▮▮▮▮⚝ 项目需要快速开发，希望利用 libevent 完善的文档和社区支持。
⚝ 优先选择 libuv 的场景：
▮▮▮▮⚝ 项目需要构建跨平台应用，希望选择跨平台性优秀的库。
▮▮▮▮⚝ 项目是 I/O 密集型应用，例如 Node.js 应用、网络工具等。
▮▮▮▮⚝ 团队希望使用 API 简洁、易于上手的库，快速构建原型或小型项目。
▮▮▮▮⚝ 项目需要与 Node.js 生态系统集成。
⚝ 优先选择 ASIO 的场景：
▮▮▮▮⚝ 项目对灵活性、可定制性要求极高，需要构建高度定制化的网络应用。
▮▮▮▮⚝ 项目对性能有极致追求，需要充分利用操作系统底层异步 I/O 接口。
▮▮▮▮⚝ 团队熟悉现代 C++ 编程，能够应对 ASIO 相对复杂的学习曲线。
▮▮▮▮⚝ 项目希望采用 C++ 标准化方向的技术，为未来技术发展做好准备。
在实际项目中，也可以根据具体需求，将不同的事件循环库进行组合使用，或者基于现有的库进行二次开发，以满足特定的场景需求。例如，可以使用 libevent 作为底层事件循环，在其之上构建更高层次的抽象层，或者将 ASIO 与其他库集成，利用其 Proactor 模式的优势。
appendix A： 常用术语表 (Glossary of Common Terms)
| 术语 (Term) | 解释 (Explanation)
Reactor (反应器)：一种事件处理模式，程序通过监听文件描述符上的事件（例如，可读、可写事件），并在事件发生时调用相应的处理函数。EventBase 采用 Reactor 模式。
Event Loop (事件循环)：事件循环是事件驱动编程的核心，它不断轮询监听的事件，并处理就绪的事件。EventBase 的核心就是事件循环。
File Descriptor (文件描述符)：在 Unix-like 系统中，文件描述符是用于表示文件、socket 等资源的整数。EventBase 可以监听文件描述符上的事件。
Timer Event (定时器事件)：定时器事件是指在指定时间后触发的事件。EventBase 提供了定时器事件的支持，可以用于实现定时任务。
Signal Event (信号事件)：信号事件是指当进程接收到特定信号时触发的事件。EventBase 提供了信号事件的支持，可以用于处理进程信号。
EventHandler (事件处理器)：事件处理器是用于处理特定类型事件的回调函数或对象。EventBase 使用 EventHandler 类族来处理不同类型的事件。
Asynchronous Programming (异步编程)：异步编程是一种并发编程模式，允许程序在等待 I/O 操作完成时继续执行其他任务，从而提高程序的响应性和吞吐量。EventBase 是异步编程的基础。
Non-blocking I/O (非阻塞 I/O)：非阻塞 I/O 是指在进行 I/O 操作时，如果数据没有准备好，系统调用不会阻塞，而是立即返回。EventBase 基于非阻塞 I/O 实现事件驱动。
Edge-Triggered (边缘触发)：边缘触发是一种事件通知模式，只有当文件描述符的状态发生变化时（例如，从不可读变为可读），才会触发事件通知。epoll 和 kqueue 支持边缘触发模式。
Level-Triggered (水平触发)：水平触发是一种事件通知模式，只要文件描述符的状态满足条件（例如，可读），就会持续触发事件通知，直到程序处理完该事件。select 和 poll 支持水平触发模式。
epoll (事件多路复用)：epoll 是 Linux 系统下高效的事件多路复用机制，能够同时监听大量文件描述符上的事件。EventBase 在 Linux 系统下默认使用 epoll。
kqueue (事件多路复用)：kqueue 是 FreeBSD、macOS 等系统下高效的事件多路复用机制，功能类似于 epoll。EventBase 在 macOS 系统下默认使用 kqueue。
select/poll (事件多路复用)：select 和 poll 是 POSIX 标准定义的事件多路复用机制，跨平台性较好，但性能相对较低。EventBase 在一些平台下会使用 select 或 poll 作为备选方案。
IOCP (I/O Completion Port)：IOCP 是 Windows 系统下高效的异步 I/O 完成端口机制。EventBase 在 Windows 系统下使用 IOCP。
Future (期物)：Future 是异步编程中用于表示异步操作结果的对象。Folly::Future 是 Folly 库提供的 Future 实现，可以与 EventBase 协同工作，简化异步编程。
TaskQueue (任务队列)：TaskQueue 是一种用于管理和调度任务的队列。Folly::TaskQueue 是 Folly 库提供的任务队列实现，可以与 EventBase 结合使用，实现任务调度和并发控制。
Zero-copy (零拷贝)：零拷贝技术旨在减少数据在内存中的拷贝次数，提高数据传输效率。EventBase 可以利用零拷贝技术优化网络数据传输。
Reactor Pattern (Reactor 模式)：Reactor 模式是一种事件驱动的设计模式，用于构建非阻塞、事件驱动的应用程序。EventBase 基于 Reactor 模式实现。
Proactor Pattern (Proactor 模式)：Proactor 模式是另一种事件驱动的设计模式，与 Reactor 模式不同，Proactor 模式由操作系统负责执行 I/O 操作，并在操作完成后通知应用程序。ASIO 主要采用 Proactor 模式。
Thread Pool (线程池)：线程池是一种管理和复用线程的技术，可以减少线程创建和销毁的开销，提高程序的并发性能。EventBase 可以与线程池结合使用，实现多线程事件处理。
Concurrency (并发)：并发是指程序能够同时处理多个任务的能力。EventBase 是实现并发编程的基础组件。
Parallelism (并行)：并行是指程序能够同时在多个处理器核心上执行多个任务的能力。EventBase 可以与多线程或多进程技术结合使用，实现并行计算。
appendix B： EventBase 快速参考 (EventBase Quick Reference)
本附录提供 EventBase 常用 API 和概念的快速参考，方便开发者快速查阅和使用。
1. EventBase 类
⚝ 创建与销毁 (Creation and Destruction)：
1
#include <folly/io/async/EventBase.h>
2
3
folly::EventBase evb; // 创建 EventBase 对象 (Creates an EventBase object)
4
// EventBase 对象在超出作用域时自动销毁 (EventBase object is automatically destroyed when it goes out of scope)
⚝ 运行事件循环 (Running the Event Loop)：
1
evb.loop(); // 运行事件循环，直到没有事件 (Runs the event loop until no more events)
2
evb.loopForever(); // 永久运行事件循环 (Runs the event loop forever)
3
evb.loopOnce(); // 运行事件循环一次 (Runs the event loop once)
4
evb.loopBody(); // 执行事件循环的核心逻辑，但不阻塞 (Executes the core logic of the event loop, but does not block)
5
evb.stop(); // 停止事件循环 (Stops the event loop)
6
evb.runInLoop([&]{ /* ... */ }); // 在 EventBase 线程中执行 lambda 函数 (Executes a lambda function in the EventBase thread)
7
evb.runInLoop([&]{ /* ... */ }, folly::FuncWeak::NORMAL); // 指定执行方式 (Specifies the execution mode)
⚝ 获取 EventBase 信息 (Getting EventBase Information)：
1
bool isInEventBaseThread() const; // 判断当前线程是否是 EventBase 线程 (Checks if the current thread is the EventBase thread)
2
folly::EventBase* getEventBase() const; // 获取当前线程的 EventBase 指针 (Gets the EventBase pointer of the current thread)
⚝ 定时器操作 (Timer Operations)：
1
folly::Timer* timer = new folly::Timer(&evb); // 创建定时器 (Creates a timer)
2
timer->scheduleTimeout([&]{ /* 定时器回调 */ }, std::chrono::milliseconds(100)); // 调度单次定时器 (Schedules a one-shot timer)
3
timer->scheduleTimeout([&]{ /* 定时器回调 */ }, std::chrono::milliseconds(100), std::chrono::milliseconds(1000)); // 调度重复定时器 (Schedules a repeating timer)
4
timer->cancelTimeout(); // 取消定时器 (Cancels the timer)
⚝ 文件描述符事件操作 (File Descriptor Event Operations)：
1
// 添加文件描述符事件 (Adds a file descriptor event)
2
evb.addHandler(handler, fd, folly::EventBase::READ | folly::EventBase::WRITE);
3
// 移除文件描述符事件 (Removes a file descriptor event)
4
evb.removeHandler(handler);
5
// 修改文件描述符事件 (Modifies a file descriptor event)
6
evb.updateHandler(handler, folly::EventBase::READ);
⚝ 信号事件操作 (Signal Event Operations)：
1
// 注册信号处理器 (Registers a signal handler)
2
evb.installSignalHandler(signal_number, handler);
3
// 移除信号处理器 (Removes a signal handler)
4
evb.uninstallSignalHandler(signal_number, handler);
2. EventHandler 类族
⚝ EventHandler (事件处理器基类)：
1
class EventHandler {
2
public:
3
virtual ~EventHandler() = default;
4
virtual void handlerReady(uint16_t events) noexcept = 0; // 事件就绪回调 (Event ready callback)
5
virtual void handlerError(folly::exception_wrapper ew) noexcept; // 事件错误回调 (Event error callback)
6
virtual void detachEventBase() noexcept; // 与 EventBase 解绑回调 (Detaches from EventBase callback)
7
virtual void attachEventBase(EventBase* evb) noexcept; // 绑定 EventBase 回调 (Attaches to EventBase callback)
8
EventBase* getEventBase() const noexcept; // 获取绑定的 EventBase (Gets the bound EventBase)
9
int getFd() const noexcept; // 获取关联的文件描述符 (Gets the associated file descriptor)
10
};
⚝ 继承自 EventHandler 的常用类 (Common classes inherited from EventHandler)：
▮▮▮▮⚝ folly::AsyncSocket：异步 socket 操作类，用于 TCP/UDP 网络编程。
▮▮▮▮⚝ folly::AsyncServerSocket：异步 server socket 类，用于 TCP 服务器开发。
▮▮▮▮⚝ folly::AsyncTransportWrapper：异步传输包装类，用于扩展异步传输功能。
3. TimerHandler 和 SignalHandler
⚝ TimerHandler (定时器处理器)：
▮▮▮▮⚝ 使用 folly::Timer 类进行定时器操作，回调函数在 Timer::scheduleTimeout 中指定。
⚝ SignalHandler (信号处理器)：
1
class SignalHandler : public EventHandler {
2
public:
3
using SignalCallback = std::function<void(int signum)>;
4
explicit SignalHandler(SignalCallback cb); // 构造函数，传入信号回调函数 (Constructor, takes a signal callback function)
5
void handlerReady(uint16_t events) noexcept override; // 信号就绪回调 (Signal ready callback)
6
private:
7
SignalCallback callback_;
8
};
1
使用 `EventBase::installSignalHandler` 注册信号处理器。
4. 文件描述符操作 API
⚝ 文件描述符事件类型 (File Descriptor Event Types)：
▮▮▮▮⚝ folly::EventBase::READ：文件描述符可读事件。
▮▮▮▮⚝ folly::EventBase::WRITE：文件描述符可写事件。
▮▮▮▮⚝ folly::EventBase::READ_WRITE：文件描述符可读可写事件。
▮▮▮▮⚝ folly::EventBase::PERSIST：事件持久化，即使事件被处理后仍然监听。
▮▮▮▮⚝ folly::EventBase::ET：边缘触发模式 (Edge-Triggered)。
⚝ 文件描述符操作函数 (File Descriptor Operation Functions)：
▮▮▮▮⚝ EventBase::addHandler(EventHandler* handler, int fd, uint16_t events)：添加文件描述符事件处理器。
▮▮▮▮⚝ EventBase::removeHandler(EventHandler* handler)：移除文件描述符事件处理器。
▮▮▮▮⚝ EventBase::updateHandler(EventHandler* handler, uint16_t events)：更新文件描述符事件处理器监听的事件类型。
5. 常用宏 (Common Macros)
⚝ FOLLY_EVENT_BASE_CHECK_THREAD(): 断言当前线程是 EventBase 线程 (Asserts that the current thread is the EventBase thread). 用于调试和线程安全检查。
注意 (Note)：
⚝ 本快速参考仅列出 EventBase 的常用 API 和概念，更详细的用法和高级特性请参考官方文档和源码。
⚝ 使用 EventBase 进行异步编程需要理解事件驱动模型和相关概念，建议结合本书其他章节进行学习。
END_OF_CHAPTER