053 《Folly与Facebook Thrift权威指南：从入门到精通 (Folly and Facebook Thrift: The Definitive Guide from Beginner to Expert)》
🌟🌟🌟本文案由Gemini 2.0 Flash Thinking Experimental 01-21创作，用来辅助学习知识。🌟🌟🌟
书籍大纲
▮▮▮▮ 1. chapter 1： 启程：Folly与Thrift的世界 (Getting Started: The World of Folly and Thrift)
▮▮▮▮▮▮▮ 1.1 Folly与Thrift：现代C++基础设施的基石 (Folly and Thrift: Cornerstones of Modern C++ Infrastructure)
▮▮▮▮▮▮▮ 1.2 为什么选择Folly？Folly的设计哲学与优势 (Why Folly? Folly's Design Philosophy and Advantages)
▮▮▮▮▮▮▮ 1.3 为什么选择Thrift？Thrift的跨语言通信魅力 (Why Thrift? The Cross-Language Communication Charm of Thrift)
▮▮▮▮▮▮▮ 1.4 开发环境搭建：快速开始Folly与Thrift之旅 (Development Environment Setup: Quick Start to Folly and Thrift Journey)
▮▮▮▮▮▮▮▮▮▮▮ 1.4.1 Folly编译与安装 (Folly Compilation and Installation)
▮▮▮▮▮▮▮▮▮▮▮ 1.4.2 Thrift编译器安装与配置 (Thrift Compiler Installation and Configuration)
▮▮▮▮▮▮▮▮▮▮▮ 1.4.3 第一个Folly程序：Hello Folly (First Folly Program: Hello Folly)
▮▮▮▮▮▮▮▮▮▮▮ 1.4.4 第一个Thrift程序：Hello Thrift (First Thrift Program: Hello Thrift)
▮▮▮▮ 2. chapter 2： Folly核心组件：构建高效C++应用 (Folly Core Components: Building Efficient C++ Applications)
▮▮▮▮▮▮▮ 2.1 StringPiece：高效字符串处理的利器 (StringPiece: A Powerful Tool for Efficient String Handling)
▮▮▮▮▮▮▮ 2.2 FBString与SmallString：定制化字符串类 (FBString and SmallString: Customized String Classes)
▮▮▮▮▮▮▮ 2.3 Containers：FBVector与F14Map (Containers: FBVector and F14Map)
▮▮▮▮▮▮▮ 2.4 Option与Expected：优雅的错误处理 (Option and Expected: Elegant Error Handling)
▮▮▮▮▮▮▮ 2.5 Futures与Promises：异步编程的基石 (Futures and Promises: Cornerstones of Asynchronous Programming)
▮▮▮▮▮▮▮ 2.6 Executors：任务调度与并行执行 (Executors: Task Scheduling and Parallel Execution)
▮▮▮▮▮▮▮ 2.7 Time：时间处理与时间轮 (Time: Time Handling and Time Wheel)
▮▮▮▮▮▮▮ 2.8 动态类型：Dynamic与Variant (Dynamic Types: Dynamic and Variant)
▮▮▮▮ 3. chapter 3： Thrift IDL详解：定义你的数据与服务 (Thrift IDL Deep Dive: Define Your Data and Services)
▮▮▮▮▮▮▮ 3.1 Thrift IDL语法基础：数据类型、结构体、枚举 (Thrift IDL Syntax Basics: Data Types, Structs, Enums)
▮▮▮▮▮▮▮ 3.2 服务定义：接口与方法 (Service Definition: Interfaces and Methods)
▮▮▮▮▮▮▮ 3.3 命名空间与包含：模块化你的Thrift定义 (Namespaces and Includes: Modularize Your Thrift Definitions)
▮▮▮▮▮▮▮ 3.4 注释与元数据：增强IDL的可读性与可维护性 (Annotations and Metadata: Enhance IDL Readability and Maintainability)
▮▮▮▮▮▮▮ 3.5 异常处理：定义与使用Thrift异常 (Exception Handling: Defining and Using Thrift Exceptions)
▮▮▮▮▮▮▮ 3.6 类型别名与常量：简化IDL定义 (Type Aliases and Constants: Simplify IDL Definitions)
▮▮▮▮ 4. chapter 4： Thrift协议与传输层：通信的基石 (Thrift Protocols and Transports: Cornerstones of Communication)
▮▮▮▮▮▮▮ 4.1 协议 (Protocols)：
▮▮▮▮▮▮▮▮▮▮▮ 4.1.1 Binary Protocol (二进制协议)
▮▮▮▮▮▮▮▮▮▮▮ 4.1.2 Compact Protocol (压缩协议)
▮▮▮▮▮▮▮▮▮▮▮ 4.1.3 JSON Protocol (JSON协议)
▮▮▮▮▮▮▮ 4.2 传输层 (Transports)：
▮▮▮▮▮▮▮▮▮▮▮ 4.2.1 TServerSocket与TSocket：TCP套接字传输 (TServerSocket and TSocket: TCP Socket Transport)
▮▮▮▮▮▮▮▮▮▮▮ 4.2.2 TBufferedTransport：缓冲传输 (TBufferedTransport: Buffered Transport)
▮▮▮▮▮▮▮▮▮▮▮ 4.2.3 TFramedTransport：分帧传输 (TFramedTransport: Framed Transport)
▮▮▮▮▮▮▮▮▮▮▮ 4.2.4 THttpClient与THttpServer：HTTP传输 (THttpClient and THttpServer: HTTP Transport)
▮▮▮▮▮▮▮ 4.3 协议与传输层的选择：性能与场景考量 (Protocol and Transport Selection: Performance and Scenario Considerations)
▮▮▮▮ 5. chapter 5： Thrift代码生成与实践：构建客户端与服务端 (Thrift Code Generation and Practice: Building Clients and Servers)
▮▮▮▮▮▮▮ 5.1 Thrift编译器详解：代码生成选项与定制 (Thrift Compiler Deep Dive: Code Generation Options and Customization)
▮▮▮▮▮▮▮ 5.2 C++服务端开发：实现Thrift服务 (C++ Server Development: Implementing Thrift Services)
▮▮▮▮▮▮▮ 5.3 C++客户端开发：调用Thrift服务 (C++ Client Development: Calling Thrift Services)
▮▮▮▮▮▮▮ 5.4 多语言客户端支持：Java、Python等 (Multi-Language Client Support: Java, Python, etc.)
▮▮▮▮▮▮▮ 5.5 异步Thrift客户端与服务端 (Asynchronous Thrift Clients and Servers)
▮▮▮▮ 6. chapter 6： Folly网络编程进阶：Asio与IO模型 (Advanced Folly Network Programming: Asio and IO Models)
▮▮▮▮▮▮▮ 6.1 Asio基础：理解IO模型与事件循环 (Asio Basics: Understanding IO Models and Event Loops)
▮▮▮▮▮▮▮ 6.2 使用Folly Socket：构建高性能网络应用 (Using Folly Socket: Building High-Performance Network Applications)
▮▮▮▮▮▮▮ 6.3 Futures for Networking：异步网络操作的优雅处理 (Futures for Networking: Elegant Handling of Asynchronous Network Operations)
▮▮▮▮▮▮▮ 6.4 协程在Folly网络编程中的应用 (Coroutines in Folly Network Programming)
▮▮▮▮▮▮▮ 6.5 网络安全：SSL/TLS集成 (Network Security: SSL/TLS Integration)
▮▮▮▮ 7. chapter 7： Folly并发与并行：充分利用多核性能 (Folly Concurrency and Parallelism: Fully Utilizing Multi-Core Performance)
▮▮▮▮▮▮▮ 7.1 Futures与Promises进阶：组合与控制流 (Advanced Futures and Promises: Composition and Control Flow)
▮▮▮▮▮▮▮ 7.2 Executors框架深入：定制化Executor与调度策略 (Executors Framework Deep Dive: Customized Executors and Scheduling Strategies)
▮▮▮▮▮▮▮ 7.3 并发数据结构：ConcurrentHashMap等 (Concurrent Data Structures: ConcurrentHashMap, etc.)
▮▮▮▮▮▮▮ 7.4 原子操作与内存模型 (Atomic Operations and Memory Model)
▮▮▮▮▮▮▮ 7.5 无锁编程实践 (Lock-Free Programming Practices)
▮▮▮▮ 8. chapter 8： Thrift高级特性与最佳实践 (Advanced Thrift Features and Best Practices)
▮▮▮▮▮▮▮ 8.1 Thrift中间件 (Middleware) 与拦截器 (Interceptors)：请求处理的扩展与定制 (Thrift Middleware and Interceptors: Extension and Customization of Request Processing)
▮▮▮▮▮▮▮ 8.2 Thrift服务治理：负载均衡、熔断、限流 (Thrift Service Governance: Load Balancing, Circuit Breaking, Rate Limiting)
▮▮▮▮▮▮▮ 8.3 Thrift监控与日志：性能分析与故障排查 (Thrift Monitoring and Logging: Performance Analysis and Troubleshooting)
▮▮▮▮▮▮▮ 8.4 Thrift版本管理与兼容性 (Thrift Version Management and Compatibility)
▮▮▮▮▮▮▮ 8.5 Thrift安全：认证与授权 (Thrift Security: Authentication and Authorization)
▮▮▮▮ 9. chapter 9： Folly高级应用与技巧 (Advanced Folly Applications and Techniques)
▮▮▮▮▮▮▮ 9.1 配置管理：使用Folly Options与Flags (Configuration Management: Using Folly Options and Flags)
▮▮▮▮▮▮▮ 9.2 日志系统：Folly Logging详解 (Logging System: Folly Logging Deep Dive)
▮▮▮▮▮▮▮ 9.3 性能分析与调优：使用Folly Benchmark与Profiling工具 (Performance Analysis and Tuning: Using Folly Benchmark and Profiling Tools)
▮▮▮▮▮▮▮ 9.4 Folly与第三方库集成 (Folly Integration with Third-Party Libraries)
▮▮▮▮▮▮▮ 9.5 Folly在大型项目中的应用案例分析 (Case Study: Folly in Large-Scale Projects)
▮▮▮▮ 10. chapter 10： 实战案例：构建高可用分布式系统 (Practical Case Study: Building a Highly Available Distributed System)
▮▮▮▮▮▮▮ 10.1 案例背景与需求分析 (Case Background and Requirement Analysis)
▮▮▮▮▮▮▮ 10.2 系统架构设计：基于Folly与Thrift (System Architecture Design: Based on Folly and Thrift)
▮▮▮▮▮▮▮ 10.3 核心模块开发：Thrift服务定义与实现 (Core Module Development: Thrift Service Definition and Implementation)
▮▮▮▮▮▮▮ 10.4 客户端集成与测试 (Client Integration and Testing)
▮▮▮▮▮▮▮ 10.5 部署与运维考量 (Deployment and Operation Considerations)
▮▮▮▮ 11. chapter 11： API参考与速查 (API Reference and Quick Lookup)
▮▮▮▮▮▮▮ 11.1 Folly常用API速查 (Folly Common API Quick Lookup)
▮▮▮▮▮▮▮▮▮▮▮ 11.1.1 String与StringPiece API (String and StringPiece API)
▮▮▮▮▮▮▮▮▮▮▮ 11.1.2 Futures与Promises API (Futures and Promises API)
▮▮▮▮▮▮▮▮▮▮▮ 11.1.3 Executors API (Executors API)
▮▮▮▮▮▮▮ 11.2 Thrift IDL语法速查 (Thrift IDL Syntax Quick Lookup)
▮▮▮▮▮▮▮ 11.3 Thrift C++ API速查 (Thrift C++ API Quick Lookup)
▮▮▮▮ 12. chapter 12： 未来展望：Folly与Thrift的演进 (Future Outlook: Evolution of Folly and Thrift)
▮▮▮▮▮▮▮ 12.1 C++标准发展趋势对Folly的影响 (Impact of C++ Standard Development Trends on Folly)
▮▮▮▮▮▮▮ 12.2 Thrift在云原生时代的机遇与挑战 (Opportunities and Challenges of Thrift in the Cloud-Native Era)
▮▮▮▮▮▮▮ 12.3 Folly与Thrift社区动态与发展方向 (Folly and Thrift Community Dynamics and Development Directions)
▮▮▮▮▮▮▮ A. 常用工具与资源 (Common Tools and Resources)
▮▮▮▮▮▮▮ B. 术语表 (Glossary)
▮▮▮▮▮▮▮ C. 参考文献 (References)
1. chapter 1： 启程：Folly与Thrift的世界 (Getting Started: The World of Folly and Thrift)
1.1 Folly与Thrift：现代C++基础设施的基石 (Folly and Thrift: Cornerstones of Modern C++ Infrastructure)
在现代软件开发的浩瀚星空中，C++ 依然是构建高性能、高效率系统的基石。尤其是在互联网、大数据、云计算等领域，C++ 以其卓越的性能和灵活性，成为了众多大型基础设施的首选语言。而在现代 C++ 生态系统中，Folly 和 Thrift 这两个由 Facebook 开源的库，无疑占据着举足轻重的地位。它们如同现代 C++ 基础设施的 “双子星”，为开发者提供了构建复杂、可扩展、高性能应用的强大工具。
Folly (Facebook Open-source Library)，正如其名，是一个由 Facebook 开源的、高度模块化的 C++ 库集合。它并非一个单一的框架，而是一系列精心设计的组件，涵盖了从基础数据结构、并发编程、网络通信到时间处理等多个方面。Folly 的目标是提供一套高效、可靠、易用的 C++ 基础设施库，以应对现代互联网应用开发中的各种挑战。它吸收了 Boost 等优秀库的精华，并在此基础上进行了大量的创新和优化，例如其强大的异步编程模型 Futures/Promises、高效的字符串处理 StringPiece、以及优化的容器 FBVector 和 F14Map 等。Folly 不仅是 Facebook 内部众多核心系统的基石，也受到了业界的广泛关注和应用。
Thrift (Apache Thrift)，则是一个强大的跨语言服务开发框架。它允许开发者使用简洁的接口定义语言 IDL (Interface Definition Language) 来定义数据类型和服务接口，然后通过 Thrift 编译器生成各种目标语言（如 C++、Java、Python、Go 等）的代码。Thrift 的核心价值在于其卓越的跨语言通信能力。借助 Thrift，你可以轻松构建由多种编程语言组件构成的分布式系统，实现不同语言服务之间的无缝互操作。Thrift 支持多种协议（如 Binary、Compact、JSON）和传输层（如 TCP、HTTP），可以根据不同的应用场景选择最优的组合，从而在性能、效率和灵活性之间取得平衡。
Folly 和 Thrift 虽然是两个独立的库，但它们在现代 C++ 基础设施中常常协同工作，相得益彰。Folly 提供了构建高性能 C++ 应用所需的各种基础组件，而 Thrift 则解决了跨语言服务通信的难题。许多大型互联网公司，包括 Facebook 在内，都广泛使用 Folly 和 Thrift 来构建其核心基础设施，例如在线服务、分布式存储、消息队列等。
学习和掌握 Folly 与 Thrift，对于希望深入现代 C++ 开发，尤其是从事高性能后端、分布式系统、云计算等领域的工程师来说，至关重要。它们不仅能帮助你构建更高效、更可靠的应用，更能让你站在技术的最前沿，理解和掌握现代 C++ 基础设施的核心技术。
1.2 为什么选择Folly？Folly的设计哲学与优势 (Why Folly? Folly's Design Philosophy and Advantages)
在众多优秀的 C++ 库中，为什么我们要特别关注和选择 Folly 呢？这并非偶然，而是由 Folly 独特的设计哲学和一系列显著的优势所决定的。理解 Folly 的设计理念和优势，能帮助我们更好地认识其价值，并在合适的场景下充分利用 Folly 的强大功能。
Folly 的设计哲学 可以概括为以下几个核心原则：
① 性能至上 (Performance First)：Folly 从设计之初就将性能放在首位。它针对现代硬件架构和应用场景进行了大量的优化，力求在各个方面都达到极致的性能。例如，Folly 的字符串处理、容器、并发原语等组件，都经过了精心的设计和优化，以减少不必要的开销，提升运行效率。
② 现代 C++ (Modern C++)：Folly 紧跟 C++ 标准的发展步伐，积极拥抱最新的 C++ 特性。它充分利用 C++11、C++14、C++17 乃至 C++20 的新特性，例如 move semantics (移动语义)、lambda expressions (lambda 表达式)、constexpr (常量表达式)、coroutines (协程) 等，来提升代码的效率、可读性和可维护性。使用 Folly，意味着你站在了现代 C++ 开发的前沿。
③ 务实与高效 (Pragmatic and Efficient)：Folly 并非一个学院派的库，而是源于 Facebook 实际的工程实践。它的设计和实现都非常务实，注重解决实际问题，提升开发效率。Folly 提供了大量经过生产环境验证的组件，可以直接应用于实际项目中，减少重复造轮子的工作，提高开发效率。
④ 模块化与可扩展 (Modular and Extensible)：Folly 采用高度模块化的设计，各个组件之间相互独立，可以根据需要选择性地使用。这种模块化设计不仅降低了学习成本，也方便了库的维护和扩展。同时，Folly 也提供了良好的扩展性，允许开发者根据自身需求定制和扩展 Folly 的功能。
Folly 的主要优势 可以总结为以下几点：
① 丰富而强大的组件库：Folly 提供了大量的组件，涵盖了字符串处理、容器、并发编程、异步编程、网络编程、时间处理、配置管理、日志系统、性能分析等多个方面。几乎你能想到的现代 C++ 应用开发中常用的基础设施，Folly 都有相应的组件提供支持。
② 卓越的性能：正如其设计哲学所强调的，性能是 Folly 的核心优势之一。Folly 的许多组件在性能上都超越了标准库或其他常见的 C++ 库。例如，FBString 和 SmallString 在某些场景下比 std::string 更高效，FBVector 和 F14Map 在特定场景下比 std::vector 和 std::unordered_map 性能更优。
③ 强大的异步编程支持：Folly 提供了强大的异步编程模型 Futures/Promises 和 Executors 框架。Futures/Promises 可以帮助开发者以更简洁、更优雅的方式处理异步操作，避免回调地狱，提高代码的可读性和可维护性。Executors 框架则提供了灵活的任务调度和并行执行能力，可以充分利用多核处理器的性能。
④ 高效的字符串处理：字符串处理是 C++ 应用开发中非常常见的任务。Folly 提供了 StringPiece、FBString、SmallString 等一系列高效的字符串处理工具。StringPiece 可以避免不必要的字符串拷贝，提高字符串处理的效率。FBString 和 SmallString 则针对不同的场景进行了优化，提供了比 std::string 更优的性能。
⑤ 优化的容器：Folly 提供了 FBVector、F14Map、F14Set 等一系列优化的容器。这些容器在内存占用、性能等方面都进行了精心的优化，特别是在高并发、大数据量的场景下，能展现出比标准库容器更优的性能。
⑥ 活跃的社区和持续的维护：Folly 是一个由 Facebook 开源的库，拥有活跃的社区和持续的维护。这意味着你可以获得及时的技术支持，并能享受到库的不断更新和改进。Facebook 也在其内部大量使用 Folly，这保证了 Folly 的质量和稳定性。
综上所述，选择 Folly，意味着你选择了一个性能卓越、功能丰富、紧跟现代 C++ 发展趋势的 C++ 基础设施库。它能帮助你构建更高效、更可靠、更易于维护的 C++ 应用，并在现代 C++ 开发的道路上助你一臂之力。
1.3 为什么选择Thrift？Thrift的跨语言通信魅力 (Why Thrift? The Cross-Language Communication Charm of Thrift)
在微服务架构盛行的今天，跨语言通信成为了构建复杂分布式系统不可或缺的关键技术。Thrift，作为一款成熟的跨语言服务开发框架，以其独特的魅力，成为了众多开发者构建跨语言应用的理想选择。那么，为什么我们要选择 Thrift 呢？Thrift 的魅力又在哪里呢？
Thrift 的核心价值 在于其卓越的 跨语言通信能力 (Cross-Language Communication Capability)。它允许你使用一种中立的接口定义语言 IDL (Interface Definition Language) 来描述你的数据结构和服务接口，然后通过 Thrift 编译器，将这份 IDL 文件编译成多种目标语言的代码。这些代码包含了数据序列化/反序列化、客户端和服务端框架等，使得不同语言编写的服务可以无缝地进行通信。
选择 Thrift 的理由 可以从以下几个方面来阐述：
① 强大的跨语言能力：这是 Thrift 最核心的优势。Thrift 支持众多主流编程语言，包括 C++、Java、Python、Go、PHP、Ruby、JavaScript、C# 等。这意味着你可以使用不同的语言来构建系统的不同组件，然后通过 Thrift 将它们连接起来。例如，你可以用 C++ 构建高性能的后端服务，用 Python 构建灵活的数据分析服务，用 Java 构建稳定的企业级应用，然后用 Thrift 将它们整合为一个统一的系统。
② 简洁的接口定义语言 (IDL)：Thrift 使用 IDL 来定义数据类型和服务接口。IDL 语法简洁明了，易于学习和使用。通过 IDL，你可以清晰地描述服务的数据结构、方法签名、异常类型等，而无需关心底层通信细节。IDL 就像一份契约，定义了服务提供者和消费者之间的交互规范，保证了跨语言通信的正确性和一致性。
③ 高效的代码生成：Thrift 编译器可以根据 IDL 文件生成各种目标语言的代码。生成的代码包含了数据序列化/反序列化的逻辑、客户端和服务端框架代码，开发者只需要关注业务逻辑的实现，而无需手动编写繁琐的通信代码。Thrift 代码生成器经过了高度优化，生成的代码效率高、性能好。
④ 多种协议和传输层选择：Thrift 支持多种协议和传输层，可以根据不同的应用场景选择最优的组合。
▮▮▮▮⚝ 协议 (Protocols)：Thrift 支持 Binary Protocol (二进制协议)、Compact Protocol (压缩协议)、JSON Protocol (JSON协议) 等多种协议。Binary Protocol 性能最高，但可读性较差；Compact Protocol 在性能和压缩率之间取得了平衡；JSON Protocol 可读性好，但性能相对较低。你可以根据性能、带宽、可读性等因素选择合适的协议。
▮▮▮▮⚝ 传输层 (Transports)：Thrift 支持 TCP Socket、HTTP、Memory Buffer 等多种传输层。TCP Socket 是最常用的传输层，适用于高性能、低延迟的场景；HTTP 适用于需要穿越防火墙或与 Web 应用集成的场景；Memory Buffer 适用于进程内通信的场景。
⑤ 成熟稳定，应用广泛：Thrift 诞生于 Facebook，并在 Facebook 内部得到了广泛的应用和验证。随后，Thrift 开源并加入了 Apache 基金会，成为了 Apache 顶级项目。许多大型互联网公司，如 Facebook、Twitter、LinkedIn、Netflix、Uber 等，都在其核心系统中使用了 Thrift。Thrift 的成熟度和稳定性得到了业界的广泛认可。
⑥ 良好的扩展性和可维护性：Thrift 的 IDL 定义和服务代码分离的设计，使得系统具有良好的扩展性和可维护性。当服务接口发生变化时，只需要修改 IDL 文件，重新编译生成代码即可，而无需修改业务逻辑代码。这种设计降低了系统的维护成本，提高了开发效率。
Thrift 的魅力 正是来自于其 跨语言通信的魔力。它打破了语言的壁垒，使得不同语言编写的服务可以像同语言服务一样无缝地协同工作。借助 Thrift，你可以构建更加灵活、更加开放、更加强大的分布式系统，充分利用各种编程语言的优势，应对日益复杂的业务挑战。
1.4 开发环境搭建：快速开始Folly与Thrift之旅 (Development Environment Setup: Quick Start to Folly and Thrift Journey)
工欲善其事，必先利其器。在正式开始 Folly 与 Thrift 的学习和实践之前，搭建好开发环境是至关重要的第一步。本节将引导你快速搭建 Folly 和 Thrift 的开发环境，并编写简单的 "Hello Folly" 和 "Hello Thrift" 程序，让你迈出 Folly 与 Thrift 之旅的第一步。
本节假设你使用的操作系统是 Linux 或 macOS，并且已经安装了以下基础工具：
⚝ C++ 编译器：例如 GCC 或 Clang (推荐 Clang++)。
⚝ CMake：用于构建 Folly 和 Thrift。
⚝ Python：Thrift 编译器是用 Python 编写的。
⚝ Git：用于下载 Folly 和 Thrift 源代码。
⚝ 其他依赖库：例如 Boost、OpenSSL、zlib、libevent 等 (具体依赖库会在后续步骤中说明)。
1.4.1 Folly编译与安装 (Folly Compilation and Installation)
Folly 的编译和安装相对来说比较复杂，因为它依赖于较多的第三方库。但不用担心，我们会一步一步地进行。
① 克隆 Folly 仓库
首先，使用 Git 克隆 Folly 的 GitHub 仓库：
1
git clone https://github.com/facebook/folly.git
2
cd folly
② 安装依赖库
Folly 依赖于一系列的第三方库，你需要根据你的操作系统和包管理器安装这些依赖库。以下是一些常见的依赖库及其安装命令示例 (以 Ubuntu 为例，其他 Linux 发行版或 macOS 可能会有所不同，请根据实际情况调整)：
1
# Ubuntu/Debian
2
sudo apt-get update
3
sudo apt-get install -y autoconf automake build-essential cmake libboost-all-dev libdouble-conversion-dev libevent-dev libgflags-dev libglog-dev liblz4-dev libnuma-dev libssl-dev libtool libunwind-dev libzstd-dev pkg-config snappy zlib1g-dev
注意：具体的依赖库版本和安装方式可能会因 Folly 版本和操作系统而异，请参考 Folly 仓库的官方文档 https://github.com/facebook/folly 获取最准确的依赖信息和安装指南。
③ 使用 CMake 构建和安装 Folly
在 Folly 仓库根目录下，创建并进入 build 目录：
1
mkdir build
2
cd build
然后，使用 CMake 配置构建：
1
cmake ..
如果一切顺利，CMake 会完成配置，并生成 Makefile 文件。接下来，编译 Folly：
1
make -j$(nproc) # 使用多核并行编译，加快编译速度
编译完成后，安装 Folly 到系统目录 (通常是 /usr/local):
1
sudo make install
2
sudo ldconfig # 更新动态链接库缓存
安装完成后，Folly 库文件和头文件会被安装到系统目录，你就可以在你的 C++ 项目中使用 Folly 了。
④ 验证 Folly 安装
为了验证 Folly 是否安装成功，可以编写一个简单的 C++ 程序，例如 hello_folly.cpp：
1
#include <folly/Format.h>
2
#include <iostream>
3
4
int main() {
5
std::cout << folly::format("Hello, {}!", "Folly") << std::endl;
6
return 0;
7
}
然后，使用 g++ 或 clang++ 编译并运行这个程序：
1
g++ hello_folly.cpp -o hello_folly -lfolly
2
./hello_folly
如果程序成功输出 Hello, Folly!，则说明 Folly 已经成功安装并可以使用了。
1.4.2 Thrift编译器安装与配置 (Thrift Compiler Installation and Configuration)
Thrift 编译器的安装相对简单，通常可以通过包管理器或者从源代码编译安装。
① 使用包管理器安装 (推荐)
大多数 Linux 发行版和 macOS 都提供了 Thrift 编译器的软件包，你可以使用包管理器直接安装。
⚝ Ubuntu/Debian：
1
sudo apt-get update
2
sudo apt-get install thrift-compiler
⚝ CentOS/Fedora：
1
sudo yum install thrift
2
# 或
3
sudo dnf install thrift
⚝ macOS (Homebrew)：
1
brew update
2
brew install thrift
使用包管理器安装 Thrift 编译器是最简单快捷的方式，推荐使用这种方法。
② 从源代码编译安装
如果你的操作系统没有提供 Thrift 编译器的软件包，或者你需要安装特定版本的 Thrift 编译器，可以从源代码编译安装。
首先，克隆 Thrift 仓库：
1
git clone https://github.com/apache/thrift.git
2
cd thrift
然后，按照 Thrift 仓库的官方文档 https://thrift.apache.org/docs/BuildingFromSource 的指引，安装 Thrift 编译器的依赖库，并使用 autoconf 和 make 构建和安装 Thrift 编译器。
③ 验证 Thrift 编译器安装
安装完成后，可以通过以下命令验证 Thrift 编译器是否安装成功：
1
thrift --version
如果命令成功输出 Thrift 编译器的版本信息，则说明 Thrift 编译器已经安装成功。
④ 配置 Thrift 编译器 (可选)
Thrift 编译器本身不需要额外的配置，但为了方便使用，你可以将 Thrift 编译器的可执行文件路径添加到系统的 PATH 环境变量中。这样你就可以在任何目录下直接运行 thrift 命令，而无需指定完整的路径。
例如，如果 Thrift 编译器的可执行文件安装在 /usr/local/bin/thrift，你可以将 /usr/local/bin 添加到 PATH 环境变量中。具体方法取决于你使用的 shell (例如 Bash、Zsh 等)，可以参考操作系统的文档进行配置。
1.4.3 第一个Folly程序：Hello Folly (First Folly Program: Hello Folly)
在 1.4.1 节中，我们已经编写并运行了一个简单的 "Hello Folly" 程序来验证 Folly 的安装。这里我们再回顾一下这个程序，并稍作解释。
创建文件 hello_folly.cpp，内容如下：
1
#include <folly/Format.h>
2
#include <iostream>
3
4
int main() {
5
std::cout << folly::format("Hello, {}!", "Folly") << std::endl;
6
return 0;
7
}
代码解释：
⚝ #include <folly/Format.h>： 引入 Folly 的 Format.h 头文件，该头文件提供了 folly::format 函数，用于格式化字符串输出。
⚝ #include <iostream>： 引入标准库的 iostream 头文件，用于标准输入输出。
⚝ folly::format("Hello, {}!", "Folly")： 使用 folly::format 函数创建一个格式化字符串。"{}" 是占位符，会被后面的参数 "Folly" 替换。
⚝ std::cout << ... << std::endl;： 使用标准输出流 std::cout 将格式化后的字符串输出到控制台，并换行。
编译和运行程序：
1
g++ hello_folly.cpp -o hello_folly -lfolly
2
./hello_folly
运行结果：
1
Hello, Folly!
这个简单的程序演示了如何使用 Folly 的 folly::format 函数进行字符串格式化输出。folly::format 类似于 std::printf 或 std::stringstream，但更加安全和易用。在后续的章节中，我们会深入学习 Folly 的更多组件和功能。
1.4.4 第一个Thrift程序：Hello Thrift (First Thrift Program: Hello Thrift)
接下来，我们编写一个简单的 "Hello Thrift" 程序，演示如何使用 Thrift 构建一个简单的客户端-服务端应用。
① 定义 Thrift IDL 文件
创建文件 hello.thrift，内容如下：
1
namespace cpp hello
2
3
service HelloService {
4
string hello_string(1: string name);
5
}
IDL 文件解释：
⚝ namespace cpp hello： 定义 C++ 命名空间为 hello，生成的 C++ 代码会放在 hello 命名空间下。
⚝ service HelloService： 定义一个名为 HelloService 的服务。
⚝ string hello_string(1: string name)： 在 HelloService 服务中定义一个名为 hello_string 的方法。
▮▮▮▮⚝ string： 方法的返回值类型为字符串。
▮▮▮▮⚝ hello_string： 方法名。
▮▮▮▮⚝ (1: string name)： 方法的参数列表。1: 表示参数的字段 ID，string 表示参数类型为字符串，name 表示参数名。
② 生成 C++ 代码
使用 Thrift 编译器编译 hello.thrift 文件，生成 C++ 代码：
1
thrift --gen cpp hello.thrift
执行命令后，会在当前目录下生成一个名为 gen-cpp 的目录，里面包含了生成的 C++ 代码文件，包括：
⚝ HelloService.h 和 HelloService.cpp： 定义了 HelloService 接口的 C++ 代码。
⚝ hello_types.h 和 hello_types.cpp： 定义了 IDL 文件中定义的数据类型的 C++ 代码 (本例中没有自定义数据类型)。
⚝ hello_constants.h 和 hello_constants.cpp： 定义了 IDL 文件中定义的常量的 C++ 代码 (本例中没有定义常量)。
③ 实现 Thrift 服务端
创建文件 HelloServer.cpp，内容如下：
1
#include "gen-cpp/HelloService.h"
2
#include <thrift/server/TSimpleServer.h>
3
#include <thrift/protocol/TBinaryProtocol.h>
4
#include <thrift/transport/TServerSocket.h>
5
#include <thrift/transport/TBufferTransports.h>
6
7
#include <iostream>
8
9
using namespace apache::thrift;
10
using namespace apache::thrift::server;
11
using namespace apache::thrift::protocol;
12
using namespace apache::thrift::transport;
13
using namespace hello; // 使用 IDL 中定义的命名空间
14
15
class HelloServiceHandler : virtual public HelloServiceIf {
16
public:
17
HelloServiceHandler() {}
18
19
std::string hello_string(const std::string& name) override {
20
std::cout << "收到客户端请求，name: " << name << std::endl;
21
return "Hello, " + name + "!";
22
}
23
};
24
25
int main() {
26
int port = 9090;
27
std::shared_ptr<HelloServiceHandler> handler(new HelloServiceHandler());
28
std::shared_ptr<TProcessor> processor(new HelloServiceProcessor(handler));
29
std::shared_ptr<TServerTransport> serverTransport(new TServerSocket(port));
30
std::shared_ptr<TTransportFactory> transportFactory(new TBufferedTransportFactory());
31
std::shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());
32
33
TSimpleServer server(processor, serverTransport, transportFactory, protocolFactory);
34
std::cout << "Thrift 服务端启动，监听端口: " << port << std::endl;
35
server.serve();
36
return 0;
37
}
服务端代码解释：
⚝ #include "gen-cpp/HelloService.h"： 引入生成的 HelloService.h 头文件，包含了 HelloServiceIf 和 HelloServiceProcessor 的定义。
⚝ 引入 Thrift 服务端和传输协议相关的头文件。
⚝ using namespace hello;： 使用 IDL 中定义的 hello 命名空间。
⚝ class HelloServiceHandler : virtual public HelloServiceIf： 定义服务端 Handler 类 HelloServiceHandler，继承自生成的 HelloServiceIf 接口。
⚝ std::string hello_string(const std::string& name) override： 实现 HelloServiceIf 接口中定义的 hello_string 方法。该方法接收客户端传递的 name 参数，并返回 "Hello, " + name + "!" 字符串。
⚝ TSimpleServer server(...)： 创建一个简单的 Thrift 服务端 TSimpleServer。
▮▮▮▮⚝ processor： 服务处理器，负责将请求分发到 Handler 处理。
▮▮▮▮⚝ serverTransport： 服务端传输层，使用 TServerSocket 监听指定端口。
▮▮▮▮⚝ transportFactory： 传输工厂，使用 TBufferedTransportFactory 创建缓冲传输。
▮▮▮▮⚝ protocolFactory： 协议工厂，使用 TBinaryProtocolFactory 创建二进制协议。
⚝ server.serve()： 启动 Thrift 服务端，开始监听和处理客户端请求。
④ 实现 Thrift 客户端
创建文件 HelloClient.cpp，内容如下：
1
#include "gen-cpp/HelloService.h"
2
#include <thrift/protocol/TBinaryProtocol.h>
3
#include <thrift/transport/TSocket.h>
4
#include <thrift/transport/TTransportUtils.h>
5
6
#include <iostream>
7
8
using namespace apache::thrift;
9
using namespace apache::thrift::protocol;
10
using namespace apache::thrift::transport;
11
using namespace hello; // 使用 IDL 中定义的命名空间
12
13
int main() {
14
std::shared_ptr<TTransport> socket(new TSocket("localhost", 9090));
15
std::shared_ptr<TTransport> transport(new TBufferedTransport(socket));
16
std::shared_ptr<TProtocol> protocol(new TBinaryProtocol(transport));
17
HelloServiceClient client(protocol);
18
19
try {
20
transport->open();
21
22
std::string name = "Thrift User";
23
std::string response = client.hello_string(name);
24
std::cout << "客户端收到响应: " << response << std::endl;
25
26
transport->close();
27
} catch (TException& tx) {
28
std::cout << "ERROR: " << tx.what() << std::endl;
29
}
30
return 0;
31
}
客户端代码解释：
⚝ #include "gen-cpp/HelloService.h"： 引入生成的 HelloService.h 头文件，包含了 HelloServiceClient 的定义。
⚝ 引入 Thrift 客户端和传输协议相关的头文件。
⚝ using namespace hello;： 使用 IDL 中定义的 hello 命名空间。
⚝ HelloServiceClient client(protocol)： 创建 HelloServiceClient 客户端对象，使用指定的协议。
⚝ transport->open()： 打开传输连接，连接到 Thrift 服务端。
⚝ std::string response = client.hello_string(name)： 调用客户端的 hello_string 方法，向服务端发送请求，并接收服务端返回的响应。
⚝ transport->close()： 关闭传输连接。
⑤ 编译和运行 Thrift 程序
首先，编译服务端程序 HelloServer.cpp：
1
g++ HelloServer.cpp gen-cpp/HelloService.cpp gen-cpp/hello_types.cpp -o HelloServer -lthrift
然后，编译客户端程序 HelloClient.cpp：
1
g++ HelloClient.cpp gen-cpp/HelloService.cpp gen-cpp/hello_types.cpp -o HelloClient -lthrift
注意：编译命令需要链接 Thrift 库 -lthrift，并且需要将生成的 gen-cpp 目录下的 .cpp 文件也加入编译。
编译完成后，先运行服务端程序 HelloServer：
1
./HelloServer
服务端程序会输出 "Thrift 服务端启动，监听端口: 9090"，并等待客户端连接。
然后，在另一个终端窗口运行客户端程序 HelloClient：
1
./HelloClient
客户端程序会输出 "客户端收到响应: Hello, Thrift User!"，服务端程序会输出 "收到客户端请求，name: Thrift User"。
至此，你已经成功运行了第一个 "Hello Thrift" 程序，体验了 Thrift 的基本使用流程。这个简单的例子演示了如何使用 Thrift IDL 定义服务接口，如何使用 Thrift 编译器生成代码，以及如何使用生成的代码构建 Thrift 客户端和服务端。在后续的章节中，我们将深入学习 Thrift 的更多高级特性和应用场景。
END_OF_CHAPTER
2. chapter 2： Folly核心组件：构建高效C++应用 (Folly Core Components: Building Efficient C++ Applications)
2.1 StringPiece：高效字符串处理的利器 (StringPiece: A Powerful Tool for Efficient String Handling)
StringPiece 是 Folly 库中一个非常重要的组件，它被设计用来高效地处理字符串，尤其是在需要避免不必要的内存拷贝的场景下。理解 StringPiece 的设计理念和使用方法，对于编写高性能的 C++ 应用至关重要。
2.1.1 StringPiece 的设计哲学 (Design Philosophy of StringPiece)
StringPiece 的核心设计哲学是零拷贝（Zero-copy）。传统的 std::string 在传递或处理子串时，常常会发生内存拷贝，这在处理大量字符串或性能敏感的应用中会成为瓶颈。StringPiece 通过持有指向字符数据的指针和长度，而不是拥有字符串的拷贝，从而避免了不必要的内存分配和拷贝操作。
① 非拥有性（Non-owning）： StringPiece 不拥有其指向的字符数据的所有权。这意味着 StringPiece 只是一个视图（view），它依赖于外部的字符数组或 std::string 对象。因此，使用 StringPiece 时必须确保其指向的数据在 StringPiece 的生命周期内有效。
② 高效性（Efficiency）： 由于避免了内存拷贝，StringPiece 在字符串的传递、比较、查找子串等操作上非常高效。这使得它成为构建高性能字符串处理库和应用的理想选择。
③ 兼容性（Compatibility）： StringPiece 提供了与 std::string 类似的接口，可以方便地与现有的 C++ 代码集成。例如，StringPiece 可以隐式转换为 std::string_view (C++17 标准引入的字符串视图)，也可以方便地转换为 std::string。
2.1.2 StringPiece 的基本用法 (Basic Usage of StringPiece)
StringPiece 的使用非常简单，主要涉及构造、赋值、以及常见的字符串操作。
① 构造 StringPiece (Constructing StringPiece):
StringPiece 可以从多种类型构造，包括 C 风格字符串、std::string、以及字符指针和长度。
1
#include <folly/StringPiece.h>
2
#include <iostream>
3
#include <string>
4
5
int main() {
6
const char* c_str = "hello folly";
7
std::string std_str = "hello string";
8
9
folly::StringPiece sp1(c_str); // 从 C 风格字符串构造
10
folly::StringPiece sp2(std_str); // 从 std::string 构造
11
folly::StringPiece sp3(c_str, 5); // 从字符指针和长度构造，只取前 5 个字符 "hello"
12
13
std::cout << "sp1: " << sp1.toString() << std::endl; // toString() 方法返回 std::string 拷贝
14
std::cout << "sp2: " << sp2.toString() << std::endl;
15
std::cout << "sp3: " << sp3.toString() << std::endl;
16
17
return 0;
18
}
② StringPiece 的常用操作 (Common Operations of StringPiece):
StringPiece 提供了丰富的成员函数，用于字符串的比较、查找、截取等操作，这些操作通常都非常高效，因为它们避免了内存拷贝。
1
#include <folly/StringPiece.h>
2
#include <iostream>
3
4
int main() {
5
folly::StringPiece sp("hello folly world");
6
7
// 长度
8
std::cout << "Length: " << sp.size() << std::endl; // 或 sp.length()
9
10
// 判断是否为空
11
std::cout << "Empty: " << sp.empty() << std::endl;
12
13
// 访问字符
14
std::cout << "First char: " << sp[0] << std::endl;
15
16
// 子串
17
folly::StringPiece sub_sp = sp.subpiece(6, 5); // 从索引 6 开始，取 5 个字符 "folly"
18
std::cout << "Subpiece: " << sub_sp.toString() << std::endl;
19
20
// 查找子串
21
size_t pos = sp.find("world");
22
if (pos != folly::StringPiece::npos) {
23
std::cout << "'world' found at position: " << pos << std::endl;
24
}
25
26
// 前缀和后缀检查
27
std::cout << "Starts with 'hello': " << sp.startsWith("hello") << std::endl;
28
std::cout << "Ends with 'world': " << sp.endsWith("world") << std::endl;
29
30
// 比较
31
folly::StringPiece sp2("hello folly world");
32
std::cout << "sp == sp2: " << (sp == sp2) << std::endl;
33
34
return 0;
35
}
③ StringPiece 与 std::string_view 的关系 (Relationship between StringPiece and std::string_view):
C++17 标准引入了 std::string_view，其设计目的与 StringPiece 非常相似，都是为了提供高效的字符串视图。实际上，StringPiece 的设计很大程度上影响了 std::string_view 的设计。在 C++17 及以上版本中，推荐优先使用 std::string_view，因为它已经是标准库的一部分。Folly 的 StringPiece 提供了与 std::string_view 的互操作性，可以方便地进行类型转换。
1
#include <folly/StringPiece.h>
2
#include <string_view>
3
#include <iostream>
4
5
int main() {
6
folly::StringPiece sp("hello folly");
7
std::string_view sv = sp; // 隐式转换为 std::string_view
8
9
folly::StringPiece sp2(sv); // 从 std::string_view 构造 StringPiece
10
11
std::cout << "StringPiece from string_view: " << sp2.toString() << std::endl;
12
std::cout << "string_view from StringPiece: " << std::string(sv) << std::endl;
13
14
return 0;
15
}
2.1.3 StringPiece 的高级应用场景 (Advanced Application Scenarios of StringPiece)
StringPiece 在很多高性能应用场景中都非常有用，尤其是在网络编程、文本处理、日志解析等方面。
① 网络编程中的应用 (Application in Network Programming):
在网络编程中，经常需要处理接收到的网络数据包，这些数据包通常是字符数组。使用 StringPiece 可以避免将网络数据拷贝到 std::string 中，直接在原始数据上进行解析和处理，提高网络应用的性能。
1
#include <folly/StringPiece.h>
2
#include <iostream>
3
4
void process_packet(const folly::StringPiece& packet_data) {
5
// 直接在 packet_data 上进行解析，无需拷贝
6
folly::StringPiece header = packet_data.subpiece(0, 10); // 假设前 10 字节是 header
7
folly::StringPiece payload = packet_data.subpiece(10); // 剩余部分是 payload
8
9
std::cout << "Header: " << header.toString() << std::endl;
10
std::cout << "Payload size: " << payload.size() << std::endl;
11
// ... further process header and payload ...
12
}
13
14
int main() {
15
char network_buffer[1024] = "headerdata payload data...";
16
process_packet(folly::StringPiece(network_buffer, sizeof(network_buffer)));
17
18
return 0;
19
}
② 日志解析中的应用 (Application in Log Parsing):
日志文件通常包含大量的文本数据，解析日志时需要频繁地提取字段。使用 StringPiece 可以高效地解析日志行，避免为每个日志字段创建 std::string 对象，从而提高日志处理速度。
1
#include <folly/StringPiece.h>
2
#include <iostream>
3
#include <vector>
4
5
std::vector<folly::StringPiece> split_log_line(const folly::StringPiece& log_line, char delimiter) {
6
std::vector<folly::StringPiece> fields;
7
size_t start = 0;
8
size_t end = 0;
9
while ((end = log_line.find(delimiter, start)) != folly::StringPiece::npos) {
10
fields.emplace_back(log_line.subpiece(start, end - start));
11
start = end + 1;
12
}
13
fields.emplace_back(log_line.subpiece(start)); // 处理最后一个字段
14
return fields;
15
}
16
17
int main() {
18
folly::StringPiece log_line = "timestamp|level|module|message";
19
std::vector<folly::StringPiece> log_fields = split_log_line(log_line, '|');
20
21
for (const auto& field : log_fields) {
22
std::cout << "Field: " << field.toString() << std::endl;
23
}
24
25
return 0;
26
}
③ 性能优化技巧 (Performance Optimization Tips):
⚝ 优先使用 StringPiece 传递字符串参数：在函数接口中，如果不需要修改字符串内容，并且希望避免拷贝，优先使用 StringPiece 或 std::string_view 作为参数类型。
⚝ 避免 StringPiece 生命周期问题：确保 StringPiece 指向的字符数据在其生命周期内有效。尤其是在多线程环境中，需要注意数据的所有权和生命周期管理。
⚝ 结合其他 Folly 组件使用：StringPiece 可以与 Folly 的其他组件，如 FBString、IOBuf 等高效地结合使用，构建更强大的字符串处理和网络应用。
2.1.4 StringPiece API 全面解析 (Comprehensive API Analysis of StringPiece)
StringPiece 提供了丰富的 API，涵盖了字符串操作的各个方面。以下是一些常用的 API 及其功能：
① 构造函数 (Constructors):
⚝ StringPiece(): 默认构造函数，创建一个空的 StringPiece。
⚝ StringPiece(const char* str): 从 C 风格字符串构造。
⚝ StringPiece(const char* str, size_t len): 从字符指针和长度构造。
⚝ StringPiece(const std::string& str): 从 std::string 构造。
⚝ StringPiece(std::string_view sv): 从 std::string_view 构造。
⚝ StringPiece(const StringPiece& other): 拷贝构造函数。
② 赋值运算符 (Assignment Operators):
⚝ StringPiece& operator=(const StringPiece& other): 拷贝赋值运算符。
③ 容量 (Capacity):
⚝ size_t size() const: 返回字符串长度。
⚝ size_t length() const: 返回字符串长度，与 size() 相同。
⚝ bool empty() const: 判断字符串是否为空。
④ 元素访问 (Element Access):
⚝ char operator[](size_t pos) const: 访问指定位置的字符，不进行边界检查。
⚝ char at(size_t pos) const: 访问指定位置的字符，进行边界检查，越界抛出异常。
⚝ char front() const: 返回第一个字符。
⚝ char back() const: 返回最后一个字符。
⚝ const char* data() const: 返回指向字符数据的指针。
⑤ 子串操作 (Substring Operations):
⚝ StringPiece subpiece(size_t pos = 0, size_t n = npos) const: 返回子串，从 pos 开始，长度为 n。
⚝ StringPiece substr(size_t pos = 0, size_t n = npos) const: 返回子串的 std::string 拷贝。
⑥ 查找操作 (Find Operations):
⚝ size_t find(StringPiece needle, size_t pos = 0) const: 从位置 pos 开始查找子串 needle，返回找到的第一个位置，未找到返回 npos。
⚝ size_t rfind(StringPiece needle, size_t pos = npos) const: 从位置 pos 开始逆向查找子串 needle，返回找到的第一个位置，未找到返回 npos。
⚝ size_t find_first_of(StringPiece needles, size_t pos = 0) const: 从位置 pos 开始查找第一个出现在 needles 中的字符，返回找到的位置，未找到返回 npos。
⚝ size_t find_first_not_of(StringPiece needles, size_t pos = 0) const: 从位置 pos 开始查找第一个不出现在 needles 中的字符，返回找到的位置，未找到返回 npos。
⚝ size_t find_last_of(StringPiece needles, size_t pos = npos) const: 从位置 pos 开始逆向查找最后一个出现在 needles 中的字符，返回找到的位置，未找到返回 npos。
⚝ size_t find_last_not_of(StringPiece needles, size_t pos = npos) const: 从位置 pos 开始逆向查找最后一个不出现在 needles 中的字符，返回找到的位置，未找到返回 npos。
⑦ 比较操作 (Comparison Operations):
⚝ int compare(StringPiece other) const: 比较两个 StringPiece 对象。
⚝ bool operator==(StringPiece other) const, operator!=(StringPiece other) const, operator<(StringPiece other) const, operator<=(StringPiece other) const, operator>(StringPiece other) const, operator>=(StringPiece other) const: 各种比较运算符。
⑧ 前缀和后缀检查 (Prefix and Suffix Checks):
⚝ bool startsWith(StringPiece prefix) const: 检查是否以指定前缀开始。
⚝ bool endsWith(StringPiece suffix) const: 检查是否以指定后缀结束。
⑨ 转换为 std::string (Conversion to std::string):
⚝ std::string toString() const: 返回 StringPiece 内容的 std::string 拷贝。
⚝ operator std::string_view() const: 隐式转换为 std::string_view (C++17 及以上)。
掌握 StringPiece 的 API 和使用技巧，可以帮助开发者编写更高效、更简洁的 C++ 代码，尤其是在处理字符串相关的任务时。
2.2 FBString与SmallString：定制化字符串类 (FBString and SmallString: Customized String Classes)
虽然 std::string 是 C++ 标准库提供的通用字符串类，但在高性能和特定应用场景下，可能存在一些不足。Folly 库提供了 FBString 和 SmallString 两种定制化的字符串类，旨在优化内存使用、提高性能，并提供更灵活的字符串操作。
2.2.1 FBString：面向性能优化的字符串 (FBString: Performance-Oriented String)
FBString 是 Folly 提供的高性能字符串类，它在设计上考虑了多种优化策略，以在常见的字符串操作中提供更好的性能，尤其是在高并发、低延迟的应用场景下。
① 定制化的内存分配器 (Customized Memory Allocator):
FBString 可以使用定制化的内存分配器，例如 Folly 的 Allocator 框架，或者 jemalloc 等高性能内存分配器。通过使用更高效的内存分配策略，FBString 可以减少内存碎片，提高内存分配和释放的速度，从而提升整体性能。
② 写时复制优化 (Copy-on-Write Optimization, CoW):
在某些情况下，FBString 可能会采用写时复制（Copy-on-Write, CoW）技术。CoW 允许在多个 FBString 对象之间共享底层的字符缓冲区，只有在需要修改字符串内容时才会进行拷贝。这可以减少不必要的内存拷贝，提高性能，尤其是在字符串频繁复制但修改较少的场景下。需要注意的是，现代 C++ 标准库的 std::string 通常不再使用 CoW，因为它在多线程环境下可能引入复杂性，并且在某些情况下性能提升并不明显。FBString 的 CoW 行为可能取决于具体的实现和配置。
③ 与 Folly 组件的集成 (Integration with Folly Components):
FBString 与 Folly 库的其他组件，如 StringPiece、IOBuf 等，可以无缝集成。例如，FBString 可以方便地转换为 StringPiece，进行高效的字符串视图操作；也可以与 IOBuf 结合，处理网络数据。
④ 使用场景 (Usage Scenarios):
FBString 适用于对性能有较高要求的场景，例如：
⚝ 高性能服务器：在处理大量请求时，字符串操作的效率至关重要。FBString 可以提供更快的字符串处理速度，降低延迟。
⚝ 内存敏感的应用：通过定制化的内存分配器和可能的 CoW 优化，FBString 可以更有效地利用内存，减少内存占用。
⚝ 与 Folly 库深度集成的项目：如果项目已经使用了 Folly 库，使用 FBString 可以更好地与 Folly 的其他组件协同工作。
⑤ 基本用法示例 (Basic Usage Example):
FBString 的 API 与 std::string 非常相似，可以很容易地替换 std::string。
1
#include <folly/FBString.h>
2
#include <iostream>
3
4
int main() {
5
folly::FBString fb_str = "hello fbstring"; // 构造 FBString
6
std::cout << fb_str.toStdString() << std::endl; // 转换为 std::string 输出
7
8
folly::FBString fb_str2 = fb_str; // 拷贝构造
9
fb_str2 += " world"; // 修改 fb_str2，可能触发 CoW (如果启用)
10
11
std::cout << "fb_str: " << fb_str.toStdString() << std::endl;
12
std::cout << "fb_str2: " << fb_str2.toStdString() << std::endl;
13
14
return 0;
15
}
2.2.2 SmallString：栈上优化的短字符串 (SmallString: Stack-Optimized Short String)
SmallString 是 Folly 提供的针对短字符串优化的字符串类。它利用小对象优化（Small Object Optimization, SSO）技术，将短字符串的内容直接存储在 SmallString 对象自身内部的栈空间中，而不是在堆上分配内存。这可以避免堆内存分配的开销，提高短字符串操作的性能。
① 小对象优化 (Small Object Optimization, SSO):
SmallString 内部维护一个固定大小的字符数组（例如，15 个字节）。当字符串的长度小于或等于这个固定大小时，字符串的内容直接存储在这个内部数组中，无需进行堆内存分配。只有当字符串长度超过这个阈值时，SmallString 才会退化为在堆上分配内存，类似于 std::string。
② 栈上存储的优势 (Advantages of Stack Storage):
⚝ 更快的内存分配和释放：栈内存的分配和释放速度非常快，几乎没有开销，远快于堆内存分配。
⚝ 更好的缓存局部性：栈内存通常在 CPU 缓存中，访问速度更快。
⚝ 减少堆碎片：避免了短字符串在堆上的分配，有助于减少内存碎片。
③ 适用场景 (Applicable Scenarios):
SmallString 特别适用于频繁处理短字符串的场景，例如：
⚝ HTTP 头部字段：HTTP 头部字段通常比较短，使用 SmallString 可以优化头部处理的性能。
⚝ JSON 或 XML 解析：在解析 JSON 或 XML 文档时，很多字符串字段也是短字符串，例如标签名、属性名等。
⚝ 符号表或字典：在编译器、解释器等应用中，符号表或字典中存储的字符串通常也比较短。
④ 阈值大小 (Threshold Size):
SmallString 的阈值大小（即内部字符数组的大小）是一个编译期常量，可以通过模板参数进行配置。默认值通常在 15 到 23 字节之间。开发者可以根据具体的应用场景，调整阈值大小以达到最佳性能。
⑤ 基本用法示例 (Basic Usage Example):
SmallString 的 API 也与 std::string 类似。
1
#include <folly/SmallString.h>
2
#include <iostream>
3
4
int main() {
5
folly::SmallString<15> small_str = "short string"; // 构造 SmallString，阈值为 15 字节
6
std::cout << small_str.toStdString() << std::endl; // 输出
7
8
folly::SmallString<15> small_str2 = small_str; // 拷贝构造
9
small_str2 += " too short"; // 字符串长度超过阈值，可能退化为堆分配
10
11
std::cout << "small_str: " << small_str.toStdString() << std::endl;
12
std::cout << "small_str2: " << small_str2.toStdString() << std::endl;
13
14
return 0;
15
}
2.2.3 FBString 与 SmallString 的选择 (Choosing between FBString and SmallString)
选择 FBString 还是 SmallString，需要根据具体的应用场景和性能需求进行权衡。
① 性能需求 (Performance Requirements):
⚝ 高吞吐量、低延迟：如果应用对性能要求非常高，例如高性能服务器，可以考虑使用 FBString，它提供了定制化的内存分配和可能的 CoW 优化。
⚝ 短字符串频繁操作：如果应用主要处理短字符串，并且操作非常频繁，例如 HTTP 头部解析，SmallString 可以通过栈上优化提供更好的性能。
② 内存使用 (Memory Usage):
⚝ 内存敏感：FBString 可以通过定制化的内存分配器更有效地利用内存。SmallString 对于短字符串可以避免堆内存分配，减少内存碎片。
⚝ 字符串长度分布：如果应用中字符串长度分布不均匀，既有长字符串也有短字符串，可以考虑组合使用 FBString 和 SmallString。例如，对于短字符串使用 SmallString，对于长字符串使用 FBString 或 std::string。
③ 代码复杂性 (Code Complexity):
⚝ 易用性：FBString 和 SmallString 的 API 都与 std::string 类似，易于使用和替换。
⚝ 配置和调优：FBString 可能需要配置定制化的内存分配器，SmallString 需要选择合适的阈值大小。这可能增加一些配置和调优的复杂性。
④ 总结 (Summary):
⚝ FBString: 面向性能优化的通用字符串类，适用于对性能有较高要求的场景，可以配置定制化的内存分配器。
⚝ SmallString: 针对短字符串优化的字符串类，通过栈上存储提高短字符串操作性能，适用于频繁处理短字符串的场景。
⚝ std::string: 标准库提供的通用字符串类，适用于大多数场景，易用性好，但性能可能不如 FBString 和 SmallString 在特定场景下。
在实际项目中，可以根据性能测试和 профилирование (Profiling) 结果，选择最合适的字符串类。在很多情况下，可以先使用 std::string 进行开发，然后在性能瓶颈出现时，再考虑替换为 FBString 或 SmallString。
2.3 Containers：FBVector与F14Map (Containers: FBVector and F14Map)
Folly 库不仅提供了优化的字符串类，还提供了一系列定制化的容器类，旨在提供比 std 标准容器更优的性能和功能。其中，FBVector 和 F14Map 是两个非常重要的容器，分别是对 std::vector 和 std::unordered_map 的改进和增强。
2.3.1 FBVector：优化的动态数组 (FBVector: Optimized Dynamic Array)
FBVector 是 Folly 提供的高性能动态数组，它是对 std::vector 的改进和增强，旨在提供更快的内存分配、更低的内存开销，以及更多的功能。
① 定制化的内存分配策略 (Customized Memory Allocation Strategy):
FBVector 可以使用定制化的内存分配策略，例如使用 Folly 的 Allocator 框架，或者 jemalloc 等高性能内存分配器。这可以提高内存分配和释放的速度，减少内存碎片，从而提升整体性能。
② 小对象优化 (Small Object Optimization, SSO) for Small Vectors:
类似于 SmallString，FBVector 也可能采用小对象优化（SSO）技术，对于小尺寸的 vector，将数据直接存储在 FBVector 对象自身内部的栈空间中，避免堆内存分配。这可以提高小 vector 的创建和访问速度。具体的 SSO 实现细节可能取决于 Folly 版本和配置。
③ 额外的功能 (Additional Features):
FBVector 可能会提供一些 std::vector 没有的功能，例如：
⚝ 更细粒度的内存控制：允许开发者更精细地控制内存分配和释放，例如预分配内存、释放多余内存等。
⚝ 性能 профилирование (Profiling) 支持：可能提供内置的性能 профилирование (Profiling) 功能，方便开发者分析 FBVector 的性能瓶颈。
⚝ 调试支持：可能提供更丰富的调试信息，例如内存泄漏检测、越界访问检测等。
④ 使用场景 (Usage Scenarios):
FBVector 适用于对性能有较高要求的动态数组场景，例如：
⚝ 高性能计算：在科学计算、数值计算等领域，动态数组是常用的数据结构。FBVector 可以提供更快的数组操作速度。
⚝ 游戏开发：在游戏开发中，动态数组用于存储游戏对象、场景数据等。FBVector 可以优化游戏性能。
⚝ 数据密集型应用：在处理大量数据的应用中，动态数组的性能至关重要。FBVector 可以提高数据处理效率。
⑤ 基本用法示例 (Basic Usage Example):
FBVector 的 API 与 std::vector 非常相似。
1
#include <folly/FBVector.h>
2
#include <iostream>
3
4
int main() {
5
folly::FBVector<int> fb_vec; // 构造 FBVector
6
for (int i = 0; i < 10; ++i) {
7
fb_vec.push_back(i); // 添加元素
8
}
9
10
for (int val : fb_vec) {
11
std::cout << val << " ";
12
}
13
std::cout << std::endl;
14
15
folly::FBVector<int> fb_vec2 = fb_vec; // 拷贝构造
16
17
return 0;
18
}
2.3.2 F14Map：高性能哈希表 (F14Map: High-Performance Hash Table)
F14Map 是 Folly 提供的高性能哈希表，它是对 std::unordered_map 的改进和增强，旨在提供更快的查找、插入、删除操作，以及更低的内存开销。F14 系列哈希表是 Folly 中非常重要的组件，包括 F14Map、F14Set、F14VectorMap 等，它们都采用了优化的哈希算法和数据结构。
① 优化的哈希算法 (Optimized Hash Algorithm):
F14Map 使用了优化的哈希算法，例如 Fast-14 哈希算法，这种算法在保证哈希冲突率较低的同时，计算速度非常快。更快的哈希算法可以提高哈希表的整体性能。
② 优化的数据结构 (Optimized Data Structure):
F14Map 采用了优化的哈希表数据结构，例如 开放寻址法（Open Addressing） 或 布谷鸟哈希（Cuckoo Hashing） 等。这些数据结构在某些场景下可以提供比传统的链地址法（Separate Chaining）更好的性能，尤其是在缓存友好性和内存局部性方面。具体的实现细节可能取决于 Folly 版本和配置。
③ 内存效率 (Memory Efficiency):
F14Map 在内存使用方面也进行了优化，例如减少哈希表元数据的开销，更有效地利用内存空间。这在存储大量数据时可以节省内存。
④ 使用场景 (Usage Scenarios):
F14Map 适用于对哈希表性能有较高要求的场景，例如：
⚝ 高性能服务器：在服务器端应用中，哈希表常用于存储会话信息、路由表等。F14Map 可以提高服务器的查找和处理速度。
⚝ 缓存系统：缓存系统需要快速的键值查找。F14Map 可以作为高性能缓存的底层数据结构。
⚝ 数据库索引：数据库索引可以使用哈希表来加速数据查找。F14Map 可以提高数据库的查询性能。
⚝ 编译器和解释器：符号表通常使用哈希表实现。F14Map 可以提高编译和解释的速度。
⑤ 基本用法示例 (Basic Usage Example):
F14Map 的 API 与 std::unordered_map 非常相似。
1
#include <folly/container/F14Map.h>
2
#include <iostream>
3
#include <string>
4
5
int main() {
6
folly::F14FastMap<std::string, int> f14_map; // 构造 F14Map
7
f14_map["apple"] = 1;
8
f14_map["banana"] = 2;
9
f14_map["orange"] = 3;
10
11
std::cout << "apple: " << f14_map["apple"] << std::endl;
12
std::cout << "banana: " << f14_map["banana"] << std::endl;
13
std::cout << "orange: " << f14_map["orange"] << std::endl;
14
15
for (const auto& pair : f14_map) {
16
std::cout << pair.first << ": " << pair.second << std::endl;
17
}
18
19
return 0;
20
}
2.3.3 FBVector 与 F14Map 的选择 (Choosing between FBVector/F14Map and std::vector/std::unordered_map)
选择 Folly 容器还是标准容器，需要根据具体的应用场景和性能需求进行权衡。
① 性能需求 (Performance Requirements):
⚝ 高吞吐量、低延迟：如果应用对性能要求非常高，例如高性能服务器、游戏开发等，可以考虑使用 FBVector 和 F14Map，它们在某些场景下可以提供比标准容器更好的性能。
⚝ 特定操作的性能瓶颈：如果应用在动态数组或哈希表操作上存在性能瓶颈，可以尝试使用 FBVector 或 F14Map 进行优化。
② 内存使用 (Memory Usage):
⚝ 内存敏感：FBVector 和 F14Map 在内存使用方面也可能更高效，尤其是在存储大量数据时。
⚝ 内存 профилирование (Profiling)：可以使用内存 профилирование (Profiling) 工具，比较 Folly 容器和标准容器的内存使用情况，选择更合适的容器。
③ 代码复杂性 (Code Complexity):
⚝ 易用性：FBVector 和 F14Map 的 API 都与标准容器类似，易于使用和替换。
⚝ 依赖性：使用 Folly 容器需要引入 Folly 库的依赖。需要权衡引入额外依赖的成本。
④ 总结 (Summary):
⚝ FBVector: 优化的动态数组，适用于对动态数组性能有较高要求的场景。
⚝ F14Map: 高性能哈希表，适用于对哈希表性能有较高要求的场景。
⚝ std::vector 和 std::unordered_map: 标准库提供的通用容器，适用于大多数场景，易用性好，但性能可能不如 Folly 容器在特定场景下。
在实际项目中，可以根据性能测试和 профилирование (Profiling) 结果，选择最合适的容器。在很多情况下，可以先使用标准容器进行开发，然后在性能瓶颈出现时，再考虑替换为 Folly 容器。Folly 还提供了其他有用的容器，例如 F14Set (高性能哈希集合)、ConcurrentHashMap (并发哈希表) 等，可以根据具体需求选择使用。
2.4 Option与Expected：优雅的错误处理 (Option and Expected: Elegant Error Handling)
错误处理是软件开发中至关重要的一部分。传统的 C++ 错误处理方式，例如返回值错误码、异常等，在某些情况下可能显得不够优雅或高效。Folly 库提供了 Option 和 Expected 两种类型，旨在提供更安全、更清晰、更高效的错误处理机制。
2.4.1 Option：处理可能缺失的值 (Option: Handling Potentially Missing Values)
Option 类型用于表示一个值可能存在，也可能不存在的情况。它类似于其他语言中的 Optional 或 Maybe 类型，可以避免使用空指针或特殊值来表示缺失，从而提高代码的安全性。
① 解决空指针问题 (Solving Null Pointer Problem):
在 C++ 中，空指针（nullptr）是常见的错误来源。使用 Option 可以显式地表示一个指针或值可能为空，迫使开发者在访问值之前进行检查，从而避免空指针解引用错误。
② 替代特殊返回值 (Replacing Special Return Values):
在传统的错误处理中，有时会使用特殊返回值（例如，函数返回 -1 表示错误）来表示操作失败。这种方式容易出错，且可读性较差。Option 可以更清晰地表示操作可能成功，也可能失败，并提供统一的接口来处理这两种情况。
③ Option 的状态 (States of Option):
Option 类型有两种状态：
⚝ Some(value): 表示值存在，并包含具体的值 value。
⚝ None: 表示值不存在。
④ 基本用法 (Basic Usage):
⚝ 创建 Option 对象 (Creating Option Objects):
1
#include <folly/Option.h>
2
#include <iostream>
3
4
int main() {
5
folly::Option<int> opt1 = folly::Some(10); // 值存在
6
folly::Option<int> opt2 = folly::None; // 值不存在
7
folly::Option<int> opt3 = 20; // 隐式转换为 Some(20)
8
9
std::cout << "opt1 is Some: " << opt1.has_value() << std::endl; // 检查是否有值
10
std::cout << "opt2 is Some: " << opt2.has_value() << std::endl;
11
std::cout << "opt3 is Some: " << opt3.has_value() << std::endl;
12
13
if (opt1.has_value()) {
14
std::cout << "opt1 value: " << opt1.value() << std::endl; // 访问值，需要先检查 has_value()
15
}
16
17
return 0;
18
}
⚝ 访问 Option 的值 (Accessing Option's Value):
⚝ has_value(): 检查 Option 是否包含值。
⚝ value(): 返回 Option 包含的值。如果 Option 为 None，调用 value() 会抛出异常。 因此，必须先使用 has_value() 检查。
⚝ value_or(default_value): 如果 Option 包含值，返回该值；否则返回 default_value。
⚝ value_or_throw(): 如果 Option 包含值，返回该值；否则抛出异常。可以自定义异常类型。
1
#include <folly/Option.h>
2
#include <iostream>
3
#include <stdexcept>
4
5
int main() {
6
folly::Option<int> opt = folly::None;
7
8
// 使用 value_or 提供默认值
9
int val1 = opt.value_or(0);
10
std::cout << "value_or(0): " << val1 << std::endl;
11
12
// 使用 value_or_throw 抛出异常
13
try {
14
int val2 = opt.value_or_throw<std::runtime_error>("Option is None");
15
} catch (const std::runtime_error& e) {
16
std::cerr << "Exception: " << e.what() << std::endl;
17
}
18
19
return 0;
20
}
⚝ Option 的链式操作 (Chaining Operations on Option):
Option 支持链式操作，可以使用 map()、flatMap() 等函数，对 Option 包含的值进行转换和处理。
1
#include <folly/Option.h>
2
#include <iostream>
3
4
folly::Option<int> safe_divide(int a, int b) {
5
if (b == 0) {
6
return folly::None; // 除数为 0，返回 None
7
} else {
8
return folly::Some(a / b); // 返回 Some(a / b)
9
}
10
}
11
12
int main() {
13
folly::Option<int> result1 = safe_divide(10, 2);
14
folly::Option<int> result2 = safe_divide(10, 0);
15
16
// 使用 map() 对 Option 的值进行转换
17
auto doubled_result1 = result1.map([](int val) { return val * 2; });
18
auto doubled_result2 = result2.map([](int val) { return val * 2; }); // 对 None Option 调用 map()，结果仍然是 None
19
20
if (doubled_result1.has_value()) {
21
std::cout << "doubled_result1: " << doubled_result1.value() << std::endl;
22
}
23
if (doubled_result2.has_value()) {
24
std::cout << "doubled_result2: " << doubled_result2.value() << std::endl; // 不会执行
25
}
26
27
return 0;
28
}
2.4.2 Expected：处理可能失败的操作 (Expected: Handling Potentially Failing Operations)
Expected 类型用于表示一个操作可能成功，也可能失败，并携带成功时的值或失败时的错误信息。它类似于其他语言中的 Result 类型，可以更清晰地表达操作的结果，并提供统一的接口来处理成功和失败两种情况。
① 替代异常 (Replacing Exceptions for Expected Failures):
在 C++ 中，异常是常用的错误处理机制。但异常在性能开销、控制流复杂性等方面存在一些问题。Expected 可以替代异常来处理预期内的失败情况，例如文件打开失败、网络请求超时等。对于非预期内的、程序逻辑错误，仍然可以使用异常。
② 清晰表达操作结果 (Clearly Expressing Operation Results):
Expected 可以明确地表示操作的结果是成功还是失败，并携带相应的信息。这比传统的返回值错误码更具表达力，也更易于理解和维护。
③ Expected 的状态 (States of Expected):
Expected<T, E> 类型有两种状态：
⚝ Value(value): 表示操作成功，并包含类型为 T 的成功值 value。
⚝ Error(error): 表示操作失败，并包含类型为 E 的错误信息 error。
④ 基本用法 (Basic Usage):
⚝ 创建 Expected 对象 (Creating Expected Objects):
1
#include <folly/Expected.h>
2
#include <iostream>
3
#include <string>
4
5
enum class FileError {
6
NotFound,
7
PermissionDenied,
8
ReadError
9
};
10
11
folly::Expected<std::string, FileError> read_file(const std::string& filename) {
12
// 模拟文件读取操作
13
if (filename == "valid_file.txt") {
14
return folly::Value("file content"); // 成功，返回 Value
15
} else if (filename == "not_found.txt") {
16
return folly::Error(FileError::NotFound); // 失败，返回 Error
17
} else {
18
return folly::Error(FileError::ReadError); // 失败，返回 Error
19
}
20
}
21
22
int main() {
23
auto result1 = read_file("valid_file.txt");
24
auto result2 = read_file("not_found.txt");
25
26
if (result1.has_value()) {
27
std::cout << "File content: " << result1.value() << std::endl; // 访问成功值
28
} else {
29
FileError error = result1.error(); // 访问错误信息
30
std::cerr << "Error reading file: ";
31
if (error == FileError::NotFound) {
32
std::cerr << "File not found" << std::endl;
33
} else if (error == FileError::ReadError) {
34
std::cerr << "Read error" << std::endl;
35
}
36
}
37
38
if (result2.has_value()) {
39
std::cout << "File content: " << result2.value() << std::endl; // 不会执行
40
} else {
41
FileError error = result2.error(); // 访问错误信息
42
std::cerr << "Error reading file: ";
43
if (error == FileError::NotFound) {
44
std::cerr << "File not found" << std::endl;
45
} else if (error == FileError::ReadError) {
46
std::cerr << "Read error" << std::endl;
47
}
48
}
49
50
return 0;
51
}
⚝ 访问 Expected 的结果 (Accessing Expected's Result):
⚝ has_value(): 检查 Expected 是否包含成功值。
⚝ value(): 返回 Expected 包含的成功值。如果 Expected 为 Error 状态，调用 value() 会抛出异常。 因此，必须先使用 has_value() 检查。
⚝ error(): 返回 Expected 包含的错误信息。如果 Expected 为 Value 状态，调用 error() 行为未定义。 因此，必须先使用 !has_value() 或 has_error() 检查。
⚝ value_or(default_value): 如果 Expected 包含成功值，返回该值；否则返回 default_value。
⚝ value_or_throw(): 如果 Expected 包含成功值，返回该值；否则抛出异常。可以自定义异常类型和错误信息。
⚝ Expected 的链式操作 (Chaining Operations on Expected):
Expected 也支持链式操作，可以使用 map()、flatMap()、andThen()、orElse() 等函数，对 Expected 的成功值或错误信息进行转换和处理。
1
#include <folly/Expected.h>
2
#include <iostream>
3
#include <string>
4
5
folly::Expected<int, std::string> string_to_int(const std::string& str) {
6
try {
7
return folly::Value(std::stoi(str)); // 成功，返回 Value
8
} catch (const std::invalid_argument& e) {
9
return folly::Error("Invalid argument: " + str); // 失败，返回 Error
10
} catch (const std::out_of_range& e) {
11
return folly::Error("Out of range: " + str); // 失败，返回 Error
12
}
13
}
14
15
int main() {
16
auto result1 = string_to_int("123");
17
auto result2 = string_to_int("abc");
18
19
// 使用 map() 对成功值进行转换
20
auto doubled_result1 = result1.map([](int val) { return val * 2; });
21
auto doubled_result2 = result2.map([](int val) { return val * 2; }); // 对 Error Expected 调用 map()，结果仍然是 Error
22
23
if (doubled_result1.has_value()) {
24
std::cout << "doubled_result1: " << doubled_result1.value() << std::endl;
25
} else {
26
std::cerr << "doubled_result1 error: " << doubled_result1.error() << std::endl; // 不会执行
27
}
28
29
if (doubled_result2.has_value()) {
30
std::cout << "doubled_result2: " << doubled_result2.value() << std::endl; // 不会执行
31
} else {
32
std::cerr << "doubled_result2 error: " << doubled_result2.error() << std::endl;
33
}
34
35
return 0;
36
}
2.4.3 Option 与 Expected 的选择与应用 (Choosing and Applying Option and Expected)
选择 Option 还是 Expected，取决于需要处理的错误类型和场景。
① Option 适用场景 (When to Use Option):
⚝ 表示值可能缺失：例如，函数可能返回一个值，也可能不返回任何值（例如，查找操作可能找不到结果）。
⚝ 避免空指针：当需要处理指针或引用可能为空的情况时，使用 Option 可以更安全。
⚝ 函数返回值可能为空：当函数在某些情况下可能不返回有效值时，使用 Option 可以更清晰地表达返回值类型。
② Expected 适用场景 (When to Use Expected):
⚝ 表示操作可能失败：例如，文件操作、网络请求、数据解析等可能失败的操作。
⚝ 需要携带错误信息：当操作失败时，需要返回详细的错误信息，例如错误类型、错误描述等。
⚝ 替代异常处理 (部分场景)：对于预期内的失败情况，可以使用 Expected 替代异常，提高性能和代码可读性。
③ 组合使用 Option 和 Expected (Combining Option and Expected):
Option 和 Expected 可以组合使用，处理更复杂的错误场景。例如，一个函数可能返回 Expected<Option<T>, E>，表示操作可能失败（Error(E)），也可能成功但没有值（Value(None)），也可能成功并返回一个值（Value(Some(T))）。
④ 总结 (Summary):
⚝ Option: 用于处理值可能缺失的情况，避免空指针，提高代码安全性。
⚝ Expected: 用于处理操作可能失败的情况，携带错误信息，替代部分异常处理场景，提高代码清晰度和性能。
⚝ 选择原则: 根据需要处理的错误类型和场景，选择 Option 或 Expected，或者组合使用。
通过合理使用 Option 和 Expected，可以编写更健壮、更易于维护的 C++ 代码，提高错误处理的效率和优雅性。
2.5 Futures与Promises：异步编程的基石 (Futures and Promises: Cornerstones of Asynchronous Programming)
在现代软件开发中，异步编程变得越来越重要，尤其是在网络编程、并发编程、GUI 编程等领域。异步编程可以提高程序的响应性、吞吐量、资源利用率。Folly 库提供了强大的 Futures 和 Promises 框架，用于简化和优化 C++ 的异步编程。
2.5.1 异步编程的需求与挑战 (Needs and Challenges of Asynchronous Programming)
传统的同步编程模式，程序按照顺序执行，一个操作完成后才能进行下一个操作。在某些场景下，这种模式会阻塞线程，导致程序响应缓慢、资源浪费。异步编程允许程序发起一个操作后立即返回，无需等待操作完成，当操作完成时，通过回调、事件通知等方式通知程序。
① 异步编程的优势 (Advantages of Asynchronous Programming):
⚝ 提高响应性 (Responsiveness): 在 GUI 应用中，异步编程可以避免长时间操作阻塞 UI 线程，保持 UI 的流畅响应。
⚝ 提高吞吐量 (Throughput): 在服务器端应用中，异步编程可以并发处理多个请求，提高服务器的吞吐量。
⚝ 提高资源利用率 (Resource Utilization): 异步编程可以更有效地利用 CPU 和 IO 资源，避免线程阻塞造成的资源浪费。
⚝ 简化并发编程 (Simplifying Concurrent Programming): 异步编程可以简化并发程序的编写，避免传统多线程编程中的锁竞争、死锁等问题。
② 异步编程的挑战 (Challenges of Asynchronous Programming):
⚝ 代码复杂性 (Code Complexity): 异步代码通常比同步代码更难编写和理解，容易陷入回调地狱（Callback Hell）。
⚝ 错误处理 (Error Handling): 异步操作的错误处理可能比较复杂，需要考虑错误传播、异常处理等问题。
⚝ 调试难度 (Debugging Difficulty): 异步程序的调试通常比同步程序更困难，因为执行流程不连续，难以跟踪。
⚝ 状态管理 (State Management): 异步操作可能涉及复杂的状态管理，需要保证状态的一致性和正确性。
2.5.2 Futures 和 Promises 的概念 (Concepts of Futures and Promises)
Futures 和 Promises 是一种用于异步编程的抽象，它们提供了一种结构化的方式来表示异步操作的结果，并简化了异步代码的编写和管理。
① Promise (承诺):
⚝ Promise 代表一个异步操作的承诺，它负责设置异步操作的结果（成功值或异常）。
⚝ Promise 通常由异步操作的发起者创建和持有。
⚝ Promise 提供了 setValue() 和 setException() 方法，用于设置异步操作的成功值或异常。
⚝ Promise 对象本身通常不直接传递给异步操作的消费者，而是与其关联的 Future 对象传递给消费者。
② Future (未来):
⚝ Future 代表一个异步操作的未来结果，它允许异步操作的消费者在操作完成时获取结果（成功值或异常）。
⚝ Future 通常由 Promise 对象创建，并传递给异步操作的消费者。
⚝ Future 提供了 get()、then()、map()、flatMap() 等方法，用于获取结果、注册回调、链式操作等。
⚝ Future 对象是只读的，消费者只能通过 Future 获取结果，而不能设置结果。
③ Futures 和 Promises 的关系 (Relationship between Futures and Promises):
⚝ Promise 是 Future 的生产者，Future 是 Promise 的消费者。
⚝ 一个 Promise 对象通常关联一个 Future 对象。
⚝ Promise 负责设置结果，Future 负责获取结果。
⚝ Futures 和 Promises 共同构成了一个异步操作的完整生命周期。
2.5.3 Folly Futures 和 Promises 的使用 (Usage of Folly Futures and Promises)
Folly 库提供了 folly::Promise 和 folly::Future 类，以及一系列辅助函数和工具，用于简化异步编程。
① 创建 Promise 和 Future (Creating Promise and Future):
1
#include <folly/Future.h>
2
#include <folly/Promise.h>
3
#include <iostream>
4
#include <thread>
5
6
int main() {
7
folly::Promise<int> promise; // 创建 Promise 对象
8
folly::Future<int> future = promise.getFuture(); // 获取与 Promise 关联的 Future 对象
9
10
// 在新线程中执行异步操作，并设置 Promise 的结果
11
std::thread t([promise = std::move(promise)]() mutable {
12
std::this_thread::sleep_for(std::chrono::seconds(2)); // 模拟耗时操作
13
promise.setValue(42); // 设置 Promise 的成功值
14
});
15
t.detach();
16
17
// 在主线程中等待 Future 的结果
18
try {
19
int result = future.get(); // 获取 Future 的结果，会阻塞直到结果可用
20
std::cout << "Future result: " << result << std::endl;
21
} catch (const std::exception& e) {
22
std::cerr << "Future exception: " << e.what() << std::endl;
23
}
24
25
return 0;
26
}
② 设置 Promise 的结果 (Setting Promise Result):
⚝ promise.setValue(value): 设置 Promise 的成功值。
⚝ promise.setException(std::exception_ptr): 设置 Promise 的异常。可以使用 std::make_exception_ptr() 创建异常指针。
⚝ promise.setException(std::exception): 设置 Promise 的异常，会自动转换为异常指针。
⚝ promise.setWith([&]() { return result; }): 使用 lambda 函数设置 Promise 的结果，lambda 函数的返回值将作为成功值，lambda 函数抛出的异常将作为异常。
③ 获取 Future 的结果 (Getting Future Result):
⚝ future.get(): 获取 Future 的结果，会阻塞当前线程直到结果可用。如果 Future 最终结果是异常，get() 会抛出该异常。
⚝ future.wait(): 等待 Future 完成，但不获取结果。
⚝ future.isReady(): 检查 Future 是否已完成（结果可用）。
④ Future 的回调 (Future Callbacks):
⚝ future.then([](int result) { /* 处理成功结果 */ }): 注册成功回调，当 Future 成功完成时调用。回调函数的参数是 Future 的成功值。
⚝ future.thenError([](const std::exception& e) { /* 处理异常 */ }): 注册异常回调，当 Future 异常完成时调用。回调函数的参数是 Future 的异常。
⚝ future.thenValue([](int result) { /* 处理成功结果 */ }): 注册成功值回调，与 then() 类似，但只处理成功情况。
⚝ future.thenErrorValue([](const std::exception& e) { /* 处理异常 */ }): 注册异常值回调，与 thenError() 类似，但只处理异常情况。
⚝ future.thenTry([](folly::Try<int>&& try_result) { /* 处理 Try 结果 */ }): 注册 Try 回调，处理 Future 的最终结果，无论是成功还是异常。回调函数的参数是 folly::Try<T> 对象，可以使用 try_result.value() 获取成功值，try_result.exception() 获取异常。
⑤ Future 的链式操作 (Chaining Operations on Future):
⚝ future.map([](int result) { return result * 2; }): 对 Future 的成功值进行转换，返回一个新的 Future，其结果是转换后的值。如果原始 Future 异常，新的 Future 也异常。
⚝ future.flatMap([](int result) { return another_future(result); }): 对 Future 的成功值进行异步转换，返回一个新的 Future，其结果是异步转换后的 Future 的结果。如果原始 Future 异常，新的 Future 也异常。
⚝ future.onSuccess([](int result) { /* 处理成功结果 */ }): 注册成功处理函数，与 thenValue() 类似，但不返回新的 Future，用于执行副作用操作。
⚝ future.onError([](const std::exception& e) { /* 处理异常 */ }): 注册异常处理函数，与 thenErrorValue() 类似，但不返回新的 Future，用于执行副作用操作。
⑥ Future 的组合 (Combining Futures):
⚝ folly::collect(futures): 将多个 Future 组合成一个新的 Future，当所有输入的 Future 都成功完成时，新的 Future 也成功完成，结果是一个包含所有输入 Future 结果的 std::vector。如果任何一个输入 Future 异常，新的 Future 也异常。
⚝ folly::collectAny(futures): 将多个 Future 组合成一个新的 Future，当任何一个输入的 Future 完成时，新的 Future 就完成，结果是第一个完成的 Future 的结果。
⚝ folly::makeFutureValue(value): 创建一个立即完成的 Future，结果是 value。
⚝ folly::makeFutureError(exception): 创建一个立即异常的 Future，异常是 exception。
2.5.4 Futures 和 Promises 的高级应用场景 (Advanced Application Scenarios of Futures and Promises)
Futures 和 Promises 在构建高性能、高并发的应用中发挥着重要作用。
① 异步网络编程 (Asynchronous Network Programming):
在网络编程中，可以使用 Futures 和 Promises 来处理异步 IO 操作，例如异步读写、异步连接等。结合 Folly 的 Asio 库，可以构建高性能的异步网络应用。
② 并发任务调度 (Concurrent Task Scheduling):
可以使用 Futures 和 Promises 结合 Folly 的 Executors 框架，实现复杂的并发任务调度，例如任务依赖、任务优先级、任务取消等。
③ GUI 编程 (GUI Programming):
在 GUI 编程中，可以使用 Futures 和 Promises 来处理后台任务，避免阻塞 UI 线程，保持 UI 的响应性。
④ 流式数据处理 (Streaming Data Processing):
可以使用 Futures 和 Promises 构建异步流式数据处理管道，例如异步数据读取、异步数据转换、异步数据写入等。
2.5.5 Futures 和 Promises 的最佳实践 (Best Practices for Futures and Promises)
⚝ 避免阻塞 get() 调用：尽量避免在主线程或关键路径上调用 future.get()，因为它会阻塞线程。优先使用回调、链式操作等异步方式处理 Future 的结果。
⚝ 合理使用线程池：在异步操作中，如果需要执行 CPU 密集型任务，应该使用线程池来避免创建过多的线程，提高资源利用率。
⚝ 注意异常处理：异步操作的异常处理非常重要，要确保所有可能的异常都被正确处理，避免程序崩溃或状态错误。
⚝ 避免回调地狱：合理使用 Future 的链式操作和组合操作，避免过深的回调嵌套，保持代码的可读性和可维护性。
⚝ 使用 Folly Executors 框架：结合 Folly 的 Executors 框架，可以更方便地管理和调度异步任务，提高并发编程的效率和可靠性。
掌握 Futures 和 Promises 的概念和使用技巧，可以帮助开发者编写更高效、更健壮的异步 C++ 代码，构建高性能的现代应用。
2.6 Executors：任务调度与并行执行 (Executors: Task Scheduling and Parallel Execution)
任务调度和并行执行是现代并发编程的核心需求。Folly 库提供了 Executors 框架，用于管理和调度异步任务，简化并行程序的编写，提高程序的性能和资源利用率。Executors 框架与 Futures 和 Promises 紧密结合，共同构建了 Folly 的异步并发编程体系。
2.6.1 任务调度与并行执行的需求 (Needs for Task Scheduling and Parallel Execution)
在很多应用场景中，需要并发执行多个任务，例如：
⚝ Web 服务器：需要并发处理多个客户端请求。
⚝ 数据处理：需要并行处理大量数据。
⚝ 科学计算：需要并行执行复杂的计算任务。
⚝ GUI 应用：需要将耗时操作放在后台线程执行，避免阻塞 UI 线程。
任务调度是指决定任务的执行顺序、优先级、资源分配等。并行执行是指同时执行多个任务，利用多核 CPU 的性能，提高程序的执行效率。
2.6.2 Executors 框架的概念 (Concepts of Executors Framework)
Folly Executors 框架提供了一种抽象的任务执行机制，将任务的提交和任务的执行解耦。开发者只需要提交任务给 Executor，Executor 负责调度和执行任务，无需关心任务的具体执行细节，例如线程管理、任务队列等。
① Executor (执行器):
⚝ Executor 是一个接口，定义了提交任务的方法 execute()。
⚝ Executor 负责接收任务，并将任务调度到合适的线程中执行。
⚝ Folly 提供了多种 Executor 的实现，例如 ThreadPoolExecutor、InlineExecutor、IOThreadPoolExecutor 等，每种 Executor 都有不同的调度策略和适用场景。
② Task (任务):
⚝ Task 是指要执行的工作单元，通常是一个函数对象（Functor）或 lambda 表达式。
⚝ Task 可以是CPU 密集型的，也可以是 IO 密集型的。
⚝ Task 可以返回一个值，也可以不返回值。
⚝ Task 可以抛出异常，也可以不抛出异常。
③ Executor 的类型 (Types of Executors):
⚝ InlineExecutor: 在提交任务的线程中同步执行任务。适用于测试、调试等场景，或者任务执行时间非常短的场景。
⚝ ThreadPoolExecutor: 使用线程池来执行任务。可以限制并发执行的任务数量，避免创建过多的线程。适用于 CPU 密集型任务。
⚝ IOThreadPoolExecutor: 专门用于IO 密集型任务的线程池。通常会配置更多的线程，以充分利用 IO 并发性。
⚝ CPUThreadPoolExecutor: 专门用于 CPU 密集型任务的线程池。通常会配置与 CPU 核心数相近的线程数，以最大化 CPU 利用率。
⚝ ScheduledExecutor: 可以延迟执行任务或周期性执行任务的 Executor。适用于定时任务、延迟任务等场景。
⚝ VirtualExecutor: 基于 C++20 协程的 Executor，可以实现轻量级的并发。
2.6.3 Folly Executors 框架的使用 (Usage of Folly Executors Framework)
Folly Executors 框架的使用非常简单，主要涉及创建 Executor 和 提交任务两个步骤。
① 创建 Executor (Creating Executor):
1
#include <folly/executors/ThreadPoolExecutor.h>
2
#include <folly/executors/InlineExecutor.h>
3
#include <iostream>
4
5
int main() {
6
// 创建一个线程池 Executor，线程数为 4
7
auto thread_pool_executor = std::make_shared<folly::ThreadPoolExecutor>(4);
8
9
// 创建一个 InlineExecutor
10
auto inline_executor = folly::InlineExecutor::instance();
11
12
// ... 使用 Executor ...
13
14
return 0;
15
}
② 提交任务 (Submitting Task):
⚝ executor->execute(task): 提交一个 void 返回值的任务。
⚝ folly::via(executor, task): 提交一个有返回值的任务，返回一个 folly::Future，用于获取任务的结果。
1
#include <folly/executors/ThreadPoolExecutor.h>
2
#include <folly/executors/InlineExecutor.h>
3
#include <folly/Future.h>
4
#include <iostream>
5
6
int main() {
7
auto thread_pool_executor = std::make_shared<folly::ThreadPoolExecutor>(4);
8
9
// 提交 void 返回值的任务
10
thread_pool_executor->execute([]() {
11
std::cout << "Task executed in thread pool" << std::endl;
12
});
13
14
// 提交有返回值的任务，并获取 Future
15
folly::Future<int> future_result = folly::via(thread_pool_executor.get(), []() {
16
std::this_thread::sleep_for(std::chrono::seconds(1)); // 模拟耗时操作
17
return 100;
18
});
19
20
try {
21
int result = future_result.get(); // 获取 Future 的结果
22
std::cout << "Task result: " << result << std::endl;
23
} catch (const std::exception& e) {
24
std::cerr << "Task exception: " << e.what() << std::endl;
25
}
26
27
return 0;
28
}
③ Executor 与 Future 的结合 (Combining Executor and Future):
folly::via(executor, task) 函数返回的 folly::Future 对象，可以将任务的执行结果与后续的异步操作链式连接起来，实现更复杂的异步流程。
1
#include <folly/executors/ThreadPoolExecutor.h>
2
#include <folly/executors/InlineExecutor.h>
3
#include <folly/Future.h>
4
#include <iostream>
5
6
folly::Future<int> async_task(int input, std::shared_ptr<folly::Executor> executor) {
7
return folly::via(executor.get(), [input]() {
8
std::this_thread::sleep_for(std::chrono::seconds(1)); // 模拟耗时操作
9
return input * 2;
10
});
11
}
12
13
int main() {
14
auto thread_pool_executor = std::make_shared<folly::ThreadPoolExecutor>(4);
15
16
// 提交异步任务，并链式处理 Future 的结果
17
async_task(20, thread_pool_executor)
18
.thenValue([](int result) {
19
std::cout << "Task result: " << result << std::endl;
20
return result + 10; // 返回新的值，用于下一个 thenValue
21
})
22
.thenValue([](int result) {
23
std::cout << "Next task result: " << result << std::endl;
24
})
25
.get(); // 阻塞等待整个异步链完成
26
27
return 0;
28
}
2.6.4 定制化 Executor 与调度策略 (Customized Executors and Scheduling Strategies)
Folly Executors 框架提供了高度的灵活性，开发者可以定制化 Executor，实现不同的调度策略，满足特定的应用需求。
① 自定义 Executor (Custom Executor):
可以继承 folly::Executor 接口，实现自定义的 Executor 类，例如：
⚝ 优先级 Executor：根据任务的优先级进行调度。
⚝ 资源限制 Executor：限制任务使用的资源（例如，内存、CPU 时间）。
⚝ 远程 Executor：将任务调度到远程机器执行。
② 调度策略 (Scheduling Strategies):
不同的 Executor 采用不同的调度策略，例如：
⚝ FIFO (First-In, First-Out)：ThreadPoolExecutor 默认使用 FIFO 策略，先提交的任务先执行。
⚝ LIFO (Last-In, First-Out)：可以自定义 Executor 实现 LIFO 策略。
⚝ 优先级调度：自定义优先级 Executor 可以实现优先级调度策略。
⚝ 公平调度：可以自定义 Executor 实现公平调度策略，保证每个任务都能获得一定的执行时间。
③ Executor 的配置 (Executor Configuration):
不同的 Executor 提供了不同的配置选项，例如：
⚝ 线程池大小：ThreadPoolExecutor 可以配置线程池的大小。
⚝ 任务队列大小：ThreadPoolExecutor 可以配置任务队列的大小。
⚝ 线程命名：可以为线程池中的线程命名，方便调试和监控。
2.6.5 Executors 框架的高级应用场景 (Advanced Application Scenarios of Executors Framework)
Executors 框架在构建高性能、高并发的应用中发挥着重要作用。
① 并发 Web 服务器 (Concurrent Web Server):
可以使用 IOThreadPoolExecutor 处理客户端请求，提高 Web 服务器的并发处理能力。
② 并行数据处理管道 (Parallel Data Processing Pipeline):
可以使用 Executors 框架构建并行数据处理管道，例如并行数据读取、并行数据转换、并行数据聚合等，提高数据处理效率。
③ 异步任务队列 (Asynchronous Task Queue):
可以使用 ScheduledExecutor 实现异步任务队列，例如延迟任务、定时任务、后台任务等。
④ 微服务架构 (Microservices Architecture):
在微服务架构中，可以使用 Executors 框架管理和调度微服务之间的异步调用，提高系统的响应性和吞吐量。
2.6.6 Executors 框架的最佳实践 (Best Practices for Executors Framework)
⚝ 选择合适的 Executor 类型：根据任务的类型（CPU 密集型、IO 密集型）、性能需求、资源限制等，选择合适的 Executor 类型。
⚝ 合理配置 Executor 参数：根据应用场景和负载情况，合理配置 Executor 的参数，例如线程池大小、任务队列大小等。
⚝ 避免阻塞 Executor 线程：在提交给 Executor 的任务中，尽量避免阻塞操作，例如同步 IO、长时间计算等，以免影响 Executor 的性能。
⚝ 监控 Executor 性能：监控 Executor 的性能指标，例如任务队列长度、线程池利用率、任务执行时间等，及时发现和解决性能瓶颈。
⚝ 结合 Futures 和 Promises 使用：充分利用 Futures 和 Promises 与 Executors 框架的集成，构建更强大的异步并发程序。
掌握 Executors 框架的概念和使用技巧，可以帮助开发者编写更高效、更可靠的并发 C++ 代码，构建高性能的现代应用。
2.7 Time：时间处理与时间轮 (Time: Time Handling and Time Wheel)
时间处理是软件开发中不可或缺的一部分，涉及到时间表示、时间计算、定时器、超时控制等。Folly 库提供了强大的 Time 库，用于简化和优化 C++ 的时间处理，并提供了高效的 时间轮（Time Wheel） 算法，用于实现高性能的定时器服务。
2.7.1 时间处理的需求与挑战 (Needs and Challenges of Time Handling)
在软件开发中，时间处理涉及到各种各样的需求，例如：
⚝ 记录事件发生的时间戳。
⚝ 计算时间间隔。
⚝ 设置定时器，在指定时间执行任务。
⚝ 实现超时控制，防止操作长时间阻塞。
⚝ 处理时区和夏令时。
⚝ 进行时间格式化和解析。
传统 C++ 的时间处理方式，例如使用 std::chrono 库，在某些情况下可能显得繁琐、低效。Folly Time 库旨在提供更简洁、更高效、更易用的时间处理工具。
2.7.2 Folly Time 库的核心组件 (Core Components of Folly Time Library)
Folly Time 库提供了一系列核心组件，用于简化时间处理：
① TimePoint (时间点):
⚝ TimePoint 表示时间轴上的一个特定时刻。
⚝ Folly 提供了多种 TimePoint 类型，例如 MicrosecondTimePoint (微秒精度)、MillisecondTimePoint (毫秒精度)、SecondTimePoint (秒精度) 等。
⚝ TimePoint 可以进行加减运算，得到 Duration (时间段)。
⚝ TimePoint 可以与 Duration 进行加减运算，得到新的 TimePoint。
⚝ TimePoint 可以进行比较运算，判断时间先后顺序。
② Duration (时间段):
⚝ Duration 表示时间轴上的一个时间间隔。
⚝ Folly 提供了多种 Duration 类型，例如 Microseconds、Milliseconds、Seconds、Minutes、Hours 等。
⚝ Duration 可以进行加减乘除运算。
⚝ Duration 可以转换为不同的时间单位，例如将 Seconds 转换为 Milliseconds。
⚝ Duration 可以与 TimePoint 进行加减运算。
③ Clock (时钟):
⚝ Clock 提供获取当前时间点的功能。
⚝ Folly 提供了多种 Clock 实现，例如 SystemClock (系统时钟)、MonotonicClock (单调时钟) 等。
⚝ SystemClock 基于系统时间，可能会受到系统时间调整的影响。
⚝ MonotonicClock 基于单调递增的时间，不受系统时间调整的影响，更适合用于测量时间间隔。
④ Timer (定时器):
⚝ Timer 用于在指定时间或时间间隔后执行任务。
⚝ Folly 提供了多种 Timer 实现，例如 EventBaseTimer (基于 EventBase 的定时器)、HHWheelTimer (基于分层时间轮的定时器) 等。
⚝ Timer 可以单次触发，也可以周期性触发。
⚝ Timer 可以取消。
⑤ 时间格式化和解析 (Time Formatting and Parsing):
⚝ Folly Time 库提供了时间格式化和解析的功能，可以将 TimePoint 格式化为字符串，也可以将字符串解析为 TimePoint。
⚝ 支持自定义时间格式。
⚝ 支持时区处理。
2.7.3 Folly Time 库的使用 (Usage of Folly Time Library)
Folly Time 库的使用非常简洁直观。
① 获取当前时间 (Getting Current Time):
1
#include <folly/Time/Time.h>
2
#include <iostream>
3
4
int main() {
5
// 获取当前微秒时间点
6
folly::MicrosecondTimePoint now = folly::MicrosecondClock::now();
7
std::cout << "Current time (microseconds): " << now.time_since_epoch().count() << std::endl;
8
9
// 获取当前毫秒时间点
10
folly::MillisecondTimePoint now_ms = folly::MillisecondClock::now();
11
std::cout << "Current time (milliseconds): " << now_ms.time_since_epoch().count() << std::endl;
12
13
return 0;
14
}
② 时间计算 (Time Calculation):
1
#include <folly/Time/Time.h>
2
#include <iostream>
3
4
int main() {
5
folly::MicrosecondTimePoint start_time = folly::MicrosecondClock::now();
6
std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 模拟耗时操作
7
folly::MicrosecondTimePoint end_time = folly::MicrosecondClock::now();
8
9
// 计算时间间隔
10
folly::Microseconds duration = end_time - start_time;
11
std::cout << "Duration (microseconds): " << duration.count() << std::endl;
12
13
// 时间点加减运算
14
folly::MicrosecondTimePoint future_time = start_time + folly::Seconds(1);
15
std::cout << "Future time (microseconds): " << future_time.time_since_epoch().count() << std::endl;
16
17
return 0;
18
}
③ 定时器 (Timer):
1
#include <folly/Time/Time.h>
2
#include <folly/io/async/EventBase.h>
3
#include <iostream>
4
5
int main() {
6
folly::EventBase evb;
7
folly::EventBaseTimer timer(&evb);
8
9
// 定时器回调函数
10
auto timer_callback = []() {
11
std::cout << "Timer fired!" << std::endl;
12
};
13
14
// 设置单次定时器，1 秒后触发
15
timer.scheduleOnce(timer_callback, std::chrono::seconds(1));
16
17
// 设置周期性定时器，每 500 毫秒触发一次
18
timer.schedule([timer_callback]() {
19
timer_callback();
20
}, std::chrono::milliseconds(500));
21
22
evb.loopForever(); // 运行 EventBase 循环，处理定时器事件
23
24
return 0;
25
}
④ 时间格式化和解析 (Time Formatting and Parsing):
1
#include <folly/Time/Time.h>
2
#include <iostream>
3
4
int main() {
5
folly::MicrosecondTimePoint now = folly::MicrosecondClock::now();
6
7
// 格式化为字符串
8
std::string formatted_time = folly::time_string(now);
9
std::cout << "Formatted time: " << formatted_time << std::endl;
10
11
// 解析字符串为时间点
12
folly::MicrosecondTimePoint parsed_time;
13
if (folly::parse_time_string("2023-10-27 10:30:00", parsed_time)) {
14
std::cout << "Parsed time (microseconds): " << parsed_time.time_since_epoch().count() << std::endl;
15
} else {
16
std::cerr << "Failed to parse time string" << std::endl;
17
}
18
19
return 0;
20
}
2.7.4 时间轮 (Time Wheel) 算法 (Time Wheel Algorithm)
时间轮（Time Wheel） 是一种高效的定时器算法，适用于高并发、大规模的定时器服务。Folly Time 库提供了 HHWheelTimer (Hierarchical Hash Wheel Timer)，是时间轮算法的一种实现。
① 时间轮的基本原理 (Basic Principle of Time Wheel):
⚝ 时间轮将时间划分为多个时间槽（Slot），每个时间槽对应一个时间刻度。
⚝ 定时器任务根据其超时时间被分配到不同的时间槽中。
⚝ 时间轮周期性地转动，每转动到一个时间槽，就检查该时间槽中的任务，如果任务超时，则执行任务。
⚝ 时间轮通常采用分层结构，例如 HHWheelTimer 使用分层哈希轮，以支持更长的时间范围和更高的精度。
② 时间轮的优势 (Advantages of Time Wheel):
⚝ 高效性：时间轮算法的时间复杂度接近 O(1)，任务的添加、删除、触发都非常高效。
⚝ 可扩展性：时间轮可以支持大量的定时器任务，适用于高并发场景。
⚝ 低开销：时间轮的内存开销和 CPU 开销都比较低。
③ HHWheelTimer 的使用 (Usage of HHWheelTimer):
1
#include <folly/Time/HHWheelTimer.h>
2
#include <folly/io/async/EventBase.h>
3
#include <iostream>
4
5
int main() {
6
folly::EventBase evb;
7
folly::HHWheelTimer timer(&evb);
8
9
// 定时器回调函数
10
auto timer_callback = [](int timer_id) {
11
std::cout << "Timer " << timer_id << " fired!" << std::endl;
12
};
13
14
// 设置多个定时器
15
timer.scheduleOnce(std::bind(timer_callback, 1), std::chrono::seconds(1));
16
timer.scheduleOnce(std::bind(timer_callback, 2), std::chrono::seconds(2));
17
timer.scheduleOnce(std::bind(timer_callback, 3), std::chrono::seconds(3));
18
19
evb.loopForever(); // 运行 EventBase 循环，处理定时器事件
20
21
return 0;
22
}
2.7.5 Folly Time 库的高级应用场景 (Advanced Application Scenarios of Folly Time Library)
Folly Time 库在构建高性能、高可靠的应用中发挥着重要作用。
① 高性能定时器服务 (High-Performance Timer Service):
可以使用 HHWheelTimer 构建高性能的定时器服务，例如任务调度系统、延迟队列、会话超时管理等。
② 网络编程超时控制 (Network Programming Timeout Control):
可以使用 Folly Time 库实现网络编程中的连接超时、读写超时、请求超时等控制，提高网络应用的健壮性。
③ 性能 профилирование (Profiling) 和监控 (Monitoring):
可以使用 Folly Time 库进行性能 профилирование (Profiling)，例如测量函数执行时间、操作延迟等。也可以用于监控系统运行时间、任务执行时间等。
2.7.6 Folly Time 库的最佳实践 (Best Practices for Folly Time Library)
⚝ 选择合适的时间精度：根据应用需求，选择合适的时间精度，例如微秒、毫秒、秒等，避免不必要的精度开销。
⚝ 使用 MonotonicClock 测量时间间隔：在测量时间间隔时，优先使用 MonotonicClock，避免系统时间调整的影响。
⚝ 合理配置时间轮参数：在使用 HHWheelTimer 时，根据定时器任务的数量、超时范围、精度要求等，合理配置时间轮的参数，例如时间槽数量、时间刻度等。
⚝ 注意定时器任务的执行时间：定时器任务的执行时间不宜过长，以免影响时间轮的精度和性能。如果任务执行时间较长，应该将任务提交到线程池异步执行。
⚝ 结合 Folly EventBase 使用：Folly Timer 通常与 EventBase 结合使用，利用 EventBase 的事件循环机制处理定时器事件。
掌握 Folly Time 库的概念和使用技巧，可以帮助开发者编写更高效、更可靠的时间处理 C++ 代码，构建高性能的现代应用。
2.8 动态类型：Dynamic与Variant (Dynamic Types: Dynamic and Variant)
在 C++ 这种静态类型语言中，动态类型的概念相对较少使用。但在某些场景下，例如处理 JSON 数据、脚本语言集成、反射等，动态类型可以提供更大的灵活性和便利性。Folly 库提供了 Dynamic 和 Variant 两种类型，用于支持 C++ 的动态类型编程。
2.8.1 动态类型的需求与应用场景 (Needs and Application Scenarios of Dynamic Types)
动态类型允许变量在运行时改变类型，或者变量可以存储不同类型的值。在 C++ 中，虽然不能像动态类型语言那样直接声明动态类型变量，但可以使用一些技巧和库来实现类似的功能。
① 处理 JSON 数据 (Handling JSON Data):
JSON (JavaScript Object Notation) 是一种常用的数据交换格式，其数据结构是动态类型的，可以包含数字、字符串、布尔值、数组、对象等多种类型。在 C++ 中处理 JSON 数据时，使用动态类型可以更方便地表示和操作 JSON 数据结构。
② 脚本语言集成 (Scripting Language Integration):
在 C++ 程序中集成脚本语言（例如，Python、Lua、JavaScript）时，需要在 C++ 和脚本语言之间传递数据。脚本语言通常是动态类型的，使用动态类型可以更方便地在 C++ 中表示和操作脚本语言的数据。
③ 反射 (Reflection):
反射是指程序在运行时检查自身结构的能力，例如获取类名、成员变量、方法等信息。动态类型可以用于实现 C++ 的反射功能，例如动态创建对象、动态调用方法等。
④ 数据序列化和反序列化 (Data Serialization and Deserialization):
在数据序列化和反序列化过程中，有时需要处理类型不确定的数据。动态类型可以用于表示和操作这些类型不确定的数据。
2.8.2 Folly Dynamic 类型 (Folly Dynamic Type)
folly::dynamic 是 Folly 提供的动态类型，它可以存储多种类型的值，例如 bool、int64_t、double、std::string、std::vector<dynamic>、folly::dynamic::object 等。dynamic 类型类似于 JavaScript 中的动态类型变量。
① dynamic 的类型 (Types of dynamic):
⚝ bool: 布尔值。
⚝ int64_t: 64 位整数。
⚝ double: 双精度浮点数。
⚝ std::string: 字符串。
⚝ std::vector<dynamic>: 动态数组，元素类型为 dynamic。
⚝ folly::dynamic::object: 动态对象，类似于 JSON 对象，键值对的集合，键是字符串，值是 dynamic。
⚝ nullptr: 空值。
② dynamic 的基本操作 (Basic Operations of dynamic):
⚝ 构造 (Construction): dynamic 可以从多种类型构造，例如 bool、int、double、std::string 等。
⚝ 赋值 (Assignment): 可以将不同类型的值赋值给 dynamic 变量。
⚝ 类型检查 (Type Checking): 可以使用 isBool()、isInt()、isDouble()、isString()、isArray()、isObject()、isNull() 等方法检查 dynamic 变量的类型。
⚝ 类型转换 (Type Conversion): 可以使用 asBool()、asInt()、asDouble()、asString()、asArray()、asObject() 等方法将 dynamic 变量转换为特定类型。如果类型不匹配，会抛出异常。
⚝ 数组操作 (Array Operations): 对于 dynamic 数组，可以使用 size()、at()、push_back() 等方法进行操作。
⚝ 对象操作 (Object Operations): 对于 dynamic 对象，可以使用 count()、operator[]、items() 等方法进行操作。
③ dynamic 的使用示例 (Usage Example of dynamic):
1
#include <folly/dynamic.h>
2
#include <iostream>
3
#include <vector>
4
5
int main() {
6
folly::dynamic d; // 默认构造，值为 null
7
8
d = true; // 赋值为布尔值
9
std::cout << "d is bool: " << d.isBool() << ", value: " << d.asBool() << std::endl;
10
11
d = 123; // 赋值为整数
12
std::cout << "d is int: " << d.isInt() << ", value: " << d.asInt() << std::endl;
13
14
d = 3.14; // 赋值为浮点数
15
std::cout << "d is double: " << d.isDouble() << ", value: " << d.asDouble() << std::endl;
16
17
d = "hello dynamic"; // 赋值为字符串
18
std::cout << "d is string: " << d.isString() << ", value: " << d.asString() << std::endl;
19
20
d = folly::dynamic::array(1, 2, 3); // 赋值为动态数组
21
std::cout << "d is array: " << d.isArray() << ", size: " << d.asArray().size() << std::endl;
22
23
d = folly::dynamic::object("name", "folly", "version", 1.0); // 赋值为动态对象
24
std::cout << "d is object: " << d.isObject() << ", name: " << d.asObject()["name"].asString() << std::endl;
25
26
return 0;
27
}
2.8.3 Folly Variant 类型 (Folly Variant Type)
folly::variant 是 Folly 提供的类型安全的联合体，它可以存储多种预定义的类型之一。variant 类型类似于 C++17 标准库的 std::variant，但 Folly 的 variant 提供了更多的功能和优化。
① variant 的类型安全 (Type Safety of variant):
variant 是类型安全的，它在编译时就确定了可以存储的类型列表。在运行时，variant 会跟踪当前存储的类型，并防止类型错误。
② variant 的类型列表 (Type List of variant):
variant 的类型列表在声明时指定，例如 folly::variant<int, std::string, bool> 表示该 variant 可以存储 int、std::string 或 bool 类型的值。
③ variant 的基本操作 (Basic Operations of variant):
⚝ 构造 (Construction): variant 可以从其类型列表中的任何类型构造。
⚝ 赋值 (Assignment): 可以将类型列表中的任何类型的值赋值给 variant 变量。
⚝ 类型检查 (Type Checking): 可以使用 is_type<T>() 方法检查 variant 当前存储的类型是否为 T。
⚝ 类型访问 (Type Access): 可以使用 as<T>() 方法将 variant 转换为类型 T 的值。如果类型不匹配，会抛出异常。
⚝ 访问者模式 (Visitor Pattern): 可以使用 match() 函数和访问者模式，根据 variant 当前存储的类型执行不同的操作。
④ variant 的使用示例 (Usage Example of variant):
1
#include <folly/Variant.h>
2
#include <iostream>
3
#include <string>
4
5
int main() {
6
folly::variant<int, std::string, bool> v; // 声明 variant，可以存储 int, string, bool
7
8
v = 100; // 赋值为 int
9
if (v.is_type<int>()) {
10
std::cout << "v is int, value: " << v.as<int>() << std::endl;
11
}
12
13
v = "hello variant"; // 赋值为 string
14
if (v.is_type<std::string>()) {
15
std::cout << "v is string, value: " << v.as<std::string>() << std::endl;
16
}
17
18
v = true; // 赋值为 bool
19
if (v.is_type<bool>()) {
20
std::cout << "v is bool, value: " << v.as<bool>() << std::endl;
21
}
22
23
// 使用 match() 和访问者模式
24
folly::match(
25
v,
26
[](int val) { std::cout << "Variant is int: " << val << std::endl; },
27
[](const std::string& str) { std::cout << "Variant is string: " << str << std::endl; },
28
[](bool b) { std::cout << "Variant is bool: " << b << std::endl; });
29
30
return 0;
31
}
2.8.4 Dynamic 与 Variant 的选择 (Choosing between Dynamic and Variant)
选择 dynamic 还是 variant，取决于具体的应用场景和需求。
① 灵活性 vs. 类型安全 (Flexibility vs. Type Safety):
⚝ dynamic: 更灵活，可以存储任意类型的值，运行时类型检查。适用于需要处理未知类型数据的场景，例如 JSON 解析。
⚝ variant: 更类型安全，编译时确定类型列表，编译时类型检查。适用于需要处理预定义类型集合的场景，例如状态机、数据结构。
② 性能 (Performance):
⚝ dynamic: 性能开销较大，运行时类型检查、动态内存分配等。
⚝ variant: 性能开销较小，编译时类型确定，静态内存分配。
③ 代码可读性和维护性 (Code Readability and Maintainability):
⚝ dynamic: 代码可能更简洁，但类型安全性较弱，容易出错。
⚝ variant: 代码可能稍显冗余，但类型安全性更高，更易于维护。
④ 总结 (Summary):
⚝ dynamic: 适用于需要处理动态类型数据的场景，例如 JSON 数据、脚本语言集成。
⚝ variant: 适用于需要类型安全的场景，例如状态机、数据结构、错误处理。
⚝ 选择原则: 根据对灵活性、类型安全、性能、代码可读性的需求进行权衡，选择最合适的类型。
在实际项目中，可以根据具体的应用场景和需求，选择使用 dynamic 或 variant，或者组合使用。例如，可以使用 dynamic 解析 JSON 数据，然后将 JSON 数据转换为 variant 类型进行类型安全的处理。
END_OF_CHAPTER
3. chapter 3： Thrift IDL详解：定义你的数据与服务 (Thrift IDL Deep Dive: Define Your Data and Services)
3.1 Thrift IDL语法基础：数据类型、结构体、枚举 (Thrift IDL Syntax Basics: Data Types, Structs, Enums)
Thrift 接口定义语言（Interface Definition Language, IDL）是定义数据结构和服务接口的核心。它使用一种简洁而强大的语法，允许开发者以平台无关的方式描述数据类型、服务接口和异常。本节将深入探讨Thrift IDL的基础语法，包括数据类型、结构体（Structs）和枚举（Enums），为后续章节的学习打下坚实的基础。
3.1.1 基本数据类型 (Basic Data Types)
Thrift IDL 提供了一组丰富的基础数据类型，可以满足绝大多数数据定义的需求。这些类型可以分为以下几类：
① 基本类型 (Primitive Types)：
⚝ bool：布尔类型，表示真或假。例如：bool success = true;
⚝ byte：8位有符号整数。例如：byte flags = 0x01;
⚝ i16：16位有符号整数。例如：i16 port = 8080;
⚝ i32：32位有符号整数。例如：i32 count = 1024;
⚝ i64：64位有符号整数。例如：i64 timestamp = 1678886400;
⚝ double：64位浮点数。例如：double price = 99.99;
⚝ string：字符串类型，默认编码为UTF-8。例如：string name = "example";
⚝ binary：二进制类型，表示原始字节序列。例如：binary data = "raw data";
② 容器类型 (Container Types)：
Thrift 提供了三种容器类型，用于组织和存储数据集合：
⚝ list<T>：有序列表，元素类型为 T。类似于C++的 std::vector 或 Python 的 list。例如：list<string> names;
⚝ set<T>：无序集合，元素类型为 T，元素唯一。类似于C++的 std::set 或 Python 的 set。例如：set<i32> ids;
⚝ map<K, V>：键值对映射，键类型为 K，值类型为 V。类似于C++的 std::map 或 Python 的 dict。例如：map<string, string> headers;
③ 特殊类型 (Special Types)：
⚝ void：空类型，通常用于表示不返回任何值的函数。
代码示例 3-1：基本数据类型示例
1
struct ExampleData {
2
1: bool is_valid;
3
2: byte status_code;
4
3: i16 retry_count;
5
4: i32 request_id;
6
5: i64 session_id;
7
6: double value;
8
7: string message;
9
8: binary raw_bytes;
10
9: list<string> tags;
11
10: set<i32> unique_ids;
12
11: map<string, i32> counts;
13
}
在上述示例中，我们定义了一个名为 ExampleData 的结构体，其中包含了各种基本数据类型的字段，展示了如何在 Thrift IDL 中声明和使用这些类型。
3.1.2 结构体 (Structs)
结构体（Structs）是 Thrift IDL 中用于定义复合数据类型的主要方式。它允许将多个不同类型的数据字段组合成一个逻辑单元，类似于C++中的结构体或类，以及Python中的类。
① 结构体定义：
使用关键字 struct 开始结构体定义，后跟结构体名称，并在花括号 {} 内定义结构体的字段。每个字段定义包括一个唯一的字段ID（正整数）、字段类型和字段名称。字段ID用于序列化和反序列化，保证协议的向前和向后兼容性。
② 字段规则 (Field Rules)：
字段规则用于指定字段是必需的（required）还是可选的（optional）。
⚝ required：必需字段，在序列化时必须存在。如果客户端或服务端在发送或接收数据时缺少必需字段，可能会导致错误。
⚝ optional：可选字段，在序列化时可以省略。可选字段提供了更大的灵活性，允许在不破坏兼容性的前提下添加新的字段。
⚝ 默认情况下，如果未指定字段规则，则行为类似于 optional，但在实践中，显式指定 required 或 optional 是更好的做法，以增强代码的可读性和可维护性。
代码示例 3-2：结构体定义示例
1
struct UserProfile {
2
1: required i32 user_id;
3
2: string user_name; // 默认为 optional
4
3: optional string email;
5
4: optional list<string> interests;
6
}
在 UserProfile 结构体中，user_id 是必需字段，user_name 默认为可选字段，email 和 interests 显式声明为可选字段。
3.1.3 枚举 (Enums)
枚举（Enums）允许定义一组具名的整数常量，用于表示一组相关的离散值。枚举可以提高代码的可读性和可维护性，避免使用 Magic Number。
① 枚举定义：
使用关键字 enum 开始枚举定义，后跟枚举名称，并在花括号 {} 内定义枚举的成员。每个枚举成员由一个名称和一个可选的整数值组成。如果未指定值，则默认从0开始递增。
② 枚举成员 (Enum Members)：
枚举成员是具名的整数常量。可以显式地为枚举成员赋值，也可以使用默认的自动递增赋值。
代码示例 3-3：枚举定义示例
1
enum Status {
2
OK = 0,
3
WARNING = 1,
4
ERROR = 2,
5
CRITICAL = 3
6
}
7
8
enum LogLevel {
9
DEBUG, // 默认值为 0
10
INFO, // 默认值为 1
11
WARN, // 默认值为 2
12
ERROR, // 默认值为 3
13
FATAL // 默认值为 4
14
}
在 Status 枚举中，我们显式地为每个成员赋值。在 LogLevel 枚举中，我们使用了默认的自动递增赋值。
3.1.4 常量 (Constants)
Thrift IDL 允许定义常量，用于表示固定的值。常量可以是基本数据类型或枚举类型。
① 常量定义：
使用关键字 const 开始常量定义，后跟常量类型、常量名称和常量值。
代码示例 3-4：常量定义示例
1
const i32 MAX_CONNECTIONS = 1000;
2
const string DEFAULT_ENCODING = "UTF-8";
3
const Status DEFAULT_STATUS = Status.OK;
常量在整个 IDL 文件中都是可见的，可以在结构体、服务定义等地方使用。
3.1.5 类型别名 (Type Aliases)
类型别名（Type Aliases）允许为现有的类型定义一个新的名称，以提高代码的可读性和可维护性，或者简化复杂类型的使用。
① 类型别名定义：
使用关键字 typedef 开始类型别名定义，后跟原始类型和新的类型名称。
代码示例 3-5：类型别名定义示例
1
typedef i64 UserId
2
typedef string EmailAddress
3
typedef list<UserProfile> UserProfileList
通过使用类型别名，我们可以使 IDL 定义更加清晰易懂，例如使用 UserId 代替 i64，可以更清楚地表达字段的含义。
本节介绍了 Thrift IDL 的基本语法，包括基本数据类型、结构体、枚举、常量和类型别名。掌握这些基础知识是理解和使用 Thrift IDL 的关键，为后续学习服务定义、协议和传输层等高级特性奠定了基础。
3.2 服务定义：接口与方法 (Service Definition: Interfaces and Methods)
Thrift IDL 的核心功能之一是定义服务接口。服务定义描述了客户端可以调用的远程过程调用（Remote Procedure Call, RPC）方法。本节将详细介绍如何在 Thrift IDL 中定义服务接口和方法。
3.2.1 服务 (Service) 定义
服务（Service）是 Thrift IDL 中定义接口的关键字。一个服务定义包含了一组相关的方法，客户端可以通过 Thrift 框架调用这些方法，服务端则负责实现这些方法。
① 服务定义语法：
使用关键字 service 开始服务定义，后跟服务名称，并在花括号 {} 内定义服务的方法。
代码示例 3-6：服务定义基本结构
1
service UserService {
2
// 方法定义将在这里
3
}
UserService 是服务的名称，可以根据服务的业务领域进行命名，例如 OrderService、PaymentService 等。
3.2.2 方法 (Method) 定义
方法（Method）定义了服务提供的具体操作。每个方法定义包括返回值类型、方法名称和参数列表。
① 方法定义语法：
方法定义位于服务定义的花括号内。语法结构如下：
1
<返回值类型> <方法名称>(<参数列表>)
⚝ 返回值类型：指定方法返回的数据类型。可以是任何 Thrift IDL 支持的数据类型，包括基本类型、结构体、枚举、容器类型，以及 void（表示不返回任何值）。
⚝ 方法名称：方法的标识符，客户端通过方法名称调用服务端的方法。方法名称应具有描述性，清晰表达方法的功能。
⚝ 参数列表：定义方法接受的输入参数。参数列表由零个或多个参数定义组成，每个参数定义包括一个唯一的字段ID（正整数）、参数类型和参数名称。参数之间用逗号 , 分隔。
代码示例 3-7：方法定义示例
1
service CalculatorService {
2
// 加法方法
3
i32 add(1: i32 num1, 2: i32 num2),
4
5
// 减法方法
6
i32 subtract(1: i32 num1, 2: i32 num2),
7
8
// 乘法方法
9
i32 multiply(1: i32 num1, 2: i32 num2),
10
11
// 除法方法，可能抛出异常
12
double divide(1: i32 dividend, 2: i32 divisor) throws (1: DivideByZeroException ex),
13
14
// 无返回值的方法
15
void ping()
16
}
在 CalculatorService 服务中，我们定义了 add、subtract、multiply、divide 和 ping 五个方法。
⚝ add、subtract 和 multiply 方法接收两个 i32 类型的参数，并返回 i32 类型的结果。
⚝ divide 方法接收两个 i32 类型的参数，返回 double 类型的结果，并且声明了可能抛出 DivideByZeroException 异常（异常将在后续章节详细介绍）。
⚝ ping 方法没有参数，也没有返回值（void 类型），通常用于健康检查。
3.2.3 参数列表 (Parameter List)
方法的参数列表定义了方法接受的输入数据。每个参数在参数列表中都有一个唯一的字段ID、参数类型和参数名称。
① 参数定义语法：
参数定义的语法结构如下：
1
<字段ID>: <参数类型> <参数名称>
⚝ 字段ID：正整数，用于参数的序列化和反序列化。在同一个方法的参数列表中，字段ID必须唯一。
⚝ 参数类型：参数的数据类型，可以是任何 Thrift IDL 支持的数据类型。
⚝ 参数名称：参数的标识符，在方法实现中用于访问参数值。
代码示例 3-8：带结构体参数的方法
1
struct Point {
2
1: i32 x,
3
2: i32 y
4
}
5
6
service GeometryService {
7
// 计算两点之间的距离
8
double calculateDistance(1: Point p1, 2: Point p2)
9
}
在 GeometryService 服务中，calculateDistance 方法接收两个 Point 类型的参数 p1 和 p2，用于计算两点之间的距离。
3.2.4 oneway 方法
默认情况下，Thrift 方法调用是同步的，客户端发送请求后会等待服务端响应。Thrift 提供了 oneway 关键字，用于定义单向方法调用。oneway 方法的特点是：
① 异步调用：客户端发送请求后立即返回，不会等待服务端响应。
② 无返回值：oneway 方法必须声明为 void 返回类型，因为客户端不会接收到服务端的任何响应。
③ 可靠性降低：由于客户端不等待响应，因此无法保证服务端是否成功接收和处理了请求。oneway 方法适用于对响应延迟敏感，但对可靠性要求相对较低的场景，例如日志上报、事件通知等。
代码示例 3-9：oneway 方法示例
1
service LogService {
2
// 上报日志消息，单向调用
3
oneway void logMessage(1: string message)
4
}
在 LogService 服务中，logMessage 方法被声明为 oneway void，客户端调用 logMessage 方法后会立即返回，不会等待服务端确认日志是否已接收。
3.2.5 服务继承 (Service Inheritance)
Thrift IDL 支持服务继承，允许一个服务继承另一个服务的方法。子服务会继承父服务的所有方法，并可以添加新的方法。
① 服务继承语法：
使用关键字 extends 指定父服务。
1
service <子服务名称> extends <父服务名称> {
2
// 子服务的方法定义
3
}
代码示例 3-10：服务继承示例
1
service BaseService {
2
// 基础服务方法
3
void ping()
4
}
5
6
service AdvancedService extends BaseService {
7
// 高级服务方法
8
string getVersion()
9
}
AdvancedService 继承了 BaseService，因此 AdvancedService 既包含 BaseService 的 ping 方法，也包含自身定义的 getVersion 方法。服务继承可以用于组织和复用服务定义，提高代码的模块化和可维护性。
本节详细介绍了 Thrift IDL 中服务和方法的定义，包括服务的基本结构、方法的返回值类型、参数列表、oneway 方法以及服务继承。掌握服务定义是使用 Thrift 构建 RPC 服务的核心，为后续学习 Thrift 协议、传输层和代码生成奠定了基础。
3.3 命名空间与包含：模块化你的Thrift定义 (Namespaces and Includes: Modularize Your Thrift Definitions)
随着项目规模的增长，Thrift IDL 文件可能会变得庞大而复杂。为了提高代码的可维护性和可读性，Thrift 提供了命名空间（Namespaces）和包含（Includes）机制，用于模块化和组织 IDL 定义。本节将介绍如何使用命名空间和包含来管理 Thrift IDL 文件。
3.3.1 命名空间 (Namespace)
命名空间（Namespace）用于避免命名冲突，并将相关的 IDL 定义组织到逻辑组中。Thrift 允许为不同的编程语言定义不同的命名空间，以适应各种语言的命名约定。
① 命名空间定义语法：
使用关键字 namespace 后跟编程语言和命名空间名称。
1
namespace <语言> <命名空间名称>
⚝ <语言>：指定编程语言，例如 cpp、java、py、go、js、php、csharp 等。* 可以用作通配符，表示所有语言的默认命名空间。
⚝ <命名空间名称>：命名空间的名称，通常采用与语言相关的命名约定。例如，Java 命名空间通常使用反向域名，如 com.example.service；C++ 命名空间通常使用模块名，如 example::service；Python 命名空间通常使用模块名，如 example.service。
代码示例 3-11：命名空间定义示例
1
namespace cpp com.example.calculator
2
namespace java com.example.calculator
3
namespace py example.calculator
4
namespace * example.calculator // 默认命名空间
5
6
struct Number {
7
1: i32 value
8
}
9
10
service CalculatorService {
11
i32 add(1: Number num1, 2: Number num2)
12
}
在上述示例中，我们为 C++、Java 和 Python 分别定义了命名空间 com.example.calculator、com.example.calculator 和 example.calculator。namespace * example.calculator 定义了默认命名空间，当没有特定语言的命名空间定义时，将使用默认命名空间。
② 命名空间的作用：
⚝ 避免命名冲突：当多个 IDL 文件中定义了相同的类型或服务名称时，命名空间可以防止命名冲突。通过使用不同的命名空间，可以区分来自不同模块的同名定义。
⚝ 代码组织：命名空间可以将相关的 IDL 定义组织到一起，形成逻辑模块，提高代码的可读性和可维护性。
⚝ 语言适配：不同的编程语言有不同的命名约定，Thrift 允许为每种语言定义不同的命名空间，以生成符合语言习惯的代码。
3.3.2 包含 (Include)
包含（Include）允许在一个 Thrift IDL 文件中引用另一个 IDL 文件中定义的类型、常量和服务。通过包含，可以将大型 IDL 定义拆分成多个小的、模块化的文件，提高代码的复用性和可维护性。
① 包含语法：
使用关键字 include 后跟要包含的 IDL 文件路径（字符串字面量）。
1
include "path/to/another.thrift"
被包含的文件路径可以是相对路径或绝对路径。通常使用相对路径，相对于当前 IDL 文件所在的目录。
代码示例 3-12：包含示例
假设我们有两个 IDL 文件：common.thrift 和 calculator.thrift。
common.thrift 文件内容：
1
namespace cpp com.example.common
2
namespace java com.example.common
3
namespace py example.common
4
5
struct Number {
6
1: i32 value
7
}
8
9
enum OperationType {
10
ADD,
11
SUBTRACT,
12
MULTIPLY,
13
DIVIDE
14
}
calculator.thrift 文件内容：
1
include "common.thrift"
2
3
namespace cpp com.example.calculator
4
namespace java com.example.calculator
5
namespace py example.calculator
6
7
service CalculatorService {
8
i32 calculate(1: common.Number num1, 2: common.Number num2, 3: common.OperationType op)
9
}
在 calculator.thrift 文件中，我们使用 include "common.thrift" 包含了 common.thrift 文件。这样，calculator.thrift 文件就可以使用 common.thrift 中定义的 Number 结构体和 OperationType 枚举。在引用被包含文件中定义的类型时，需要使用被包含文件的命名空间作为前缀，例如 common.Number 和 common.OperationType。
② 包含的作用：
⚝ 代码复用：通过包含，可以在多个 IDL 文件中复用相同的类型和常量定义，避免重复编写代码。
⚝ 模块化：将大型 IDL 定义拆分成多个小的文件，每个文件负责定义一个模块的功能，提高代码的模块化程度。
⚝ 依赖管理：包含关系明确了 IDL 文件之间的依赖关系，有助于管理和维护复杂的 IDL 定义。
3.3.3 命名空间与包含的最佳实践
① 合理划分命名空间：根据业务模块或功能领域划分命名空间，避免命名空间过于宽泛或过于细碎。
② 使用包含组织模块：将相关的类型、常量和服务定义放在同一个 IDL 文件中，并使用包含将不同模块的 IDL 文件组织起来。
③ 避免循环包含：循环包含会导致编译错误，应避免在 IDL 文件之间形成循环依赖关系。
④ 保持命名空间一致性：在同一个项目中，保持命名空间命名风格的一致性，提高代码的可读性。
通过合理使用命名空间和包含，可以有效地模块化和组织 Thrift IDL 定义，提高代码的可维护性、可读性和复用性，从而更好地管理和开发基于 Thrift 的服务。
3.4 注释与元数据：增强IDL的可读性与可维护性 (Annotations and Metadata: Enhance IDL Readability and Maintainability)
为了提高 Thrift IDL 的可读性和可维护性，Thrift 提供了注释（Comments）和注解（Annotations）机制。注释用于为 IDL 文件添加 human-readable 的说明，注解用于为 IDL 元素添加机器可读的元数据。本节将介绍如何在 Thrift IDL 中使用注释和注解。
3.4.1 注释 (Comments)
注释用于在 IDL 文件中添加说明性文本，帮助开发者理解 IDL 定义的含义。Thrift IDL 支持两种类型的注释：
① 单行注释 (Single-line Comments)：
使用双斜线 // 开始单行注释，注释内容从 // 开始到行尾。
代码示例 3-13：单行注释示例
1
// 这是一个用户服务
2
service UserService {
3
// 获取用户信息
4
UserProfile getUser(1: i32 userId)
5
}
② 多行注释 (Multi-line Comments)：
使用 /* 开始多行注释，使用 */ 结束多行注释。多行注释可以跨越多行。
代码示例 3-14：多行注释示例
1
/*
2
* 这是一个复杂的服务，
3
* 提供了多种用户管理功能。
4
*/
5
service ComplexUserService {
6
/**
7
* 获取用户详细信息
8
* 包括用户基本信息和扩展信息。
9
*/
10
UserDetail getUserDetail(1: i32 userId)
11
}
多行注释通常用于添加更详细的说明，例如服务或方法的用途、参数的含义、返回值等。
③ 文档注释 (Documentation Comments)：
虽然 Thrift IDL 没有明确的文档注释规范，但通常可以使用多行注释 /* ... */ 或特殊格式的单行注释（例如以 /// 开头）来编写文档注释。一些 Thrift 工具链可能会解析这些注释，并生成文档。在 代码示例 3-14 中，/** ... */ 形式的注释可以被视为一种文档注释，用于描述 getUserDetail 方法的功能。
3.4.2 注解 (Annotations)
注解（Annotations）是一种结构化的元数据，可以附加到 IDL 文件的各种元素上，例如服务、方法、结构体、字段、枚举等。注解可以用于提供额外的信息，例如版本信息、作者信息、代码生成指令、运行时行为提示等。
① 注解语法：
注解使用 ( 和 ) 包围，放在被注解的 IDL 元素之后。一个 IDL 元素可以有多个注解。注解由注解名称和一个可选的值组成。值可以是字符串、数字、布尔值、列表或映射。
代码示例 3-15：注解示例
1
struct UserProfile (
2
version = "1.0",
3
author = "John Doe"
4
) {
5
1: required i32 user_id (doc = "用户ID"),
6
2: string user_name (deprecated = true)
7
}
8
9
service UserService (stability = "stable") {
10
i32 getUserCount () (timeout = 1000)
11
}
12
13
enum Status (category = "common") {
14
OK,
15
ERROR
16
}
在上述示例中：
⚝ UserProfile 结构体使用了 version 和 author 注解，提供了版本和作者信息。
⚝ user_id 字段使用了 doc 注解，提供了字段的文档说明。
⚝ user_name 字段使用了 deprecated 注解，标记为已废弃。
⚝ UserService 服务使用了 stability 注解，表示服务的稳定性级别。
⚝ getUserCount 方法使用了 timeout 注解，指定了方法的超时时间。
⚝ Status 枚举使用了 category 注解，表示枚举的类别。
② 注解的用途：
⚝ 文档生成：注解可以用于生成文档，例如字段的 doc 注解可以用于生成字段的说明文档。
⚝ 代码生成：注解可以作为代码生成器的指令，影响代码的生成行为。例如，可以使用注解指定字段的序列化方式、方法的超时时间、服务的版本号等。
⚝ 运行时行为：一些 Thrift 框架或中间件可能会读取注解信息，并根据注解配置运行时行为。例如，可以使用注解配置服务的负载均衡策略、熔断策略、监控指标等。
⚝ 元数据管理：注解可以作为 IDL 元素的元数据，用于管理和维护 IDL 定义。例如，可以使用注解记录 IDL 元素的版本信息、作者信息、变更历史等。
③ 自定义注解：
Thrift IDL 本身没有预定义的注解类型，注解名称和值的含义由工具链和框架解释。开发者可以根据需要自定义注解，并在代码生成和运行时环境中处理这些注解。
3.4.3 注释与注解的最佳实践
① 充分使用注释：为服务、方法、结构体、字段、枚举等添加清晰的注释，说明其用途、功能和注意事项，提高 IDL 的可读性。
② 合理使用注解：根据项目需求，选择合适的注解来增强 IDL 的功能和可维护性。避免过度使用注解，以免降低 IDL 的简洁性。
③ 保持注释和注解的更新：当 IDL 定义发生变更时，及时更新相关的注释和注解，保持文档和元数据与代码的一致性。
④ 约定注解规范：在团队内部约定注解的使用规范，例如常用的注解名称、值的类型和含义，提高团队协作效率。
通过有效使用注释和注解，可以显著提高 Thrift IDL 的可读性和可维护性，为基于 Thrift 的服务开发和维护带来便利。
3.5 异常处理：定义与使用Thrift异常 (Exception Handling: Defining and Using Thrift Exceptions)
在分布式系统中，错误处理是至关重要的。Thrift IDL 提供了异常（Exception）机制，用于定义和声明服务方法可能抛出的异常。客户端可以捕获这些异常，并根据异常类型进行相应的处理。本节将介绍如何在 Thrift IDL 中定义和使用异常。
3.5.1 异常 (Exception) 定义
异常（Exception）在 Thrift IDL 中类似于结构体（Struct），用于定义错误信息的数据结构。异常定义使用关键字 exception，语法结构与结构体类似。
① 异常定义语法：
使用关键字 exception 开始异常定义，后跟异常名称，并在花括号 {} 内定义异常的字段。每个字段定义包括一个唯一的字段ID（正整数）、字段类型和字段名称。
代码示例 3-16：异常定义示例
1
exception UserNotFoundException {
2
1: required i32 user_id;
3
2: optional string message = "User not found";
4
}
5
6
exception InvalidArgumentException {
7
1: required string message;
8
2: optional string argument_name;
9
}
10
11
exception DatabaseError {
12
1: optional string error_code;
13
2: optional string error_message;
14
}
在上述示例中，我们定义了三个异常：UserNotFoundException、InvalidArgumentException 和 DatabaseError。每个异常都包含一些字段，用于携带异常的详细信息。例如，UserNotFoundException 包含 user_id 字段，表示未找到的用户ID，以及可选的 message 字段，提供默认的错误消息。
② 异常的字段规则：
与结构体类似，异常的字段也可以使用 required 和 optional 规则。通常，异常的必要信息（例如错误码、错误ID）应定义为 required 字段，而一些辅助信息（例如错误消息、详细描述）可以定义为 optional 字段。
3.5.2 声明方法抛出异常
在服务方法定义中，可以使用 throws 关键字声明方法可能抛出的异常列表。throws 关键字后跟一个括号 ()，括号内列出方法可能抛出的异常，多个异常之间用逗号 , 分隔。每个异常声明包括一个唯一的字段ID（正整数）和异常类型。
① throws 声明语法：
在方法定义的参数列表之后，返回值类型之前，使用 throws 关键字声明异常。
1
<返回值类型> <方法名称>(<参数列表>) throws (<异常列表>)
代码示例 3-17：声明方法抛出异常示例
1
service UserService {
2
// 根据用户ID获取用户信息，可能抛出 UserNotFoundException 或 DatabaseError
3
UserProfile getUser(1: i32 userId) throws (1: UserNotFoundException notFound, 2: DatabaseError dbError),
4
5
// 创建用户，可能抛出 InvalidArgumentException
6
i32 createUser(1: UserProfile userProfile) throws (1: InvalidArgumentException invalidArg)
7
}
在 UserService 服务中：
⚝ getUser 方法声明了可能抛出 UserNotFoundException 和 DatabaseError 两种异常。UserNotFoundException 的字段ID 为 1，别名为 notFound；DatabaseError 的字段ID 为 2，别名为 dbError。别名是可选的，可以省略。
⚝ createUser 方法声明了可能抛出 InvalidArgumentException 异常，字段ID 为 1，别名为 invalidArg。
② 异常字段ID的作用：
在 throws 声明中，异常的字段ID 用于在序列化和反序列化异常时标识异常类型。与方法参数和结构体字段的字段ID 作用类似，保证协议的兼容性。
3.5.3 服务端抛出异常与客户端捕获异常
在服务端实现 Thrift 服务时，当方法执行过程中发生错误时，可以抛出在 IDL 中声明的异常。Thrift 框架会将异常序列化并通过网络传输给客户端。客户端在调用 Thrift 方法时，可以捕获服务端抛出的异常，并根据异常类型进行处理。
① 服务端抛出异常：
在服务端代码中，可以使用特定语言的异常抛出机制来抛出 Thrift 异常。例如，在 C++ 中，可以使用 throw 关键字抛出异常对象；在 Java 中，可以使用 throw new ...Exception() 抛出异常对象。
② 客户端捕获异常：
在客户端代码中，可以像处理本地异常一样捕获 Thrift 异常。不同的编程语言有不同的异常处理机制，例如 C++ 的 try-catch 块，Java 的 try-catch 块，Python 的 try-except 块等。
代码示例 3-18：C++ 服务端抛出异常示例
1
UserProfile UserServiceHandler::getUser(int32_t userId) {
2
if (userId <= 0) {
3
InvalidArgumentException invalidArg;
4
invalidArg.message = "Invalid userId";
5
invalidArg.argument_name = "userId";
6
throw invalidArg;
7
}
8
// ... 业务逻辑 ...
9
if (user == nullptr) {
10
UserNotFoundException notFound;
11
notFound.user_id = userId;
12
throw notFound;
13
}
14
return *user;
15
}
代码示例 3-19：Java 客户端捕获异常示例
1
try {
2
UserProfile user = client.getUser(userId);
3
// 处理用户信息
4
} catch (UserNotFoundException notFound) {
5
System.out.println("User not found: userId=" + notFound.user_id);
6
} catch (DatabaseError dbError) {
7
System.err.println("Database error: " + dbError.error_message);
8
} catch (TException e) {
9
System.err.println("Thrift exception: " + e.getMessage());
10
}
在客户端代码中，需要捕获可能抛出的 Thrift 异常类型，并进行相应的错误处理。同时，还需要捕获通用的 TException 或其语言特定的基类异常，以处理 Thrift 框架本身的异常。
3.5.4 未声明异常 (Undeclared Exceptions)
如果服务端方法抛出了在 IDL 中未声明的异常，Thrift 框架通常会将其转换为通用的异常类型（例如 TApplicationException），并返回给客户端。客户端只能捕获到通用的异常，无法获取到原始异常的详细信息。因此，建议在 IDL 中完整地声明服务方法可能抛出的所有业务异常，以便客户端能够正确处理各种错误情况。
3.5.5 异常使用的最佳实践
① 明确定义业务异常：根据业务场景，定义清晰、具体的业务异常类型，例如 UserNotFoundException、OrderCreationFailedException、PaymentFailedException 等。
② 在 IDL 中声明异常：在服务方法定义中，使用 throws 关键字声明方法可能抛出的所有业务异常。
③ 服务端正确抛出异常：在服务端代码中，当发生业务错误时，抛出相应的 Thrift 异常，并填充异常的字段信息。
④ 客户端妥善处理异常：在客户端代码中，捕获可能抛出的 Thrift 异常，并根据异常类型进行相应的错误处理，例如重试、降级、错误提示等。
⑤ 避免过度使用异常：异常处理应该用于处理真正的异常情况，而不是作为控制流的手段。对于可预期的错误情况，可以考虑使用返回值或状态码来表示。
通过合理使用 Thrift 异常机制，可以提高分布式系统的健壮性和可靠性，更好地处理各种错误情况，并为客户端提供清晰的错误反馈。
3.6 类型别名与常量：简化IDL定义 (Type Aliases and Constants: Simplify IDL Definitions)
为了提高 Thrift IDL 的可读性和可维护性，并简化复杂定义，Thrift 提供了类型别名（Type Aliases）和常量（Constants）机制。类型别名允许为已有的类型定义新的名称，常量允许定义具名的固定值。本节将详细介绍类型别名和常量的使用。
3.6.1 类型别名 (Type Aliases)
类型别名（Type Aliases）允许为现有的数据类型定义一个新的名称。类型别名可以提高 IDL 的可读性，尤其是在处理复杂类型或具有特定语义的类型时。
① 类型别名定义语法：
使用关键字 typedef 开始类型别名定义，后跟原始类型和新的类型名称。
1
typedef <原始类型> <类型别名>
代码示例 3-20：类型别名定义示例
1
typedef i64 Timestamp // 时间戳，Unix 时间戳，单位秒
2
typedef string EmailAddress // 邮箱地址
3
typedef list<UserProfile> UserProfileList // 用户列表
4
typedef map<string, string> ConfigurationMap // 配置映射
在上述示例中，我们为 i64 定义了类型别名 Timestamp，为 string 定义了类型别名 EmailAddress，为 list<UserProfile> 定义了类型别名 UserProfileList，为 map<string, string> 定义了类型别名 ConfigurationMap。
② 类型别名的用途：
⚝ 提高可读性：类型别名可以使 IDL 定义更具语义化，提高代码的可读性。例如，使用 Timestamp 代替 i64 可以更清晰地表达字段的含义。
⚝ 简化复杂类型：对于复杂的类型定义，可以使用类型别名简化其表示。例如，UserProfileList 类型别名简化了 list<UserProfile> 的书写。
⚝ 增强可维护性：当需要修改类型定义时，如果使用了类型别名，只需要修改类型别名的定义，而不需要修改所有使用该类型的地方，提高代码的可维护性。
③ 类型别名的使用：
定义类型别名后，可以在 IDL 文件中像使用普通类型一样使用类型别名。
代码示例 3-21：使用类型别名示例
1
typedef i64 Timestamp
2
typedef string EmailAddress
3
4
struct UserProfile {
5
1: required i32 user_id,
6
2: required string user_name,
7
3: optional EmailAddress email, // 使用类型别名 EmailAddress
8
4: optional Timestamp create_time // 使用类型别名 Timestamp
9
}
10
11
service UserService {
12
// ...
13
UserProfile getUserByEmail(1: EmailAddress email) // 方法参数中使用类型别名
14
}
在 UserProfile 结构体和 UserService 服务中，我们使用了类型别名 EmailAddress 和 Timestamp，使 IDL 定义更加清晰易懂。
3.6.2 常量 (Constants)
常量（Constants）允许在 Thrift IDL 中定义具名的固定值。常量可以是基本数据类型或枚举类型。常量可以提高代码的可读性和可维护性，避免使用 Magic Number。
① 常量定义语法：
使用关键字 const 开始常量定义，后跟常量类型、常量名称和常量值。
1
const <常量类型> <常量名称> = <常量值>
代码示例 3-22：常量定义示例
1
const i32 MAX_CONNECTIONS = 1000 // 最大连接数
2
const string DEFAULT_ENCODING = "UTF-8" // 默认编码
3
const double PI = 3.1415926 // 圆周率
4
const Status DEFAULT_STATUS = Status.OK // 默认状态，假设 Status 是一个枚举类型
在上述示例中，我们定义了 MAX_CONNECTIONS、DEFAULT_ENCODING、PI 和 DEFAULT_STATUS 四个常量，分别表示最大连接数、默认编码、圆周率和默认状态。
② 常量的用途：
⚝ 提高可读性：常量使用具名的标识符代替 Magic Number，提高代码的可读性。例如，使用 MAX_CONNECTIONS 代替数字 1000 可以更清晰地表达常量的含义。
⚝ 增强可维护性：当需要修改常量值时，只需要修改常量定义，而不需要修改所有使用该常量的地方，提高代码的可维护性。
⚝ 配置管理：常量可以用于定义配置参数，例如默认值、最大值、最小值等。
③ 常量的使用：
定义常量后，可以在 IDL 文件中像使用字面量一样使用常量名称。常量可以在结构体字段的默认值、枚举成员的值、方法参数的默认值等地方使用。
代码示例 3-23：使用常量示例
1
enum Status {
2
OK = 0,
3
WARNING = 1,
4
ERROR = 2,
5
CRITICAL = 3
6
}
7
8
const Status DEFAULT_STATUS = Status.OK
9
const i32 DEFAULT_RETRY_COUNT = 3
10
11
struct RequestContext {
12
1: optional Status status = DEFAULT_STATUS, // 使用常量作为默认值
13
2: optional i32 retry_count = DEFAULT_RETRY_COUNT
14
}
15
16
service TaskService {
17
// ...
18
void executeTask(1: RequestContext context)
19
}
在 RequestContext 结构体中，我们使用了常量 DEFAULT_STATUS 和 DEFAULT_RETRY_COUNT 作为字段的默认值。
3.6.3 类型别名与常量的最佳实践
① 合理使用类型别名：为具有特定语义或复杂的数据类型定义类型别名，提高 IDL 的可读性和可维护性。避免过度使用类型别名，以免增加代码的复杂性。
② 充分利用常量：为 Magic Number 定义常量，提高代码的可读性和可维护性。将配置参数定义为常量，方便统一管理和修改。
③ 保持命名一致性：类型别名和常量的命名应遵循一致的命名约定，提高代码的可读性。
④ 添加注释说明：为类型别名和常量添加注释，说明其用途和含义，提高代码的可理解性。
通过合理使用类型别名和常量，可以有效地简化 Thrift IDL 定义，提高代码的可读性、可维护性和可复用性，从而更好地管理和开发基于 Thrift 的服务。
END_OF_CHAPTER
4. chapter 4： Thrift协议与传输层：通信的基石 (Thrift Protocols and Transports: Cornerstones of Communication)
4.1 协议 (Protocols)
在Thrift中，协议 (Protocols) 负责定义数据在网络中传输时的编码格式。它决定了数据如何被序列化成字节流，以及如何从字节流反序列化回原始数据结构。选择合适的协议对于性能、带宽消耗以及跨语言兼容性至关重要。Thrift支持多种协议，每种协议都有其特定的优势和适用场景。
4.1.1 Binary Protocol (二进制协议)
Binary Protocol (二进制协议)，顾名思义，是一种将数据以二进制格式进行编码的协议。它是Thrift中最基础、也是最常用的协议之一。
特点与优势 (Features and Advantages):
① 高效性 (Efficiency)：二进制协议以紧凑的二进制格式编码数据，减少了数据在网络传输中的大小，从而提高了传输效率和速度。相比于文本协议，二进制协议解析速度更快，CPU消耗更低。
② 紧凑性 (Compactness)：二进制格式避免了文本协议中大量的分隔符和元数据，使得数据包更加紧凑，节省了带宽资源。
③ 跨语言兼容性 (Cross-Language Compatibility)：由于二进制格式的通用性，Binary Protocol在各种编程语言中都有良好的支持，保证了Thrift跨语言通信的能力。
适用场景 (Use Cases):
① 高性能RPC (High-Performance RPC)：对于对性能要求极高的RPC服务，Binary Protocol是首选。其高效的编码和解码能力能够最大限度地减少延迟，提升吞吐量。
② 内部服务通信 (Internal Service Communication)：在服务内部，网络环境通常较为稳定，带宽资源相对充足，但对性能要求较高。Binary Protocol能够满足这类场景的需求。
示例 (Example):
假设我们有一个Thrift结构体 User：
1
struct User {
2
1: i32 id;
3
2: string name;
4
}
使用Binary Protocol序列化一个 User 对象，其 id 为 123，name 为 "Alice"，得到的二进制数据将非常紧凑，只包含必要的字段类型、长度和值信息。
局限性 (Limitations):
① 可读性差 (Poor Readability)：二进制数据对于人类来说难以直接阅读和调试。当需要人工分析网络数据包时，Binary Protocol不如文本协议方便。
② 调试难度较高 (Higher Debugging Difficulty)：由于其二进制格式，在网络抓包分析或日志记录时，Binary Protocol的数据不如文本协议直观，调试难度相对较高。需要借助专门的工具进行解析。
4.1.2 Compact Protocol (压缩协议)
Compact Protocol (压缩协议) 是Thrift为了进一步提升性能和减少带宽占用而设计的一种二进制协议。它在Binary Protocol的基础上进行了优化，采用了更加紧凑的编码方式。
特点与优势 (Features and Advantages):
① 极致压缩 (Extreme Compression)：Compact Protocol采用了Varint编码、字段ID压缩等技术，进一步减少了数据的大小。对于数值类型和重复字段，压缩效果尤为明显。
② 高性能 (High Performance)：虽然压缩过程会增加一定的计算开销，但由于数据量的显著减少，网络传输时间缩短，总体性能通常优于Binary Protocol，尤其是在网络带宽受限的情况下。
③ 仍然保持跨语言兼容性 (Still Maintain Cross-Language Compatibility)：Compact Protocol仍然是一种二进制协议，保持了良好的跨语言兼容性。
适用场景 (Use Cases):
① 带宽受限环境 (Bandwidth-Constrained Environments)：在移动网络、低带宽网络或需要传输大量数据的场景下，Compact Protocol能够显著减少带宽消耗，提升应用性能。
② 对性能和带宽都敏感的场景 (Scenarios Sensitive to Both Performance and Bandwidth)：对于既要求高性能，又希望节省带宽的应用，Compact Protocol是理想的选择。例如，大规模分布式系统中节点间的通信。
示例 (Example):
继续使用之前的 User 结构体，使用Compact Protocol序列化相同的 User 对象，得到的二进制数据将比Binary Protocol更小。例如，字段ID会被压缩编码，重复出现的字段类型信息也会被优化。
与Binary Protocol的对比 (Comparison with Binary Protocol):
| 特性 (Feature) | Binary Protocol (二进制协议) | Compact Protocol (压缩协议) |
| ------------------ | ----------------------- | ----------------------- |
| 数据大小 (Data Size) | 较大 | 更小 |
| 性能 (Performance) | 高 | 略高 (带宽受限时更高) |
| CPU消耗 (CPU Usage) | 较低 | 略高 |
| 压缩率 (Compression Ratio) | 低 | 高 |
| 复杂性 (Complexity) | 简单 | 较复杂 |
局限性 (Limitations):
① CPU消耗略高 (Slightly Higher CPU Usage)：压缩和解压缩过程会带来一定的CPU开销，虽然通常可以忽略不计，但在极端高负载情况下可能需要考虑。
② 调试难度依然较高 (Still Higher Debugging Difficulty)：与Binary Protocol类似，Compact Protocol也是二进制协议，可读性差，调试难度较高。
4.1.3 JSON Protocol (JSON协议)
JSON Protocol (JSON协议) 使用 JSON (JavaScript Object Notation) 格式来编码数据。JSON是一种轻量级的数据交换格式，以其良好的可读性和跨语言兼容性而闻名。
特点与优势 (Features and Advantages):
① 优秀的文本可读性 (Excellent Text Readability)：JSON格式采用纯文本表示数据，结构清晰，易于阅读和理解。这使得JSON Protocol在调试、日志记录和人工分析数据时非常方便。
② 广泛的跨语言支持 (Wide Cross-Language Support)：JSON作为一种通用的数据交换格式，几乎所有编程语言都提供了完善的JSON库支持，使得JSON Protocol具有极佳的跨语言兼容性。
③ 易于调试 (Easy Debugging)：由于其文本格式，JSON Protocol的数据可以直接通过文本编辑器或浏览器查看，网络抓包工具也能直接显示JSON内容，大大降低了调试难度。
适用场景 (Use Cases):
① Web前端与后端通信 (Web Frontend and Backend Communication)：JSON是Web开发中最常用的数据交换格式。当Thrift服务需要与Web前端（例如，使用JavaScript客户端）交互时，JSON Protocol是天然的选择。
② API接口 (API Interfaces)：对于需要对外提供API接口的服务，JSON Protocol的良好可读性和通用性使其成为理想的协议。
③ 调试与开发阶段 (Debugging and Development Phase)：在开发和调试阶段，JSON Protocol的易读性可以显著提高开发效率，方便问题排查。
示例 (Example):
对于之前的 User 结构体，使用JSON Protocol序列化相同的 User 对象，得到的JSON字符串如下：
1
{"id":123,"name":"Alice"}
这种格式清晰易懂，方便人工阅读。
局限性 (Limitations):
① 性能较低 (Lower Performance)：相比于二进制协议，JSON Protocol的性能较低。文本格式解析和生成需要更多的CPU资源，且数据量通常较大。
② 数据量较大 (Larger Data Size)：JSON文本格式包含大量的分隔符（如花括号、逗号、引号）和键名，导致数据包大小显著增加，浪费带宽。
③ 不适合高性能场景 (Not Suitable for High-Performance Scenarios)：对于对性能要求极高的场景，JSON Protocol通常不是最佳选择。
与Binary Protocol和Compact Protocol的对比 (Comparison with Binary and Compact Protocols):
| 特性 (Feature) | Binary Protocol (二进制协议) | Compact Protocol (压缩协议) | JSON Protocol (JSON协议) |
| ------------------ | ----------------------- | ----------------------- | -------------------- |
| 数据大小 (Data Size) | 最小 | 更小 | 最大 |
| 性能 (Performance) | 最高 | 较高 | 最低 |
| CPU消耗 (CPU Usage) | 最低 | 略高 | 最高 |
| 可读性 (Readability) | 最差 | 差 | 最好 |
| 调试性 (Debuggability) | 差 | 较差 | 最好 |
| 跨语言性 (Cross-Language) | 良好 | 良好 | 极佳 |
4.2 传输层 (Transports)
传输层 (Transports) 在Thrift中负责实际的网络数据传输。它定义了数据如何通过网络介质（如TCP套接字、HTTP）进行发送和接收。传输层位于协议层之下，为协议层提供可靠的数据传输通道。Thrift提供了多种传输层实现，以适应不同的网络环境和应用需求。
4.2.1 TServerSocket与TSocket：TCP套接字传输 (TServerSocket and TSocket: TCP Socket Transport)
TCP套接字传输 (TCP Socket Transport) 是Thrift最基础也是最常用的传输方式。它基于 TCP (Transmission Control Protocol) 协议，提供了可靠的、面向连接的数据传输服务。
⚝ TSocket (客户端套接字)：TSocket 类用于客户端，负责与Thrift服务端建立TCP连接，并发送和接收数据。客户端通过 TSocket 连接到服务端的IP地址和端口。
⚝ TServerSocket (服务端套接字)：TServerSocket 类用于服务端，负责监听指定的端口，接受客户端的TCP连接请求，并为每个连接创建一个新的套接字进行数据交互。
特点与优势 (Features and Advantages):
① 可靠传输 (Reliable Transmission)：TCP协议保证了数据的可靠传输，提供了数据包的顺序性、无丢失和无重复。
② 广泛适用性 (Wide Applicability)：TCP套接字是网络编程的基础，几乎所有操作系统和编程语言都提供了完善的支持。
③ 成熟稳定 (Mature and Stable)：TCP协议经过多年的发展和应用，已经非常成熟和稳定。
适用场景 (Use Cases):
① 大多数RPC场景 (Most RPC Scenarios)：对于大多数RPC服务，TCP套接字传输都是一个可靠且高效的选择。
② 长连接服务 (Long-Connection Services)：TCP连接是面向连接的，适合需要保持长连接的服务，例如，需要频繁交互的应用。
示例 (Example):
服务端代码片段（C++）：
1
#include <thrift/transport/TServerSocket.h>
2
#include <thrift/transport/TTransportUtils.h>
3
4
using namespace apache::thrift::transport;
5
6
int main() {
7
boost::shared_ptr<TServerSocket> serverSocket(new TServerSocket(9090)); // 监听9090端口
8
boost::shared_ptr<TBufferedTransportFactory> transportFactory(new TBufferedTransportFactory());
9
// ... (创建处理器、协议工厂等)
10
TServer server(processor, serverSocket, transportFactory, protocolFactory);
11
server.serve();
12
return 0;
13
}
客户端代码片段（C++）：
1
#include <thrift/transport/TSocket.h>
2
#include <thrift/transport/TTransportUtils.h>
3
4
using namespace apache::thrift::transport;
5
6
int main() {
7
boost::shared_ptr<TSocket> socket(new TSocket("localhost", 9090)); // 连接到localhost:9090
8
boost::shared_ptr<TBufferedTransport> transport(new TBufferedTransport(socket));
9
transport->open();
10
// ... (创建协议、客户端等)
11
client.someFunction();
12
transport->close();
13
return 0;
14
}
局限性 (Limitations):
① 开销相对较大 (Relatively High Overhead)：TCP协议为了保证可靠性，引入了三次握手、滑动窗口、拥塞控制等机制，这些机制带来了一定的开销。
② 不适用于某些特殊场景 (Not Suitable for Some Special Scenarios)：例如，对于UDP协议更适合的场景（如实时音视频传输），TCP套接字传输可能不是最佳选择。
4.2.2 TBufferedTransport：缓冲传输 (TBufferedTransport: Buffered Transport)
TBufferedTransport (缓冲传输) 是对底层传输层（通常是 TSocket）的封装，它在内存中维护一个缓冲区，用于批量读取和写入数据。
工作原理 (Working Principle):
⚝ 写入缓冲 (Write Buffer)：当客户端或服务端需要发送数据时，数据首先被写入到缓冲区中。当缓冲区满或者显式调用 flush() 方法时，缓冲区中的数据才会被一次性发送到网络。
⚝ 读取缓冲 (Read Buffer)：当从网络接收到数据时，数据首先被读取到缓冲区中。上层应用从缓冲区中读取数据，而不是直接从网络读取。
特点与优势 (Features and Advantages):
① 提高小数据包传输效率 (Improve Efficiency of Small Packet Transmission)：对于频繁发送小数据包的应用，缓冲传输可以将多个小数据包合并成一个大的数据包发送，减少了网络IO次数，提高了传输效率。
② 减少系统调用 (Reduce System Calls)：批量读写操作可以减少系统调用的次数，降低CPU开销。
③ 简化上层应用编程 (Simplify Upper-Layer Application Programming)：上层应用无需关心底层数据包的大小和发送频率，只需简单地写入和读取数据即可。
适用场景 (Use Cases):
① 小数据包频繁传输的场景 (Scenarios with Frequent Transmission of Small Packets)：例如，某些控制指令频繁发送的系统。
② 需要优化网络IO性能的场景 (Scenarios Requiring Optimization of Network IO Performance)：在网络IO成为瓶颈的应用中，缓冲传输可以有效提升性能。
示例 (Example):
在之前的 TSocket 客户端和服务端示例中，我们已经使用了 TBufferedTransport：
1
boost::shared_ptr<TBufferedTransport> transport(new TBufferedTransport(socket)); // 使用 TBufferedTransport 封装 TSocket
TBufferedTransport 通常与 TSocket 结合使用，作为默认的传输层封装。
局限性 (Limitations):
① 引入延迟 (Introduce Latency)：由于数据需要先写入缓冲区，等待缓冲区满或显式刷新才能发送，因此缓冲传输会引入一定的延迟。对于对延迟敏感的应用，可能需要调整缓冲区大小或谨慎使用。
② 内存占用 (Memory Usage)：缓冲传输需要在内存中维护缓冲区，会占用一定的内存空间。
4.2.3 TFramedTransport：分帧传输 (TFramedTransport: Framed Transport)
TFramedTransport (分帧传输) 也是对底层传输层的封装，它在发送的数据包前添加一个帧头 (frame header)，用于标识数据包的长度。
工作原理 (Working Principle):
⚝ 帧头添加 (Frame Header Addition)：在发送数据时，TFramedTransport 会在数据包前添加一个固定长度的帧头，帧头中包含了后续数据包的长度信息。
⚝ 按帧读取 (Frame-by-Frame Reading)：接收端根据帧头中的长度信息，从网络流中读取完整的数据包。
特点与优势 (Features and Advantages):
① 解决TCP粘包问题 (Solve TCP Packet粘包 Problem)：TCP是面向流的协议，数据在传输过程中可能会发生粘包和拆包。TFramedTransport 通过帧头明确了每个数据包的边界，接收端可以准确地识别和解析完整的数据包。
② 支持非阻塞IO (Support Non-Blocking IO)：分帧传输使得接收端可以知道每个数据包的完整长度，从而可以实现非阻塞的读取操作。当网络数据不足以构成一个完整的数据包时，接收端可以等待数据到达，而不会阻塞整个线程。
③ 简化复杂数据包处理 (Simplify Complex Packet Handling)：对于需要处理变长数据包的应用，分帧传输简化了数据包的解析和处理逻辑。
适用场景 (Use Cases):
① 需要处理变长数据包的场景 (Scenarios Requiring Handling of Variable-Length Packets)：例如，传输文件、图片等大数据块的应用。
② 需要支持非阻塞IO的场景 (Scenarios Requiring Support for Non-Blocking IO)：例如，高并发的网络应用。
示例 (Example):
使用 TFramedTransport 替代 TBufferedTransport：
1
boost::shared_ptr<TFramedTransportFactory> transportFactory(new TFramedTransportFactory()); // 服务端使用 TFramedTransportFactory
2
boost::shared_ptr<TFramedTransport> transport(new TFramedTransport(socket)); // 客户端使用 TFramedTransport
服务端和客户端都需要使用 TFramedTransport 或 TFramedTransportFactory 来确保分帧传输的正常工作。
局限性 (Limitations):
① 增加帧头开销 (Increase Frame Header Overhead)：每个数据包都需要添加帧头，会增加一定的网络传输开销，尤其是在传输大量小数据包时。
② 实现略微复杂 (Slightly More Complex Implementation)：相比于简单的缓冲传输，分帧传输的实现稍微复杂一些。
4.2.4 THttpClient与THttpServer：HTTP传输 (THttpClient and THttpServer: HTTP Transport)
HTTP传输 (HTTP Transport) 允许Thrift服务通过 HTTP (Hypertext Transfer Protocol) 协议进行通信。Thrift提供了 THttpClient 和 THttpServer 类来实现HTTP传输。
⚝ THttpClient (HTTP客户端)：THttpClient 类用于客户端，它将Thrift请求封装成HTTP请求（通常是POST请求），发送到Thrift服务端，并接收HTTP响应。
⚝ THttpServer (HTTP服务端)：THttpServer 类用于服务端，它作为一个HTTP服务器，接收HTTP请求，解析Thrift请求，调用相应的服务处理函数，并将Thrift响应封装成HTTP响应返回。
特点与优势 (Features and Advantages):
① 穿透防火墙 (Firewall Traversal)：HTTP协议是Web应用的标准协议，通常防火墙会允许HTTP流量通过。使用HTTP传输可以更容易地穿透防火墙，实现跨网络通信。
② 与Web基础设施兼容 (Compatibility with Web Infrastructure)：HTTP传输可以与现有的Web基础设施（如Web服务器、负载均衡器、反向代理）无缝集成。
③ 易于集成 (Easy Integration)：对于已经使用HTTP协议的系统，集成Thrift HTTP服务更加方便。
适用场景 (Use Cases):
① 需要穿透防火墙的场景 (Scenarios Requiring Firewall Traversal)：例如，跨公网的服务调用。
② 需要与Web应用集成的场景 (Scenarios Requiring Integration with Web Applications)：例如，将Thrift服务作为Web应用的后端服务。
③ 利用现有HTTP基础设施的场景 (Scenarios Utilizing Existing HTTP Infrastructure)：例如，利用现有的HTTP负载均衡器来管理Thrift服务。
示例 (Example):
客户端代码片段（C++）：
1
#include <thrift/transport/THttpClient.h>
2
#include <thrift/transport/TTransportUtils.h>
3
4
using namespace apache::thrift::transport;
5
6
int main() {
7
boost::shared_ptr<THttpClient> transport(new THttpClient("localhost", 8080, "/thrift")); // 连接到 http://localhost:8080/thrift
8
transport->open();
9
// ... (创建协议、客户端等)
10
client.someFunction();
11
transport->close();
12
return 0;
13
}
服务端通常需要与Web服务器（如Apache、Nginx）结合使用，将Thrift请求转发到 THttpServer 处理。
局限性 (Limitations):
① 性能较低 (Lower Performance)：HTTP协议是文本协议，且协议头冗余信息较多，性能不如直接使用TCP套接字传输。
② 开销较大 (Higher Overhead)：HTTP协议引入了额外的HTTP头部信息，增加了网络传输开销。
③ 不适合高性能RPC (Not Suitable for High-Performance RPC)：对于对性能要求极高的RPC服务，HTTP传输通常不是最佳选择。
4.3 协议与传输层的选择：性能与场景考量 (Protocol and Transport Selection: Performance and Scenario Considerations)
选择合适的 协议 (Protocol) 和 传输层 (Transport) 对于Thrift应用的性能、可靠性和兼容性至关重要。以下是一些选择的考量因素和建议：
协议选择 (Protocol Selection):
① 性能需求 (Performance Requirements)：
▮▮▮▮⚝ 高性能：Binary Protocol 或 Compact Protocol 是首选。Compact Protocol 在带宽受限时更具优势。
▮▮▮▮⚝ 中等性能：JSON Protocol 适用于对性能要求不高，但对可读性和调试性有要求的场景。
② 带宽限制 (Bandwidth Constraints)：
▮▮▮▮⚝ 带宽受限：Compact Protocol 是最佳选择，其高压缩率可以显著减少带宽消耗。
▮▮▮▮⚝ 带宽充足：Binary Protocol 或 JSON Protocol 都可以考虑，根据其他需求选择。
③ 可读性和调试性 (Readability and Debuggability)：
▮▮▮▮⚝ 高可读性：JSON Protocol 是唯一选择，其文本格式易于阅读和调试。
▮▮▮▮⚝ 低可读性：Binary Protocol 和 Compact Protocol 都是二进制协议，可读性较差。
④ 跨语言兼容性 (Cross-Language Compatibility)：
▮▮▮▮⚝ 所有Thrift协议（Binary, Compact, JSON）都具有良好的跨语言兼容性。
⑤ 应用场景 (Application Scenarios)：
▮▮▮▮⚝ 内部RPC服务：Binary Protocol 或 Compact Protocol 通常是最佳选择，追求高性能和低延迟。
▮▮▮▮⚝ Web前端通信：JSON Protocol 是首选，方便与JavaScript客户端交互。
▮▮▮▮⚝ API接口：JSON Protocol 或 Binary Protocol 可以根据API的性质和受众选择。
传输层选择 (Transport Selection):
① 可靠性需求 (Reliability Requirements)：
▮▮▮▮⚝ 可靠传输：TSocket (TCP套接字) 是默认且可靠的选择。
▮▮▮▮⚝ 非可靠传输：Thrift本身不直接支持UDP等非可靠传输，但可以通过自定义传输层实现。
② 性能需求 (Performance Requirements)：
▮▮▮▮⚝ 小数据包优化：TBufferedTransport 可以提高小数据包传输效率。
▮▮▮▮⚝ 大数据包处理：TFramedTransport 可以解决TCP粘包问题，支持非阻塞IO。
▮▮▮▮⚝ HTTP穿透：THttpClient 和 THttpServer 适用于需要穿透防火墙的场景，但性能较低。
③ 网络环境 (Network Environment)：
▮▮▮▮⚝ 局域网：TSocket 或 TBufferedTransport 通常足够。
▮▮▮▮⚝ 广域网：TFramedTransport 或 THttpClient 可以根据具体情况选择。
▮▮▮▮⚝ 防火墙限制：THttpClient 和 THttpServer 可以穿透防火墙。
④ 系统集成 (System Integration)：
▮▮▮▮⚝ Web系统集成：THttpClient 和 THttpServer 可以方便地与Web系统集成。
▮▮▮▮⚝ 现有基础设施：根据现有基础设施选择合适的传输层，例如，已有的HTTP负载均衡器可以与 THttpServer 配合使用。
组合建议 (Combination Suggestions):
⚝ 高性能RPC服务：Compact Protocol + TFramedTransport + TSocket (或 TBufferedTransport)。这种组合兼顾了性能、带宽和可靠性。
⚝ Web API：JSON Protocol + THttpClient / THttpServer。这种组合易于与Web前端集成，可读性好。
⚝ 内部服务，带宽敏感：Compact Protocol + TBufferedTransport + TSocket。 侧重于节省带宽。
⚝ 调试阶段：JSON Protocol + TSocket 或 THttpClient。 方便调试和问题排查。
总结 (Summary):
协议和传输层的选择没有绝对的“最佳”方案，需要根据具体的应用场景、性能需求、网络环境和系统集成等因素综合考虑。理解各种协议和传输层的特点和适用场景，才能做出明智的选择，构建高效、可靠的Thrift应用。在实际应用中，可以进行性能测试和对比，选择最适合的组合。
END_OF_CHAPTER
5. chapter 5： Thrift代码生成与实践：构建客户端与服务端 (Thrift Code Generation and Practice: Building Clients and Servers)
5.1 Thrift编译器详解：代码生成选项与定制 (Thrift Compiler Deep Dive: Code Generation Options and Customization)
Thrift 编译器 thrift 是 Thrift 工具链的核心组件，它的主要职责是将使用 Thrift 接口定义语言（Interface Definition Language, IDL）编写的 .thrift 文件，转换成特定编程语言的代码。这些生成的代码包括数据结构定义、客户端桩代码（client stub）、服务端骨架代码（server skeleton）等，极大地简化了跨语言、跨平台分布式系统的开发流程。本节将深入探讨 Thrift 编译器的各种选项和定制方法，帮助读者充分利用 Thrift 编译器的强大功能。
Thrift 编译器的基本用法
Thrift 编译器的基本用法非常简单，通常的命令格式如下：
1
thrift [options] <input file>
其中，<input file> 是指你的 .thrift 文件路径，[options] 则代表各种编译选项，用于控制代码生成的行为。
常用的代码生成选项
Thrift 编译器支持多种目标语言的代码生成，通过 -gen <language> 选项指定。以下是一些常用的目标语言选项：
① c++：生成 C++ 代码。这是最常用的选项之一，尤其是在高性能服务端开发领域。
② java：生成 Java 代码。适用于 Java 平台的服务端和客户端开发。
③ py 或 python：生成 Python 代码。方便快捷地构建 Python 服务和客户端。
④ go：生成 Go 代码。适用于构建现代云原生应用。
⑤ js 或 javascript：生成 JavaScript 代码。用于 Web 前端或 Node.js 服务。
⑥ php：生成 PHP 代码。用于构建 PHP 服务。
⑦ csharp：生成 C# 代码。适用于 .NET 平台开发。
例如，要为 service.thrift 文件生成 C++ 代码，可以使用以下命令：
1
thrift -gen cpp service.thrift
执行上述命令后，Thrift 编译器会在当前目录下创建一个名为 gen-cpp 的文件夹，并将生成的 C++ 代码放置其中。
C++ 代码生成选项详解
对于 C++ 代码生成，Thrift 编译器提供了丰富的选项来定制生成的代码，以满足不同的需求。以下是一些常用的 C++ 代码生成选项：
① namespace：指定生成的 C++ 代码的命名空间。默认情况下，Thrift 会使用 IDL 文件中定义的命名空间。可以使用 --gen cpp:namespace=<namespace_name> 选项来覆盖默认命名空间。例如：
1
thrift --gen cpp:namespace=my_company::my_service service.thrift
② include_prefix：指定生成的头文件包含路径前缀。当你的项目有复杂的目录结构时，可以使用 --gen cpp:include_prefix=<prefix> 选项来指定头文件的包含路径前缀，避免手动修改 #include 语句。例如：
1
thrift --gen cpp:include_prefix=path/to/include/ service.thrift
③ templates：指定自定义的代码生成模板。Thrift 允许使用自定义的模板来生成代码，这为高级用户提供了极大的灵活性。可以使用 --gen cpp:templates=<path_to_templates> 选项来指定模板路径。
④ dense：生成更紧凑的代码。使用 --gen cpp:dense 选项可以生成更紧凑的 C++ 代码，可能会牺牲一些可读性，但可以减小代码体积。
⑤ utf8strings：使用 UTF-8 编码处理字符串。默认情况下，Thrift C++ 代码使用标准字符串类型 std::string，如果需要处理 UTF-8 编码的字符串，可以使用 --gen cpp:utf8strings 选项。
⑥ no_client_completion：禁用客户端代码的 Future 完成回调。默认情况下，Thrift C++ 客户端代码会生成基于 Future 的异步接口，并提供完成回调机制。使用 --gen cpp:no_client_completion 选项可以禁用客户端代码的 Future 完成回调。
⑦ protocol=<protocol_name>：指定默认的协议。可以使用 --gen cpp:protocol=binary 或 --gen cpp:protocol=compact 等选项来指定默认的协议，默认为 binary 协议。
⑧ transport=<transport_name>：指定默认的传输层。可以使用 --gen cpp:transport=buffered 或 --gen cpp:transport=framed 等选项来指定默认的传输层，默认为 buffered 传输层。
代码生成目录结构
默认情况下，Thrift 编译器会在当前目录下创建一个名为 gen-<language> 的文件夹，并将生成的代码放置其中。例如，对于 C++ 代码，会生成 gen-cpp 目录。生成的目录结构通常如下：
1
gen-cpp/
2
├── service_constants.cpp // 常量定义实现文件
3
├── service_constants.h // 常量定义头文件
4
├── service_types.cpp // 类型定义实现文件 (结构体、枚举等)
5
├── service_types.h // 类型定义头文件
6
├── service.cpp // 服务接口实现文件 (骨架代码)
7
└── service.h // 服务接口头文件
其中，service 会被替换成你的 .thrift 文件名（不包含 .thrift 扩展名）。
定制代码生成
除了使用命令行选项，Thrift 还允许通过修改模板文件来深度定制代码生成过程。Thrift 的代码生成器是基于模板引擎实现的，模板文件通常位于 Thrift 源代码的 src/thrift/codegen/templates 目录下。
如果你需要进行更高级的定制，例如修改代码的风格、添加自定义的代码注释、或者生成特定框架的代码，可以考虑修改模板文件。但这需要对 Thrift 代码生成器的内部机制有一定的了解，并且需要谨慎操作，以避免破坏代码生成器的正常功能。
实战案例：定制命名空间与包含路径
假设你的项目命名空间为 com.example.myservice，并且头文件需要放置在 /usr/local/include/my_project 目录下。你可以使用以下命令来生成代码：
1
thrift --gen cpp:namespace=com::example::myservice,include_prefix=/usr/local/include/my_project/ service.thrift
这样生成的 C++ 代码，其命名空间将会是 com::example::myservice，并且生成的头文件中的 #include 语句将会使用 /usr/local/include/my_project/ 作为前缀。
总结
Thrift 编译器是构建跨语言分布式系统的强大工具。通过灵活的代码生成选项和定制能力，Thrift 编译器可以生成符合各种项目需求的代码。理解和掌握 Thrift 编译器的各种选项，能够帮助开发者更高效地使用 Thrift，构建高质量的分布式应用。在实际开发中，应根据项目的具体需求，选择合适的代码生成选项，并充分利用 Thrift 编译器的定制能力，提升开发效率和代码质量。
5.2 C++服务端开发：实现Thrift服务 (C++ Server Development: Implementing Thrift Services)
在上一节中，我们学习了如何使用 Thrift 编译器生成 C++ 代码。本节将重点介绍如何基于生成的代码，开发 Thrift C++ 服务端，实现具体的业务逻辑，并对外提供服务。
服务端代码结构概览
使用 Thrift 编译器生成 C++ 服务端代码后，你会得到一系列的文件，其中最核心的是服务接口的头文件和实现文件。假设我们有一个名为 CalculatorService 的服务在 calculator.thrift 文件中定义，生成的 C++ 代码目录结构如下：
1
gen-cpp/
2
├── CalculatorService.h // 服务接口头文件
3
├── CalculatorService.cpp // 服务接口实现文件 (骨架代码)
4
├── calculator_constants.h
5
├── calculator_constants.cpp
6
├── calculator_types.h
7
└── calculator_types.cpp
CalculatorService.h 文件定义了服务接口的抽象类 CalculatorServiceIf，以及客户端代理类 CalculatorServiceClient。CalculatorService.cpp 文件则包含了 CalculatorServiceIf 抽象类的骨架代码，我们需要继承这个抽象类，并实现其中的纯虚函数，来完成具体的服务逻辑。
实现服务接口
要实现 Thrift 服务端，首先需要创建一个类，继承自 CalculatorServiceIf，并重写在 .thrift 文件中定义的服务方法。例如，如果 calculator.thrift 中定义了一个 add 方法：
1
service CalculatorService {
2
i32 add(i32 num1, i32 num2);
3
}
那么在 CalculatorService.cpp 文件中，你需要实现 add 方法：
1
#include "CalculatorService.h"
2
3
using namespace ::apache::thrift;
4
using namespace ::apache::thrift::protocol;
5
using namespace ::apache::thrift::transport;
6
using namespace ::std;
7
8
class CalculatorServiceHandler : virtual public CalculatorServiceIf {
9
public:
10
CalculatorServiceHandler() {
11
// 实现你的初始化逻辑
12
}
13
14
void add(int32_t& _return, const int32_t num1, const int32_t num2) override {
15
// 实现加法逻辑
16
_return = num1 + num2;
17
printf("add(%d, %d)\n", num1, num2);
18
}
19
20
};
代码解释：
① class CalculatorServiceHandler : virtual public CalculatorServiceIf：定义服务处理器类 CalculatorServiceHandler，继承自 CalculatorServiceIf 抽象类。virtual public 继承方式是 Thrift 代码生成器默认使用的。
② CalculatorServiceHandler()：构造函数，可以在这里进行一些初始化操作。
③ void add(int32_t& _return, const int32_t num1, const int32_t num2) override：重写 add 方法。注意，Thrift 生成的代码中，返回值是通过第一个参数 _return 以引用的方式返回的。override 关键字是 C++11 引入的，用于显式地表示这是一个重写的方法，提高代码可读性和安全性。
④ _return = num1 + num2;：实现具体的加法逻辑，并将结果赋值给 _return。
⑤ printf("add(%d, %d)\n", num1, num2);：添加日志输出，方便调试和监控。
启动 Thrift 服务
实现了服务处理器后，还需要编写代码来启动 Thrift 服务，监听端口，并处理客户端请求。以下是一个简单的 Thrift 服务端启动示例：
1
#include <thrift/protocol/TBinaryProtocol.h>
2
#include <thrift/server/TSimpleServer.h>
3
#include <thrift/transport/TServerSocket.h>
4
#include <thrift/transport/TBufferTransports.h>
5
#include <iostream>
6
#include "CalculatorService.h"
7
8
using namespace ::apache::thrift;
9
using namespace ::apache::thrift::protocol;
10
using namespace ::apache::thrift::transport;
11
using namespace ::apache::thrift::server;
12
13
using namespace ::tutorial; // 假设你的 thrift 文件 namespace 为 tutorial
14
15
int main(int argc, char **argv) {
16
int port = 9090;
17
::std::shared_ptr<TServerSocket> serverSocket(new TServerSocket(port));
18
::std::shared_ptr<TBufferedTransportFactory> transportFactory(new TBufferedTransportFactory());
19
::std::shared_ptr<TBinaryProtocolFactory> protocolFactory(new TBinaryProtocolFactory());
20
21
::std::shared_ptr<CalculatorServiceHandler> handler(new CalculatorServiceHandler());
22
::std::shared_ptr<TProcessor> processor(new CalculatorServiceProcessor(handler));
23
TSimpleServer server(processor, serverSocket, transportFactory, protocolFactory);
24
25
std::cout << "Starting the simple server..." << std::endl;
26
server.serve();
27
std::cout << "done." << std::endl;
28
return 0;
29
}
代码解释：
① #include <thrift/...>：包含 Thrift 相关的头文件，包括协议、传输层、服务端等。
② #include "CalculatorService.h"：包含生成的服务接口头文件。
③ int port = 9090;：定义服务监听端口为 9090。
④ ::std::shared_ptr<TServerSocket> serverSocket(new TServerSocket(port));：创建 TServerSocket，用于监听 TCP 连接。
⑤ ::std::shared_ptr<TBufferedTransportFactory> transportFactory(new TBufferedTransportFactory());：创建 TBufferedTransportFactory，使用缓冲传输层。
⑥ ::std::shared_ptr<TBinaryProtocolFactory> protocolFactory(new TBinaryProtocolFactory());：创建 TBinaryProtocolFactory，使用二进制协议。
⑦ ::std::shared_ptr<CalculatorServiceHandler> handler(new CalculatorServiceHandler());：创建服务处理器实例。
⑧ ::std::shared_ptr<TProcessor> processor(new CalculatorServiceProcessor(handler));：创建 CalculatorServiceProcessor，将处理器和生成的服务接口关联起来。CalculatorServiceProcessor 是由 Thrift 编译器生成的，负责将客户端请求分发到对应的服务方法。
⑨ TSimpleServer server(processor, serverSocket, transportFactory, protocolFactory);：创建 TSimpleServer 实例，传入处理器、ServerSocket、传输层工厂和协议工厂。TSimpleServer 是 Thrift 提供的最简单的单线程服务端实现。
⑩ server.serve();：启动服务，开始监听和处理客户端请求。
编译和运行服务端
要编译上述服务端代码，你需要使用 C++ 编译器（如 g++）并链接 Thrift 库。编译命令示例如下（假设 Thrift 库安装在 /usr/local/lib，头文件在 /usr/local/include）：
1
g++ -o server server.cpp gen-cpp/CalculatorService.cpp gen-cpp/calculator_types.cpp gen-cpp/calculator_constants.cpp -I/usr/local/include -L/usr/local/lib -lthrift
编译成功后，运行生成的可执行文件 server：
1
./server
如果一切正常，你将在终端看到 "Starting the simple server..." 的输出，表示 Thrift 服务端已成功启动并开始监听 9090 端口。
选择不同的服务端类型
除了 TSimpleServer，Thrift 还提供了其他类型的服务端，适用于不同的场景：
① TThreadedServer：多线程服务端，每个客户端连接分配一个线程处理。适用于并发连接数不高，但每个连接处理时间较长的场景。
② TThreadPoolServer：线程池服务端，使用线程池来处理客户端连接。适用于高并发、连接处理时间较短的场景。
③ TNonblockingServer：非阻塞服务端，基于事件驱动的 IO 模型（如 epoll, kqueue）。适用于极高并发、低延迟的场景。
选择哪种服务端类型，需要根据具体的应用场景和性能需求进行权衡。对于初学者，TSimpleServer 是一个很好的入门选择，易于理解和使用。随着对 Thrift 的深入理解，可以逐步尝试更高级的服务端类型。
总结
本节介绍了如何基于 Thrift 生成的 C++ 代码，实现 Thrift 服务端。主要步骤包括：
① 继承服务接口抽象类 CalculatorServiceIf，并实现服务方法。
② 编写服务端启动代码，创建 ServerSocket、传输层工厂、协议工厂、处理器，并启动服务端。
③ 选择合适的 Thrift 服务端类型，如 TSimpleServer、TThreadedServer、TThreadPoolServer、TNonblockingServer 等。
通过本节的学习，读者应该能够掌握 Thrift C++ 服务端的基本开发流程，并能够根据自己的需求，构建简单的 Thrift 服务。在后续章节中，我们将继续深入探讨 Thrift 服务端的更多高级特性和最佳实践。
5.3 C++客户端开发：调用Thrift服务 (C++ Client Development: Calling Thrift Services)
上一节我们学习了如何开发 Thrift C++ 服务端。本节将介绍如何开发 Thrift C++ 客户端，来调用服务端提供的服务。
客户端代码结构概览
与服务端类似，使用 Thrift 编译器生成 C++ 客户端代码后，也会得到一系列文件，其中客户端代理类 CalculatorServiceClient 是客户端开发的核心。在 gen-cpp 目录下，CalculatorService.h 文件包含了 CalculatorServiceClient 的定义。
创建客户端实例
要调用 Thrift 服务，首先需要创建一个 CalculatorServiceClient 的实例。创建客户端实例通常需要以下几个步骤：
① 创建 TTransport：选择合适的传输层，例如 TSocket 用于 TCP 连接，THttpClient 用于 HTTP 连接等。
② 创建 TProtocol：选择合适的协议，例如 TBinaryProtocol、TCompactProtocol、TJSONProtocol 等。
③ 创建 CalculatorServiceClient：将 TTransport 和 TProtocol 传递给 CalculatorServiceClient 的构造函数。
以下是一个创建 CalculatorServiceClient 实例的示例代码：
1
#include <thrift/protocol/TBinaryProtocol.h>
2
#include <thrift/transport/TSocket.h>
3
#include <thrift/transport/TTransportUtils.h>
4
#include <iostream>
5
#include "CalculatorService.h"
6
7
using namespace ::apache::thrift;
8
using namespace ::apache::thrift::protocol;
9
using namespace ::apache::thrift::transport;
10
using namespace ::std;
11
12
using namespace ::tutorial; // 假设你的 thrift 文件 namespace 为 tutorial
13
14
int main() {
15
::std::shared_ptr<TTransport> socket(new TSocket("localhost", 9090));
16
::std::shared_ptr<TTransport> transport(new TBufferedTransport(socket));
17
::std::shared_ptr<TProtocol> protocol(new TBinaryProtocol(transport));
18
CalculatorServiceClient client(protocol);
19
20
try {
21
transport->open(); // 打开连接
22
23
int32_t sum = 0;
24
client.add(sum, 10, 20); // 调用 add 方法
25
cout << "10 + 20 = " << sum << endl;
26
27
transport->close(); // 关闭连接
28
} catch (TException& tx) {
29
cout << "ERROR: " << tx.what() << endl;
30
}
31
return 0;
32
}
代码解释：
① #include <thrift/...>：包含 Thrift 客户端相关的头文件，包括协议、传输层等。
② #include "CalculatorService.h"：包含生成的服务接口头文件。
③ ::std::shared_ptr<TTransport> socket(new TSocket("localhost", 9090));：创建 TSocket，指定服务端地址为 localhost，端口为 9090。
④ ::std::shared_ptr<TTransport> transport(new TBufferedTransport(socket));：创建 TBufferedTransport，在 TSocket 之上添加缓冲功能。
⑤ ::std::shared_ptr<TProtocol> protocol(new TBinaryProtocol(transport));：创建 TBinaryProtocol，使用二进制协议。
⑥ CalculatorServiceClient client(protocol);：创建 CalculatorServiceClient 实例，将协议传递给构造函数。
⑦ transport->open();：打开传输层连接，建立与服务端的 TCP 连接。
⑧ client.add(sum, 10, 20);：调用 CalculatorServiceClient 的 add 方法，传入参数 10 和 20，并将结果存储在 sum 变量中。
⑨ cout << "10 + 20 = " << sum << endl;：打印计算结果。
⑩ transport->close();：关闭传输层连接，断开与服务端的 TCP 连接。
⑪ try...catch (TException& tx)：使用 try...catch 块捕获 Thrift 异常，处理可能发生的网络错误或服务端异常。
调用服务方法
创建客户端实例后，就可以像调用本地方法一样，调用 CalculatorServiceClient 中定义的服务方法。例如，要调用 add 方法，直接使用 client.add(sum, 10, 20); 即可。
异常处理
在客户端调用服务方法时，可能会发生各种异常，例如网络连接错误、服务端处理异常等。Thrift 定义了一套异常处理机制，客户端可以通过 try...catch 块捕获 TException 及其子类异常，进行相应的处理。
Thrift IDL 中可以自定义异常类型，例如：
1
exception InvalidOperation {
2
1: i32 errorCode,
3
2: string message
4
}
5
6
service CalculatorService {
7
i32 divide(i32 num1, i32 num2) throws (InvalidOperation);
8
}
在 C++ 客户端代码中，可以捕获自定义异常：
1
try {
2
int32_t quotient = 0;
3
client.divide(quotient, 10, 0); // 除以 0 可能会抛出异常
4
cout << "10 / 0 = " << quotient << endl;
5
} catch (InvalidOperation &io) {
6
cout << "InvalidOperation: errorCode=" << io.errorCode << ", message=" << io.message << endl;
7
} catch (TException& tx) {
8
cout << "ERROR: " << tx.what() << endl;
9
}
选择不同的传输层和协议
与服务端类似，客户端也可以选择不同的传输层和协议，以满足不同的性能和场景需求。常用的传输层和协议组合包括：
① TSocket + TBufferedTransport + TBinaryProtocol：最常用的组合，适用于大多数场景。
② TSocket + TFramedTransport + TBinaryProtocol：使用分帧传输，适用于传输大数据块的场景。
③ THttpClient + TBufferedTransport + TJSONProtocol：使用 HTTP 传输和 JSON 协议，适用于需要与 Web 服务集成的场景。
④ TSocket + TSocket + TCompactProtocol：使用压缩协议，适用于网络带宽受限的场景。
选择合适的传输层和协议组合，需要根据具体的应用场景和性能需求进行权衡。
编译和运行客户端
要编译上述客户端代码，同样需要使用 C++ 编译器并链接 Thrift 库。编译命令示例如下（假设 Thrift 库安装在 /usr/local/lib，头文件在 /usr/local/include）：
1
g++ -o client client.cpp gen-cpp/CalculatorService.cpp gen-cpp/calculator_types.cpp gen-cpp/calculator_constants.cpp -I/usr/local/include -L/usr/local/lib -lthrift
编译成功后，先确保服务端程序 server 正在运行，然后运行客户端程序 client：
1
./client
如果一切正常，你将在终端看到 "10 + 20 = 30" 的输出，表示客户端成功调用了服务端提供的 add 方法，并获得了正确的结果。
总结
本节介绍了如何开发 Thrift C++ 客户端，调用 Thrift 服务端提供的服务。主要步骤包括：
① 创建 TTransport、TProtocol 和 CalculatorServiceClient 实例。
② 打开传输层连接 transport->open()。
③ 调用 CalculatorServiceClient 的服务方法，例如 client.add()。
④ 处理异常，例如 try...catch (TException& tx)。
⑤ 关闭传输层连接 transport->close()。
⑥ 选择合适的传输层和协议组合。
通过本节的学习，读者应该能够掌握 Thrift C++ 客户端的基本开发流程，并能够编写简单的客户端程序，调用 Thrift 服务。在后续章节中，我们将继续深入探讨 Thrift 客户端的更多高级特性和最佳实践。
5.4 多语言客户端支持：Java、Python等 (Multi-Language Client Support: Java, Python, etc.)
Thrift 的一大优势在于其跨语言能力。同一个 Thrift IDL 文件，可以生成多种编程语言的代码，从而实现不同语言开发的系统之间的互联互通。本节将简要介绍如何使用 Java 和 Python 等语言开发 Thrift 客户端，调用前面章节中开发的 C++ 服务端。
Java 客户端
首先，需要使用 Thrift 编译器生成 Java 代码。假设你的 .thrift 文件名为 calculator.thrift，可以使用以下命令生成 Java 代码：
1
thrift -gen java calculator.thrift
这会在当前目录下创建一个 gen-java 文件夹，其中包含了生成的 Java 代码。
接下来，创建一个 Java 项目，并将 gen-java 目录下的代码添加到项目中。然后，编写 Java 客户端代码，调用 C++ 服务端。以下是一个简单的 Java 客户端示例：
1
import org.apache.thrift.TException;
2
import org.apache.thrift.transport.TSocket;
3
import org.apache.thrift.transport.TTransport;
4
import org.apache.thrift.transport.TBufferedTransport;
5
import org.apache.thrift.protocol.TBinaryProtocol;
6
import tutorial.CalculatorService; // 假设你的 thrift 文件 namespace 为 tutorial
7
8
public class JavaClient {
9
public static void main(String[] args) {
10
try {
11
TTransport transport = new TSocket("localhost", 9090);
12
transport = new TBufferedTransport(transport);
13
TProtocol protocol = new TBinaryProtocol(transport);
14
CalculatorService.Client client = new CalculatorService.Client(protocol);
15
16
transport.open();
17
18
int sum = client.add(10, 20);
19
System.out.println("10 + 20 = " + sum);
20
21
transport.close();
22
} catch (TException x) {
23
x.printStackTrace();
24
}
25
}
26
}
代码解释：
① import org.apache.thrift...：导入 Thrift Java 库相关的类。
② import tutorial.CalculatorService;：导入生成的 Java 服务接口类。
③ TTransport transport = new TSocket("localhost", 9090);：创建 TSocket，指定服务端地址和端口。
④ TProtocol protocol = new TBinaryProtocol(transport);：创建 TBinaryProtocol，使用二进制协议。
⑤ CalculatorService.Client client = new CalculatorService.Client(protocol);：创建 CalculatorService.Client 实例。
⑥ transport.open();：打开连接。
⑦ int sum = client.add(10, 20);：调用 add 方法。
⑧ transport.close();：关闭连接。
⑨ try...catch (TException x)：异常处理。
要编译和运行 Java 客户端，你需要确保已经安装了 Java 开发环境和 Thrift Java 库。可以使用 Maven 或 Gradle 等构建工具来管理项目依赖。
Python 客户端
类似地，可以使用 Thrift 编译器生成 Python 代码：
1
thrift -gen py calculator.thrift
这会在当前目录下创建一个 gen-py 文件夹，其中包含了生成的 Python 代码。
创建一个 Python 脚本，并将 gen-py 目录添加到 Python 模块搜索路径中。然后，编写 Python 客户端代码，调用 C++ 服务端。以下是一个简单的 Python 客户端示例：
1
import sys
2
sys.path.append('./gen-py') # 将 gen-py 目录添加到模块搜索路径
3
4
from tutorial import CalculatorService # 假设你的 thrift 文件 namespace 为 tutorial
5
from thrift import Thrift
6
from thrift.transport import TSocket
7
from thrift.transport import TTransport
8
from thrift.protocol import TBinaryProtocol
9
10
try:
11
transport = TSocket.TSocket('localhost', 9090)
12
transport = TTransport.TBufferedTransport(transport)
13
protocol = TBinaryProtocol.TBinaryProtocol(transport)
14
client = CalculatorService.Client(protocol)
15
16
transport.open()
17
18
sum_result = client.add(10, 20)
19
print("10 + 20 = %d" % sum_result)
20
21
transport.close()
22
23
except Thrift.TException as tx:
24
print("%s" % (tx.message))
代码解释：
① sys.path.append('./gen-py')：将 gen-py 目录添加到 Python 模块搜索路径。
② from tutorial import CalculatorService：导入生成的 Python 服务接口类。
③ from thrift...：导入 Thrift Python 库相关的模块。
④ transport = TSocket.TSocket('localhost', 9090)：创建 TSocket。
⑤ protocol = TBinaryProtocol.TBinaryProtocol(transport)：创建 TBinaryProtocol。
⑥ client = CalculatorService.Client(protocol)：创建 CalculatorService.Client 实例。
⑦ transport.open()：打开连接。
⑧ sum_result = client.add(10, 20)：调用 add 方法。
⑨ transport.close()：关闭连接。
⑩ except Thrift.TException as tx：异常处理。
要运行 Python 客户端，你需要确保已经安装了 Python 环境和 Thrift Python 库。可以使用 pip install thrift 命令安装 Thrift Python 库。
其他语言客户端
除了 Java 和 Python，Thrift 还支持生成 Go、JavaScript、PHP、C# 等多种语言的代码。开发这些语言的客户端的流程与 Java 和 Python 类似，都需要先使用 Thrift 编译器生成对应语言的代码，然后创建客户端实例，调用服务方法，并处理异常。
跨语言互操作性
通过 Thrift，我们可以轻松实现不同语言开发的系统之间的互操作。例如，可以使用 C++ 开发高性能的服务端，使用 Python 开发便捷的客户端工具，或者使用 Java 开发跨平台的应用。Thrift 提供的跨语言能力，极大地提高了分布式系统的灵活性和可扩展性。
总结
本节简要介绍了如何使用 Java 和 Python 等语言开发 Thrift 客户端，调用 C++ 服务端。Thrift 的跨语言能力是其重要的优势之一，可以帮助开发者构建更加灵活和强大的分布式系统。在实际项目中，可以根据团队的技术栈和项目需求，选择合适的编程语言来开发 Thrift 客户端和服务端，充分利用 Thrift 的跨语言互操作性。
5.5 异步Thrift客户端与服务端 (Asynchronous Thrift Clients and Servers)
在传统的同步 Thrift 客户端和服务端模型中，客户端发起请求后，需要等待服务端响应返回才能继续执行后续操作。这种同步阻塞的方式在处理高并发、低延迟的场景下可能会成为性能瓶颈。为了解决这个问题，Thrift 提供了异步编程的支持。本节将介绍如何开发异步 Thrift 客户端和服务端，提升系统的并发处理能力和响应速度。
异步 Thrift 的优势
异步 Thrift 相比同步 Thrift，主要优势在于：
① 提高并发性：异步非阻塞 IO 模型可以处理大量的并发连接，而无需为每个连接分配独立的线程，从而降低资源消耗，提高系统吞吐量。
② 降低延迟：异步操作不会阻塞线程，可以更快地响应客户端请求，降低延迟。
③ 提升资源利用率：异步模型可以更有效地利用 CPU 和 IO 资源，提高资源利用率。
Folly Futures 简介
在 C++ 异步 Thrift 开发中，通常会结合 Facebook 开源的 Folly 库。Folly 库提供了强大的异步编程工具，其中最核心的是 Future 和 Promise。
⚝ Future（未来）：代表一个异步操作的结果，但结果在未来某个时刻才会可用。客户端可以通过 Future 来获取异步操作的结果，或者注册回调函数，在结果可用时被通知。
⚝ Promise（承诺）：用于设置 Future 的结果。服务端在完成异步操作后，通过 Promise 来设置 Future 的结果，从而通知客户端。
Folly Future 提供了丰富的操作，例如链式调用、组合、错误处理等，可以方便地构建复杂的异步逻辑。
异步 Thrift C++ 客户端
要开发异步 Thrift C++ 客户端，需要在生成代码时指定异步选项。例如，使用 --gen cpp:async 选项：
1
thrift --gen cpp:async calculator.thrift
生成的异步客户端代码，其服务接口方法会返回 folly::Future<ReturnType>，而不是同步方法的 void 或 ReturnType。
以下是一个简单的异步 Thrift C++ 客户端示例：
1
#include <thrift/protocol/TBinaryProtocol.h>
2
#include <thrift/transport/TSocket.h>
3
#include <thrift/transport/TTransportUtils.h>
4
#include <iostream>
5
#include <folly/futures/Future.h>
6
#include <folly/executors/IOThreadPoolExecutor.h>
7
#include "CalculatorService.h"
8
9
using namespace ::apache::thrift;
10
using namespace ::apache::thrift::protocol;
11
using namespace ::apache::thrift::transport;
12
using namespace ::std;
13
using namespace folly;
14
15
using namespace ::tutorial; // 假设你的 thrift 文件 namespace 为 tutorial
16
17
int main() {
18
// 创建 IO 线程池
19
IOThreadPoolExecutor executor;
20
21
::std::shared_ptr<TTransport> socket(new TSocket("localhost", 9090));
22
::std::shared_ptr<TTransport> transport(new TBufferedTransport(socket));
23
::std::shared_ptr<TProtocol> protocol(new TBinaryProtocol(transport));
24
CalculatorServiceAsyncClient client(protocol, &executor); // 使用异步客户端
25
26
try {
27
transport->open();
28
29
// 异步调用 add 方法，返回 Future
30
Future<int32_t> sumFuture = client.future_add(10, 20);
31
32
// 同步等待 Future 结果
33
int32_t sum = sumFuture.get();
34
cout << "10 + 20 = " << sum << endl;
35
36
transport->close();
37
} catch (TException& tx) {
38
cout << "ERROR: " << tx.what() << endl;
39
}
40
return 0;
41
}
代码解释：
① #include <folly/futures/Future.h> 和 #include <folly/executors/IOThreadPoolExecutor.h>：包含 Folly 库相关的头文件。
② IOThreadPoolExecutor executor;：创建 Folly IO 线程池，用于执行异步 IO 操作。
③ CalculatorServiceAsyncClient client(protocol, &executor);：创建 CalculatorServiceAsyncClient 实例，注意这里使用的是 CalculatorServiceAsyncClient，而不是同步客户端 CalculatorServiceClient，并且需要传入 IOThreadPoolExecutor 实例。
④ Future<int32_t> sumFuture = client.future_add(10, 20);：调用异步方法 future_add，返回 Future<int32_t>。
⑤ int32_t sum = sumFuture.get();：同步等待 Future 结果，使用 get() 方法会阻塞当前线程，直到结果可用。在实际异步编程中，通常不建议使用 get() 方法，而是使用回调函数或 then() 方法来处理异步结果。
异步 Thrift C++ 服务端
要开发异步 Thrift C++ 服务端，同样需要在生成代码时指定异步选项。生成的异步服务端代码，其服务接口抽象类会变为 CalculatorServiceSvIf，服务处理器类会变为 CalculatorServiceAsyncProcessor。
以下是一个简单的异步 Thrift C++ 服务端示例：
1
#include <thrift/protocol/TBinaryProtocol.h>
2
#include <thrift/server/TNonblockingServer.h>
3
#include <thrift/transport/TServerSocket.h>
4
#include <thrift/transport/TBufferTransports.h>
5
#include <iostream>
6
#include <folly/futures/Future.h>
7
#include "CalculatorService.h"
8
9
using namespace ::apache::thrift;
10
using namespace ::apache::thrift::protocol;
11
using namespace ::apache::thrift::transport;
12
using namespace ::apache::thrift::server;
13
using namespace ::std;
14
using namespace folly;
15
16
using namespace ::tutorial; // 假设你的 thrift 文件 namespace 为 tutorial
17
18
class CalculatorServiceHandler : virtual public CalculatorServiceSvIf { // 继承 SvIf
19
public:
20
CalculatorServiceHandler() {
21
// 实现你的初始化逻辑
22
}
23
24
Future<int32_t> future_add(int32_t num1, int32_t num2) override { // 返回 Future
25
// 异步实现加法逻辑
26
Promise<int32_t> promise;
27
int32_t result = num1 + num2;
28
promise.setValue(result); // 设置 Future 结果
29
printf("add(%d, %d)\n", num1, num2);
30
return promise.getFuture(); // 返回 Future
31
}
32
};
33
34
int main(int argc, char **argv) {
35
int port = 9090;
36
::std::shared_ptr<TServerSocket> serverSocket(new TServerSocket(port));
37
::std::shared_ptr<TBufferedTransportFactory> transportFactory(new TBufferedTransportFactory());
38
::std::shared_ptr<TBinaryProtocolFactory> protocolFactory(new TBinaryProtocolFactory());
39
40
::std::shared_ptr<CalculatorServiceHandler> handler(new CalculatorServiceHandler());
41
::std::shared_ptr<TAsyncProcessor> processor(new CalculatorServiceAsyncProcessor(handler)); // 使用异步 Processor
42
TNonblockingServer server(processor, serverSocket); // 使用 TNonblockingServer
43
44
std::cout << "Starting the nonblocking server..." << std::endl;
45
server.serve();
46
std::cout << "done." << std::endl;
47
return 0;
48
}
代码解释：
① class CalculatorServiceHandler : virtual public CalculatorServiceSvIf：服务处理器类继承自 CalculatorServiceSvIf，而不是 CalculatorServiceIf。
② Future<int32_t> future_add(int32_t num1, int32_t num2) override：异步服务方法返回 Future<int32_t>。
③ Promise<int32_t> promise;：创建 Promise 实例。
④ promise.setValue(result);：设置 Promise 的值，即 Future 的结果。
⑤ return promise.getFuture();：返回 Promise 关联的 Future。
⑥ ::std::shared_ptr<TAsyncProcessor> processor(new CalculatorServiceAsyncProcessor(handler));：使用 CalculatorServiceAsyncProcessor 异步处理器。
⑦ TNonblockingServer server(processor, serverSocket);：使用 TNonblockingServer 非阻塞服务端。
异步编程的最佳实践
在实际异步 Thrift 开发中，需要注意以下最佳实践：
① 避免阻塞操作：在异步服务方法中，应尽量避免执行阻塞 IO 或 CPU 密集型操作，如果必须执行，应将其放到独立的线程池中执行，避免阻塞 IO 线程。
② 合理使用线程池：根据应用场景和负载特点，合理配置 IO 线程池和计算线程池的大小，避免线程池过小导致性能瓶颈，或线程池过大导致资源浪费。
③ 错误处理：异步操作的错误处理需要特别注意，可以使用 Future 的 thenError()、handle() 等方法来处理异步错误。
④ 监控与调优：异步系统的监控和调优比同步系统更复杂，需要使用合适的监控工具和性能分析方法，定位性能瓶颈，进行优化。
总结
本节介绍了异步 Thrift 客户端和服务端的开发方法，以及 Folly Futures 在异步 Thrift C++ 开发中的应用。异步 Thrift 可以显著提高系统的并发处理能力和响应速度，适用于高并发、低延迟的场景。掌握异步 Thrift 编程技术，对于构建高性能分布式系统至关重要。在实际项目中，应根据具体的性能需求和场景特点，选择合适的同步或异步 Thrift 模型。
END_OF_CHAPTER
6. chapter 6： Folly网络编程进阶：Asio与IO模型 (Advanced Folly Network Programming: Asio and IO Models)
6.1 Asio基础：理解IO模型与事件循环 (Asio Basics: Understanding IO Models and Event Loops)
在构建高性能网络应用程序时，理解底层的I/O模型至关重要。Folly 库的网络编程能力很大程度上建立在 Asio 库之上。Asio (Asynchronous Input/Output) 是一个跨平台的 C++ 库，用于网络和底层 I/O 编程，它提供了统一的异步操作接口，支持多种 I/O 模型，并被广泛应用于高性能网络服务开发。本节将深入探讨 Asio 的基础概念，特别是 I/O 模型和事件循环，为后续章节深入 Folly 网络编程打下坚实的基础。
6.1.1 同步阻塞I/O (Synchronous Blocking I/O)
最传统的 I/O 模型是同步阻塞 I/O (Synchronous Blocking I/O)。在这种模型下，当应用程序发起一个 I/O 操作（例如，读取网络数据）时，发起调用的线程会被阻塞 (block)，直到 I/O 操作完成并返回结果。这意味着在 I/O 操作执行期间，线程无法执行其他任何任务。
① 工作原理：
⚝ 应用程序调用 read() 或 recv() 等系统调用发起 I/O 请求。
⚝ 操作系统内核接收到请求，如果数据尚未准备好，则将线程挂起（阻塞）。
⚝ 当数据准备就绪后，内核将数据从内核空间拷贝到用户空间缓冲区。
⚝ 内核唤醒被阻塞的线程，系统调用返回，应用程序继续执行。
② 优点：
⚝ 编程模型简单直观，易于理解和实现。
⚝ 代码逻辑符合线性执行的习惯，易于调试。
③ 缺点：
⚝ 性能瓶颈：在处理高并发连接时，每个连接都需要一个线程来处理，大量的阻塞线程会导致系统资源消耗巨大，上下文切换开销高昂，性能难以扩展。
⚝ 资源浪费：线程在等待 I/O 完成期间处于空闲状态，浪费 CPU 资源。
④ 适用场景：
⚝ 低并发、低负载的应用场景。
⚝ 对实时性要求不高，可以容忍一定延迟的应用。
⚝ 简单的脚本或工具程序。
1
// 同步阻塞 I/O 示例 (伪代码)
2
int socket_fd = create_socket();
3
bind_socket(socket_fd, address);
4
listen_socket(socket_fd);
5
6
while (true) {
7
int client_fd = accept_connection(socket_fd); // 阻塞等待客户端连接
8
handle_client(client_fd); // 阻塞处理客户端请求
9
close_socket(client_fd);
10
}
6.1.2 非阻塞I/O (Non-blocking I/O)
为了解决同步阻塞 I/O 的性能问题，非阻塞 I/O (Non-blocking I/O) 模型应运而生。在非阻塞 I/O 模型中，当应用程序发起一个 I/O 操作时，系统调用会立即返回，而不管 I/O 操作是否完成。如果 I/O 操作尚未完成，系统调用会返回一个特定的错误码（例如 EAGAIN 或 EWOULDBLOCK），表示操作正在进行中，但数据尚未准备好。应用程序需要轮询 (polling) 或使用其他机制来检查 I/O 操作是否完成。
① 工作原理：
⚝ 将 socket 设置为非阻塞模式。
⚝ 应用程序调用 recv() 等系统调用发起 I/O 请求。
⚝ 如果数据已准备好，系统调用立即返回数据。
⚝ 如果数据未准备好，系统调用立即返回错误码（EAGAIN 或 EWOULDBLOCK），不会阻塞线程。
⚝ 应用程序需要循环调用系统调用，不断轮询检查 I/O 是否就绪。
② 优点：
⚝ 避免阻塞：线程不会因为 I/O 操作而阻塞，可以继续执行其他任务。
⚝ 提高并发性：单个线程可以同时处理多个连接的 I/O 操作。
③ 缺点：
⚝ 轮询开销：应用程序需要不断轮询检查 I/O 状态，会消耗 CPU 资源，即使在没有 I/O 事件发生时也会进行无效的轮询。
⚝ 编程复杂性：需要手动处理轮询逻辑和状态管理，编程模型相对复杂。
④ 适用场景：
⚝ 需要一定并发处理能力，但并发量不是极高的场景。
⚝ 对实时性有一定要求，但可以容忍一定延迟的应用。
1
// 非阻塞 I/O 示例 (伪代码)
2
int socket_fd = create_non_blocking_socket();
3
bind_socket(socket_fd, address);
4
listen_socket(socket_fd);
5
6
while (true) {
7
int client_fd = accept_connection(socket_fd); // 非阻塞 accept
8
if (client_fd != -1) {
9
// 处理新连接
10
}
11
12
// 轮询检查 socket 是否可读
13
if (is_socket_readable(socket_fd)) {
14
read_data(socket_fd); // 非阻塞 read
15
}
16
17
// 执行其他任务
18
do_other_tasks();
19
}
6.1.3 I/O多路复用 (I/O Multiplexing)
I/O 多路复用 (I/O Multiplexing) 是解决非阻塞 I/O 轮询开销问题的一种高效 I/O 模型。它允许单个线程同时监听多个文件描述符 (file descriptor，例如 socket)。当任何一个或多个文件描述符就绪（可读、可写或发生错误）时，操作系统内核会通知应用程序，应用程序再对就绪的文件描述符进行 I/O 操作。常见的 I/O 多路复用机制包括 select、poll 和 epoll (Linux)、kqueue (BSD/macOS) 等。
① 工作原理：
⚝ 应用程序将需要监听的文件描述符集合注册到多路复用器 (例如 epoll)。
⚝ 多路复用器监听这些文件描述符的 I/O 事件。
⚝ 当任何一个文件描述符就绪时，多路复用器返回就绪的文件描述符列表。
⚝ 应用程序遍历就绪的文件描述符列表，并进行相应的 I/O 操作。
② 优点：
⚝ 高效并发：单个线程可以同时管理大量连接，避免了多线程的上下文切换开销。
⚝ 事件驱动：只有在文件描述符就绪时才进行处理，避免了无效的轮询，提高了 CPU 利用率。
⚝ 高扩展性：可以轻松处理数万甚至数十万的并发连接。
③ 缺点：
⚝ 编程模型相对复杂：需要理解和使用多路复用 API，例如 epoll_create、epoll_ctl、epoll_wait 等。
⚝ 事件处理逻辑：需要编写事件处理函数来处理不同类型的 I/O 事件。
④ 适用场景：
⚝ 高并发、高性能网络服务器。
⚝ 需要同时处理大量连接的应用，例如聊天服务器、游戏服务器、代理服务器等。
1
// I/O 多路复用 (epoll) 示例 (伪代码)
2
int epoll_fd = epoll_create1(0);
3
// ... 添加 socket_fd 到 epoll 监听 ...
4
5
while (true) {
6
int num_events = epoll_wait(epoll_fd, events, MAX_EVENTS, -1); // 等待事件发生
7
for (int i = 0; i < num_events; ++i) {
8
int fd = events[i].data.fd;
9
if (events[i].events & EPOLLIN) { // 可读事件
10
read_data(fd);
11
}
12
if (events[i].events & EPOLLOUT) { // 可写事件
13
write_data(fd);
14
}
15
// ... 处理其他事件 ...
16
}
17
}
6.1.4 信号驱动I/O (Signal-driven I/O)
信号驱动 I/O (Signal-driven I/O) 是一种异步 I/O 模型。在这种模型中，应用程序预先注册一个信号处理函数 (signal handler)，当文件描述符就绪时，操作系统内核会向应用程序发送一个信号 (例如 SIGIO)，通知应用程序可以进行 I/O 操作。应用程序在信号处理函数中处理 I/O 事件。
① 工作原理：
⚝ 应用程序使用 sigaction 等系统调用注册信号处理函数，并设置文件描述符为信号驱动模式。
⚝ 当文件描述符就绪时，内核向应用程序发送 SIGIO 信号。
⚝ 应用程序的信号处理函数被调用，在信号处理函数中进行 I/O 操作。
② 优点：
⚝ 异步通知：I/O 事件发生时，内核主动通知应用程序，无需轮询。
⚝ 资源效率：应用程序在等待 I/O 事件期间可以执行其他任务，提高了资源利用率。
③ 缺点：
⚝ 信号处理复杂性：信号处理函数需要是非重入 (reentrant) 的，并且需要处理信号竞态条件 (race condition) 等复杂问题。
⚝ 编程模型相对复杂：相对于其他模型，信号驱动 I/O 的编程模型较为复杂，容易出错。
⚝ 实际应用较少：由于其复杂性和一些限制，信号驱动 I/O 在实际应用中相对较少，不如 I/O 多路复用模型普及。
④ 适用场景：
⚝ 理论上适用于高并发网络应用，但实际应用较少。
⚝ 一些特定的嵌入式系统或实时系统可能会使用信号驱动 I/O。
1
// 信号驱动 I/O 示例 (伪代码)
2
void signal_handler(int signum) {
3
// 处理 I/O 事件
4
read_data(socket_fd);
5
}
6
7
int main() {
8
// ... 设置信号处理函数 sigaction ...
9
fcntl(socket_fd, F_SETFL, O_ASYNC | O_NONBLOCK); // 设置为信号驱动和非阻塞模式
10
fcntl(socket_fd, F_SETOWN, getpid()); // 设置接收信号的进程
11
12
while (true) {
13
// 执行其他任务，等待信号
14
pause();
15
}
16
return 0;
17
}
6.1.5 异步I/O (Asynchronous I/O, AIO)
真正的异步 I/O (Asynchronous I/O, AIO) 模型与信号驱动 I/O 有些类似，但更加强大和高效。在异步 I/O 模型中，应用程序发起一个 I/O 操作后，立即返回，不会阻塞。I/O 操作的整个过程（包括数据准备和数据拷贝）都由操作系统内核在后台完成。当整个 I/O 操作完成后，内核会通过事件通知 (completion event) 的方式通知应用程序，例如通过回调函数 (callback function) 或完成队列 (completion queue)。
① 工作原理：
⚝ 应用程序调用 aio_read 或 aio_write 等异步 I/O 系统调用发起 I/O 请求。
⚝ 系统调用立即返回，应用程序可以继续执行其他任务。
⚝ 操作系统内核在后台完成整个 I/O 操作，包括数据准备和数据拷贝。
⚝ 当 I/O 操作完成后，内核通过事件通知机制（例如回调函数或完成队列）通知应用程序。
② 优点：
⚝ 真正的异步：I/O 操作的整个过程都是异步的，应用程序在发起 I/O 操作后可以完全不关心 I/O 的执行过程，直到收到完成通知。
⚝ 最高效的并发：应用程序可以充分利用 CPU 和 I/O 资源，实现最高的并发性能。
③ 缺点：
⚝ 编程模型复杂：异步 I/O 的编程模型相对复杂，需要使用回调函数或完成队列等机制来处理 I/O 完成事件。
⚝ 操作系统支持：并非所有操作系统都提供完善的异步 I/O 支持，例如早期的 Linux 系统对 AIO 的支持不够完善（glibc 提供的 AIO 实际上是基于线程池模拟的）。但现代 Linux 内核 (libaio) 和 Windows (IOCP) 都提供了真正的异步 I/O 支持。
⚝ 调试难度：异步编程的调试难度相对较高，错误追踪和定位可能更加困难。
④ 适用场景：
⚝ 超高并发、超高性能的网络服务器和存储系统。
⚝ 对 I/O 性能要求极致的应用，例如大型数据库、高性能 Web 服务器、分布式存储系统等。
1
// 异步 I/O (AIO) 示例 (伪代码，Linux AIO)
2
void completion_callback(sigval_t sigval) {
3
// I/O 完成回调函数
4
struct aiocb* cb = (struct aiocb*)sigval.sival_ptr;
5
int result = aio_return(cb);
6
// ... 处理 I/O 结果 ...
7
aio_free(cb);
8
}
9
10
int main() {
11
struct aiocb* cb = aio_alloc();
12
// ... 初始化 aiocb 结构体，设置回调函数 ...
13
int ret = aio_read(cb); // 发起异步读操作，立即返回
14
if (ret == -1) {
15
perror("aio_read");
16
}
17
18
// ... 执行其他任务 ...
19
20
// 在回调函数中处理 I/O 完成事件
21
return 0;
22
}
6.1.6 事件循环 (Event Loop)
事件循环 (Event Loop) 是一种程序设计模式，用于处理异步事件。它在单线程环境中实现并发，通过循环监听和处理事件，使得程序能够响应外部输入和执行异步任务，而不会阻塞主线程。事件循环是构建非阻塞、事件驱动应用程序的核心机制，广泛应用于 GUI 编程、网络编程、Node.js 等领域。
① 核心组件：
⚝ 事件队列 (Event Queue)：用于存储待处理的事件，例如 I/O 事件、定时器事件、用户输入事件等。
⚝ 事件循环 (Event Loop)：一个无限循环，不断从事件队列中取出事件并进行处理。
⚝ 事件分发器 (Event Dispatcher)：负责监听文件描述符 (例如 socket) 上的事件，并将就绪的事件添加到事件队列中。在 Linux 系统中，事件分发器通常是 epoll，在 BSD/macOS 系统中是 kqueue，在 Windows 系统中是 IOCP。
⚝ 事件处理器 (Event Handler)：用于处理特定类型的事件，例如读取数据、写入数据、处理连接请求等。
② 工作流程：
⚝ 初始化：初始化事件分发器，创建事件队列。
⚝ 注册事件：将需要监听的文件描述符和事件类型注册到事件分发器，并关联相应的事件处理器。
⚝ 事件循环：
▮▮▮▮▮▮▮▮❶ 事件分发器监听注册的文件描述符，等待事件发生。
▮▮▮▮▮▮▮▮❷ 当有事件发生时，事件分发器将就绪的事件添加到事件队列。
▮▮▮▮▮▮▮▮❸ 事件循环从事件队列中取出事件。
▮▮▮▮▮▮▮▮❹ 根据事件类型，调用相应的事件处理器来处理事件。
▮▮▮▮▮▮▮▮❺ 处理完成后，返回事件循环的开始，继续监听和处理新的事件。
③ 优点：
⚝ 单线程并发：在单线程中实现并发，避免了多线程的上下文切换开销和锁竞争问题。
⚝ 高响应性：事件驱动的架构使得程序能够及时响应外部事件，保持高响应性。
⚝ 资源效率：充分利用 CPU 资源，避免了阻塞等待和无效轮询。
④ 适用场景：
⚝ GUI 应用程序。
⚝ 网络服务器。
⚝ Node.js 环境。
⚝ 任何需要处理异步事件和保持高响应性的应用程序。
⑤ Folly 与 Asio 中的事件循环：
Folly 的网络编程组件，例如 folly::EventBase 和 folly::AsyncSocket，都基于 Asio 构建，并使用了事件循环机制。folly::EventBase 封装了底层的事件循环，提供了统一的事件处理接口。folly::AsyncSocket 基于 folly::EventBase，提供了异步 socket 操作的接口。在 Folly 中，开发者通常不需要直接操作底层的事件循环细节，而是使用 Folly 提供的更高层次的抽象，例如 folly::Future 和 folly::Promise，来处理异步操作和事件。
总结来说，理解 I/O 模型和事件循环是深入学习 Folly 网络编程的关键。Asio 提供了强大的跨平台异步 I/O 能力，而 Folly 在 Asio 的基础上进行了封装和扩展，提供了更加易用和高效的网络编程接口。在后续章节中，我们将深入探讨如何使用 Folly 的网络编程组件来构建高性能的 C++ 应用程序。
6.2 使用Folly Socket：构建高性能网络应用 (Using Folly Socket: Building High-Performance Network Applications)
Folly 库提供了 folly::Socket 类，它是对底层 socket API 的一个现代 C++ 封装，旨在简化网络编程并提供更高的性能和安全性。folly::Socket 基于 Asio 构建，充分利用了异步 I/O 和事件循环的优势，提供了非阻塞的、事件驱动的网络编程接口。本节将介绍 folly::Socket 的基本用法，并演示如何使用它来构建高性能的网络应用程序。
6.2.1 folly::Socket 概述
folly::Socket 不仅仅是对原始 socket API 的简单包装，它在以下几个方面进行了增强和改进：
① 异步操作：folly::Socket 的核心是异步操作。所有的 I/O 操作，例如 connect、accept、read、write 等，都是异步的，不会阻塞调用线程。这些异步操作通常返回 folly::Future，用于表示异步操作的结果，并支持链式调用、错误处理和取消等功能。
② 事件驱动：folly::Socket 基于 folly::EventBase 的事件循环机制。当 socket 上的事件（例如可读、可写、连接建立等）发生时，folly::EventBase 会通知 folly::Socket，并触发相应的回调函数或 Future 的完成。
③ 跨平台：folly::Socket 封装了底层操作系统的 socket API 差异，提供了统一的跨平台接口，可以在 Linux、macOS、Windows 等平台上运行。
④ 安全性：folly::Socket 支持 SSL/TLS 加密，可以方便地构建安全的网络连接。
⑤ 高性能：folly::Socket 充分利用了 Asio 的异步 I/O 和事件循环机制，以及 Folly 库自身的高效数据结构和算法，提供了卓越的性能。
6.2.2 创建和绑定 folly::Socket
要使用 folly::Socket，首先需要创建一个 folly::EventBase 对象，它是事件循环的核心。然后，可以使用 folly::AsyncServerSocket 或 folly::AsyncSocket 来创建 socket 对象。
① folly::EventBase：
folly::EventBase 代表一个事件循环实例。通常，每个线程拥有一个 folly::EventBase 对象。可以使用 folly::EventBase::get() 获取当前线程的 folly::EventBase 对象（如果不存在则会创建）。
1
folly::EventBase* evb = folly::EventBase::get();
② folly::AsyncServerSocket：
folly::AsyncServerSocket 用于创建服务器端 socket，监听连接请求。
1
folly::AsyncServerSocket::UniquePtr serverSocket = folly::AsyncServerSocket::createSocket(evb);
③ folly::AsyncSocket：
folly::AsyncSocket 用于创建客户端 socket 或接受连接后的 socket。
1
folly::AsyncSocket::UniquePtr clientSocket = folly::AsyncSocket::createSocket(evb);
④ 绑定地址和端口：
服务器端 socket 需要绑定地址和端口才能监听连接。可以使用 bind 方法进行绑定。
1
folly::SocketAddress address("0.0.0.0", 8080); // 监听所有地址的 8080 端口
2
serverSocket->bind(address);
6.2.3 监听连接和接受连接
服务器端 socket 绑定地址和端口后，需要调用 listen 方法开始监听连接请求。然后，可以使用 accept 方法异步接受客户端连接。accept 方法返回一个 folly::Future<folly::AsyncSocket::UniquePtr>，当有新的连接到达时，Future 会完成，并返回一个新的 folly::AsyncSocket 对象，用于与客户端进行通信。
1
serverSocket->listen(128); // 设置最大连接队列长度
2
3
serverSocket->accept().then([&](folly::AsyncSocket::UniquePtr sock) {
4
// 连接建立成功，sock 是与客户端通信的 socket
5
handleConnection(std::move(sock)); // 处理客户端连接
6
// 再次调用 accept 接受下一个连接
7
serverSocket->accept().then( ... ); // 递归调用 accept
8
});
注意，accept 方法返回的 Future 需要链式调用 .then() 方法来处理连接建立后的逻辑。为了持续接受连接，通常需要在 .then() 回调函数中再次调用 accept 方法，形成递归调用。
6.2.4 客户端连接
客户端可以使用 folly::AsyncSocket 的 connect 方法连接到服务器。connect 方法也返回一个 folly::Future<Unit>，当连接建立成功时，Future 会完成。
1
folly::AsyncSocket::UniquePtr clientSocket = folly::AsyncSocket::createSocket(evb);
2
folly::SocketAddress serverAddress("127.0.0.1", 8080);
3
4
clientSocket->connect(serverAddress).then([&]() {
5
// 连接建立成功
6
sendMessage(clientSocket.get(), "Hello Server!"); // 发送消息
7
});
6.2.5 发送和接收数据
folly::AsyncSocket 提供了 write 和 read 方法用于发送和接收数据。这两个方法都是异步的，返回 folly::Future<size_t>，表示实际发送或接收的字节数。
① 发送数据 (write)：
1
folly::IOBufQueue writeQueue;
2
writeQueue.append(folly::IOBuf::copyBuffer("Hello Client!"));
3
4
clientSocket->write(writeQueue).then([](size_t bytesWritten) {
5
// 数据发送成功，bytesWritten 是实际发送的字节数
6
LOG(INFO) << "Sent " << bytesWritten << " bytes.";
7
});
发送数据时，需要将数据封装到 folly::IOBufQueue 中。folly::IOBuf 是 Folly 库中用于高效处理内存缓冲区的类，folly::IOBufQueue 是 folly::IOBuf 的队列，用于管理待发送的数据。
② 接收数据 (read)：
folly::AsyncSocket 的 read 方法需要配合 ReadCallback 接口使用。需要创建一个类实现 folly::AsyncSocket::ReadCallback 接口，并将其设置为 folly::AsyncSocket 的读回调。当 socket 上有数据可读时，ReadCallback 接口的方法会被调用。
1
class MyReadCallback : public folly::AsyncSocket::ReadCallback {
2
public:
3
explicit MyReadCallback(folly::AsyncSocket* sock) : sock_(sock) {}
4
5
void onReadDataAvailable(folly::AsyncSocket* sock) noexcept override {
6
folly::IOBufQueue readQueue;
7
sock->recv(&readQueue); // 从 socket 接收数据到 readQueue
8
processData(readQueue); // 处理接收到的数据
9
sock->setReadCB(this); // 再次设置读回调，继续接收数据
10
}
11
12
void onReadClosed(folly::AsyncSocket* sock) noexcept override {
13
LOG(INFO) << "Connection closed by peer.";
14
delete this; // 释放 ReadCallback 对象
15
}
16
17
void onReadError(folly::AsyncSocket* sock, const folly::AsyncSocketException& ex) noexcept override {
18
LOG(ERROR) << "Read error: " << ex.what();
19
delete this; // 释放 ReadCallback 对象
20
}
21
22
private:
23
folly::AsyncSocket* sock_;
24
};
25
26
// ... 在连接建立后设置读回调 ...
27
clientSocket->setReadCB(new MyReadCallback(clientSocket.get()));
ReadCallback 接口包含三个方法：
⚝ onReadDataAvailable：当 socket 上有数据可读时被调用。在这个方法中，可以使用 sock->recv(&readQueue) 从 socket 接收数据到 folly::IOBufQueue 中，并进行处理。处理完数据后，需要再次调用 sock->setReadCB(this) 重新设置读回调，以便继续接收后续数据。
⚝ onReadClosed：当连接被对端关闭时被调用。
⚝ onReadError：当读取数据发生错误时被调用。
在 onReadClosed 和 onReadError 方法中，通常需要释放 ReadCallback 对象，并进行连接关闭和资源清理等操作。
6.2.6 错误处理
folly::Future 提供了强大的错误处理机制。可以使用 .thenError() 或 .catchError() 方法来处理异步操作的错误。folly::AsyncSocket 的方法可能会抛出 folly::AsyncSocketException 异常，表示 socket 操作失败。
1
clientSocket->connect(serverAddress).then([&]() {
2
// 连接成功
3
// ...
4
}).thenError(folly::tag_exception<folly::AsyncSocketException>([](const folly::AsyncSocketException& ex) {
5
// 连接失败，处理 AsyncSocketException 异常
6
LOG(ERROR) << "Connect error: " << ex.what();
7
}));
6.2.7 示例代码：简单的 Echo 服务器和客户端
下面是一个简单的 Echo 服务器和客户端示例，演示了如何使用 folly::Socket 构建网络应用程序。
Echo 服务器 (EchoServer.cpp)
1
#include <folly/io/async/AsyncServerSocket.h>
2
#include <folly/io/async/AsyncSocket.h>
3
#include <folly/io/IOBufQueue.h>
4
#include <folly/futures/Future.h>
5
#include <folly/SocketAddress.h>
6
#include <folly/EventBase.h>
7
#include <folly/String.h>
8
#include <glog/logging.h>
9
10
using namespace folly;
11
12
class EchoReadCallback : public AsyncSocket::ReadCallback {
13
public:
14
explicit EchoReadCallback(AsyncSocket* sock) : sock_(sock) {}
15
16
void onReadDataAvailable(AsyncSocket* sock) noexcept override {
17
IOBufQueue readQueue;
18
sock->recv(&readQueue);
19
processData(readQueue);
20
sock->setReadCB(this); // 再次设置读回调
21
}
22
23
void onReadClosed(AsyncSocket* sock) noexcept override {
24
LOG(INFO) << "Connection closed by peer.";
25
delete this;
26
}
27
28
void onReadError(AsyncSocket* sock, const AsyncSocketException& ex) noexcept override {
29
LOG(ERROR) << "Read error: " << ex.what();
30
delete this;
31
}
32
33
private:
34
void processData(IOBufQueue& readQueue) {
35
while (!readQueue.empty()) {
36
auto buf = readQueue.front();
37
readQueue.pop_front();
38
StringPiece data(reinterpret_cast<const char*>(buf->data()), buf->length());
39
LOG(INFO) << "Received: " << data;
40
41
// Echo back
42
IOBufQueue writeQueue;
43
writeQueue.append(IOBuf::copyBuffer(data));
44
sock_->write(writeQueue).then([](size_t bytesWritten) {
45
LOG(INFO) << "Echoed back " << bytesWritten << " bytes.";
46
});
47
}
48
}
49
50
AsyncSocket* sock_;
51
};
52
53
int main() {
54
EventBase evb;
55
AsyncServerSocket::UniquePtr serverSocket = AsyncServerSocket::createSocket(&evb);
56
SocketAddress address("0.0.0.0", 8080);
57
serverSocket->bind(address);
58
serverSocket->listen(128);
59
60
serverSocket->accept().then([&](AsyncSocket::UniquePtr sock) {
61
LOG(INFO) << "Accepted connection from " << sock->getPeerAddress().describe();
62
sock->setReadCB(new EchoReadCallback(sock.get()));
63
serverSocket->accept().then( ... ); // 递归 accept
64
});
65
66
LOG(INFO) << "Echo server started on port 8080";
67
evb.loopForever();
68
return 0;
69
}
Echo 客户端 (EchoClient.cpp)
1
#include <folly/io/async/AsyncSocket.h>
2
#include <folly/io/IOBufQueue.h>
3
#include <folly/futures/Future.h>
4
#include <folly/SocketAddress.h>
5
#include <folly/EventBase.h>
6
#include <folly/String.h>
7
#include <glog/logging.h>
8
9
using namespace folly;
10
11
class EchoClientReadCallback : public AsyncSocket::ReadCallback {
12
public:
13
explicit EchoClientReadCallback(AsyncSocket* sock) : sock_(sock) {}
14
15
void onReadDataAvailable(AsyncSocket* sock) noexcept override {
16
IOBufQueue readQueue;
17
sock->recv(&readQueue);
18
processData(readQueue);
19
sock->setReadCB(this); // 再次设置读回调
20
}
21
22
void onReadClosed(AsyncSocket* sock) noexcept override {
23
LOG(INFO) << "Connection closed by server.";
24
delete this;
25
}
26
27
void onReadError(AsyncSocket* sock, const AsyncSocketException& ex) noexcept override {
28
LOG(ERROR) << "Read error: " << ex.what();
29
delete this;
30
}
31
32
private:
33
void processData(IOBufQueue& readQueue) {
34
while (!readQueue.empty()) {
35
auto buf = readQueue.front();
36
readQueue.pop_front();
37
StringPiece data(reinterpret_cast<const char*>(buf->data()), buf->length());
38
LOG(INFO) << "Received from server: " << data;
39
}
40
}
41
42
AsyncSocket* sock_;
43
};
44
45
int main() {
46
EventBase evb;
47
AsyncSocket::UniquePtr clientSocket = AsyncSocket::createSocket(&evb);
48
SocketAddress serverAddress("127.0.0.1", 8080);
49
50
clientSocket->connect(serverAddress).then([&]() {
51
LOG(INFO) << "Connected to server.";
52
clientSocket->setReadCB(new EchoClientReadCallback(clientSocket.get()));
53
54
// Send messages
55
std::vector<String> messages = {"Hello Server!", "How are you?", "Goodbye!"};
56
for (const auto& msg : messages) {
57
IOBufQueue writeQueue;
58
writeQueue.append(IOBuf::copyBuffer(msg));
59
clientSocket->write(writeQueue).then([msg](size_t bytesWritten) {
60
LOG(INFO) << "Sent '" << msg << "', " << bytesWritten << " bytes.";
61
});
62
}
63
}).thenError(folly::tag_exception<AsyncSocketException>([](const AsyncSocketException& ex) {
64
LOG(ERROR) << "Connect error: " << ex.what();
65
}));
66
67
evb.loopForever();
68
return 0;
69
}
编译和运行示例代码：
1
# 编译 (需要链接 folly glog)
2
g++ -std=c++17 EchoServer.cpp -o EchoServer -lfolly -lglog
3
g++ -std=c++17 EchoClient.cpp -o EchoClient -lfolly -lglog
4
5
# 运行服务器
6
./EchoServer
7
8
# 运行客户端 (在另一个终端)
9
./EchoClient
通过这个简单的 Echo 服务器和客户端示例，可以初步了解 folly::Socket 的基本用法，包括创建 socket、绑定地址、监听连接、接受连接、客户端连接、发送和接收数据等。在实际应用中，可以根据具体需求，进一步扩展和完善网络应用程序的功能。
6.3 Futures for Networking：异步网络操作的优雅处理 (Futures for Networking: Elegant Handling of Asynchronous Network Operations)
在上一节中，我们已经初步接触了 folly::Future 在 folly::Socket 异步操作中的应用。folly::Future 是 Folly 库中用于处理异步操作结果的核心组件，它提供了一种优雅、高效、类型安全的方式来管理异步操作，并支持链式调用、错误处理、组合和取消等高级功能。本节将深入探讨如何使用 folly::Future 来处理 folly::Socket 的异步网络操作，构建更加健壮和易于维护的网络应用程序。
6.3.1 folly::Future 基础回顾
在深入网络编程应用之前，我们先简要回顾一下 folly::Future 的基本概念和用法。
① folly::Future<T>：
folly::Future<T> 代表一个异步操作的最终结果，类型参数 T 表示结果的类型。当异步操作完成时，Future 会持有一个类型为 T 的值，或者一个异常。
② folly::Promise<T>：
folly::Promise<T> 用于设置 Future 的结果。folly::Promise 和 folly::Future 通常配对使用，Promise 用于在异步操作完成时设置 Future 的值或异常。
③ .then() 链式调用：
.then() 方法是 folly::Future 最常用的方法之一，用于在 Future 完成后执行后续操作。.then() 方法接受一个回调函数，当 Future 完成时，回调函数会被调用，并将 Future 的结果作为参数传递给回调函数。.then() 方法返回一个新的 Future，表示后续操作的结果，从而可以实现链式调用。
④ 错误处理 (.thenError(), .catchError())：
folly::Future 提供了多种错误处理方法，例如 .thenError() 和 .catchError()，用于处理 Future 链中的异常。.thenError() 接受一个错误处理回调函数，只在 Future 链中发生异常时被调用。.catchError() 类似于 .thenError()，但返回一个新的 Future，可以用于从错误中恢复或抛出新的异常。
⑤ 组合 Future (folly::collect(), folly::whenAll())：
Folly 提供了 folly::collect() 和 folly::whenAll() 等函数，用于组合多个 Future，等待所有 Future 完成或任意一个 Future 完成。
⑥ 取消 Future (setCancellationCallback())：
folly::Future 支持取消操作。可以使用 setCancellationCallback() 方法注册一个取消回调函数，当 Future 被取消时，回调函数会被调用，可以执行清理操作。
6.3.2 folly::Future 在 folly::Socket 异步操作中的应用
folly::Socket 的所有异步操作，例如 connect、accept、write、read 等，都返回 folly::Future。这使得我们可以使用 folly::Future 的强大功能来管理和编排异步网络操作。
① 连接操作 (connect)：
folly::AsyncSocket::connect() 方法返回 folly::Future<Unit>，表示连接操作的结果。可以使用 .then() 方法在连接成功后执行后续操作，使用 .thenError() 或 .catchError() 方法处理连接失败的情况。
1
clientSocket->connect(serverAddress).then([&]() {
2
// 连接成功，发送数据
3
return sendMessage(clientSocket.get(), "Hello Server!");
4
}).thenError(folly::tag_exception<AsyncSocketException>([](const AsyncSocketException& ex) {
5
// 连接失败，处理错误
6
LOG(ERROR) << "Connect error: " << ex.what();
7
}));
② 写入操作 (write)：
folly::AsyncSocket::write() 方法返回 folly::Future<size_t>，表示写入操作的结果，返回实际写入的字节数。可以使用 .then() 方法在写入完成后执行后续操作，例如发送下一个消息或关闭连接。
1
IOBufQueue writeQueue;
2
writeQueue.append(IOBuf::copyBuffer("Hello Client!"));
3
clientSocket->write(writeQueue).then([](size_t bytesWritten) {
4
// 写入成功，bytesWritten 是实际写入的字节数
5
LOG(INFO) << "Sent " << bytesWritten << " bytes.";
6
// ... 后续操作 ...
7
});
③ 读取操作 (read)：
虽然 folly::AsyncSocket::read() 方法本身不直接返回 Future，但我们可以结合 folly::Promise 和 ReadCallback 接口，将读取操作封装成 Future。
1
folly::Future<IOBufQueue> asyncRead(folly::AsyncSocket* sock) {
2
auto promise = std::make_shared<folly::Promise<IOBufQueue>>();
3
class ReadFutureCallback : public folly::AsyncSocket::ReadCallback {
4
public:
5
ReadFutureCallback(folly::AsyncSocket* sock, std::shared_ptr<folly::Promise<IOBufQueue>> promise)
6
: sock_(sock), promise_(promise) {}
7
8
void onReadDataAvailable(folly::AsyncSocket* sock) noexcept override {
9
IOBufQueue readQueue;
10
sock->recv(&readQueue);
11
promise_->setValue(std::move(readQueue)); // 设置 Future 的结果
12
delete this; // 读取完成后释放回调对象
13
}
14
15
void onReadClosed(folly::AsyncSocket* sock) noexcept override {
16
promise_->setException(std::runtime_error("Connection closed"));
17
delete this;
18
}
19
20
void onReadError(folly::AsyncSocket* sock, const folly::AsyncSocketException& ex) noexcept override {
21
promise_->setException(ex);
22
delete this;
23
}
24
25
private:
26
folly::AsyncSocket* sock_;
27
std::shared_ptr<folly::Promise<IOBufQueue>> promise_;
28
};
29
30
sock->setReadCB(new ReadFutureCallback(sock, promise));
31
return promise->getFuture();
32
}
33
34
// 使用 asyncRead
35
asyncRead(clientSocket.get()).then([](IOBufQueue readQueue) {
36
// 读取成功，处理 readQueue
37
processData(readQueue);
38
}).thenError([](const std::exception& ex) {
39
// 读取失败，处理错误
40
LOG(ERROR) << "Read error: " << ex.what();
41
});
在上面的示例中，asyncRead 函数将 folly::AsyncSocket 的读取操作封装成一个返回 folly::Future<IOBufQueue> 的异步函数。它创建了一个 folly::Promise 和一个自定义的 ReadCallback，当 onReadDataAvailable 方法被调用时，将接收到的数据设置到 Promise 中，从而完成 Future。
6.3.3 使用 .then() 链式调用编排异步操作
folly::Future 的 .then() 链式调用可以用于编排复杂的异步操作流程。例如，客户端可以先连接到服务器，然后发送消息，接收服务器的响应，最后关闭连接。
1
folly::AsyncSocket::UniquePtr clientSocket = folly::AsyncSocket::createSocket(evb);
2
folly::SocketAddress serverAddress("127.0.0.1", 8080);
3
4
clientSocket->connect(serverAddress).then([&]() {
5
LOG(INFO) << "Connected to server.";
6
return sendMessage(clientSocket.get(), "Request Data"); // 发送请求消息
7
}).then([&](size_t bytesWritten) {
8
LOG(INFO) << "Sent request, waiting for response...";
9
return asyncRead(clientSocket.get()); // 异步读取响应
10
}).then([](IOBufQueue responseQueue) {
11
LOG(INFO) << "Received response: " << StringPiece(reinterpret_cast<const char*>(responseQueue.front()->data()), responseQueue.front()->length());
12
// ... 处理响应数据 ...
13
}).then([&]() {
14
LOG(INFO) << "Closing connection.";
15
clientSocket->close(); // 关闭连接
16
}).thenError(folly::tag_exception<AsyncSocketException>([](const AsyncSocketException& ex) {
17
LOG(ERROR) << "Error during communication: " << ex.what();
18
}));
通过 .then() 链式调用，可以将异步操作串联起来，形成清晰的异步流程。每个 .then() 方法的回调函数都返回一个 Future，表示下一步的异步操作，从而实现了异步操作的顺序执行。
6.3.4 错误处理与异常传播
folly::Future 的错误处理机制可以有效地处理异步操作链中的错误。如果在 Future 链中的任何一个环节发生异常，异常会被传播到后续的 .thenError() 或 .catchError() 方法中进行处理。
1
clientSocket->connect(serverAddress).then([&]() {
2
// ...
3
return asyncRead(clientSocket.get());
4
}).then([](IOBufQueue responseQueue) {
5
// ...
6
throw std::runtime_error("Error processing response"); // 模拟处理响应时发生错误
7
}).thenError([](const std::exception& ex) {
8
// 捕获并处理异常
9
LOG(ERROR) << "Error in Future chain: " << ex.what();
10
});
在上面的示例中，如果在处理响应数据时抛出异常，异常会被传播到最后的 .thenError() 方法中进行处理。这样可以保证异步操作链中的错误能够被及时捕获和处理，避免程序崩溃或状态异常。
6.3.5 取消异步操作
folly::Future 支持取消操作。可以使用 setCancellationCallback() 方法注册一个取消回调函数，当 Future 被取消时，回调函数会被调用，可以执行清理操作，例如关闭 socket 连接、释放资源等。
1
auto future = clientSocket->connect(serverAddress).then([&]() {
2
// ...
3
return asyncRead(clientSocket.get());
4
});
5
6
future.setCancellationCallback([&]() {
7
LOG(WARNING) << "Connection attempt cancelled.";
8
clientSocket->close(); // 取消连接时关闭 socket
9
});
10
11
// ... 在需要取消操作时调用 future.cancel()
12
// future.cancel();
在上面的示例中，当 Future 被取消时，注册的取消回调函数会被调用，在回调函数中可以关闭 socket 连接，释放相关资源。取消操作可以用于处理超时、用户主动中断等场景，提高程序的健壮性和用户体验。
总结来说，folly::Future 为 folly::Socket 的异步网络操作提供了强大的支持。通过使用 folly::Future，我们可以以一种优雅、高效、类型安全的方式管理异步操作，编排复杂的异步流程，处理错误和异常，以及取消异步操作。folly::Future 大大简化了异步网络编程的复杂性，提高了代码的可读性和可维护性，是构建高性能、高可靠性网络应用程序的利器。
6.4 协程在Folly网络编程中的应用 (Coroutines in Folly Network Programming)
C++20 引入了协程 (coroutines) 特性，为异步编程带来了新的范式。协程允许开发者以同步的代码风格编写异步代码，极大地提高了异步代码的可读性和可维护性。Folly 库也积极拥抱协程，并在网络编程组件中提供了对协程的支持。本节将介绍如何在 Folly 网络编程中使用协程，以及协程如何简化异步网络代码的编写。
6.4.1 C++ 协程基础
在深入 Folly 协程应用之前，我们先简要回顾一下 C++ 协程的基本概念。
① co_await 关键字：
co_await 是协程的核心关键字，用于挂起 (suspend) 当前协程的执行，等待一个异步操作完成，然后恢复 (resume) 协程的执行。co_await 表达式通常接受一个 awaitable 对象，例如 folly::Future。
② co_return 关键字：
co_return 用于从协程中返回值，并结束协程的执行。类似于普通函数的 return 语句。
③ co_yield 关键字：
co_yield 用于在协程中产生一个值，并挂起协程的执行，等待下次恢复。通常用于实现生成器 (generator) 或迭代器 (iterator)。
④ 协程帧 (Coroutine Frame)：
当协程被挂起时，协程的状态（包括局部变量、程序计数器等）会被保存到一个协程帧中。当协程恢复执行时，会从协程帧中恢复状态。
⑤ Awaitable 对象：
co_await 表达式需要一个 awaitable 对象。Awaitable 对象需要实现 await_ready、await_suspend 和 await_resume 三个方法，用于控制协程的挂起和恢复。folly::Future 就是一个 awaitable 对象。
6.4.2 Folly 协程支持
Folly 库提供了对 C++ 协程的良好支持，主要体现在以下几个方面：
① folly::coro::co_await(Future<T>)：
Folly 提供了 folly::coro::co_await(Future<T>) 函数，可以将 folly::Future<T> 转换为 awaitable 对象，使得可以在协程中使用 co_await 关键字等待 Future 完成。
② folly::coro::Task<T>：
folly::coro::Task<T> 是 Folly 提供的协程类型，类似于 std::future<T>，用于表示协程的执行结果。可以使用 folly::coro::Task<T> 来定义协程函数，并使用 .start() 方法启动协程。
③ folly::coro::blockingWait(Task<T>)：
folly::coro::blockingWait(Task<T>) 函数用于阻塞等待协程执行完成，并返回协程的结果。通常用于在主线程中等待协程结果。
6.4.3 协程在 folly::Socket 网络编程中的应用
使用协程可以极大地简化 folly::Socket 的异步网络编程代码。可以将原本需要使用 .then() 链式调用和回调函数编写的异步代码，转换为类似于同步代码的风格。
① 使用协程简化连接操作：
1
folly::coro::Task<void> connectToServer(folly::AsyncSocket* clientSocket, const folly::SocketAddress& serverAddress) {
2
LOG(INFO) << "Connecting to server...";
3
try {
4
co_await folly::coro::co_await(clientSocket->connect(serverAddress)); // 使用 co_await 等待连接完成
5
LOG(INFO) << "Connected to server.";
6
} catch (const folly::AsyncSocketException& ex) {
7
LOG(ERROR) << "Connect error: " << ex.what();
8
throw; // 重新抛出异常
9
}
10
}
在上面的示例中，connectToServer 函数是一个协程函数，使用 co_await folly::coro::co_await(clientSocket->connect(serverAddress)) 语句等待连接操作完成。代码风格类似于同步代码，但实际上 clientSocket->connect() 仍然是异步操作，协程会在 co_await 处挂起，等待连接完成，然后恢复执行。
② 使用协程简化发送和接收数据：
1
folly::coro::Task<void> sendAndReceive(folly::AsyncSocket* clientSocket) {
2
try {
3
// 发送数据
4
IOBufQueue writeQueue;
5
writeQueue.append(IOBuf::copyBuffer("Request Data"));
6
co_await folly::coro::co_await(clientSocket->write(writeQueue));
7
LOG(INFO) << "Sent request, waiting for response...";
8
9
// 接收数据
10
IOBufQueue readQueue = co_await asyncReadCoroutine(clientSocket); // 使用协程版本的 asyncRead
11
LOG(INFO) << "Received response: " << StringPiece(reinterpret_cast<const char*>(readQueue.front()->data()), readQueue.front()->length());
12
// ... 处理响应数据 ...
13
14
} catch (const std::exception& ex) {
15
LOG(ERROR) << "Error during communication: " << ex.what();
16
throw;
17
}
18
}
19
20
// 协程版本的 asyncRead
21
folly::coro::Task<IOBufQueue> asyncReadCoroutine(folly::AsyncSocket* sock) {
22
auto promise = std::make_shared<folly::Promise<IOBufQueue>>();
23
class ReadCoroutineCallback : public folly::AsyncSocket::ReadCallback {
24
public:
25
ReadCoroutineCallback(folly::AsyncSocket* sock, std::shared_ptr<folly::Promise<IOBufQueue>> promise)
26
: sock_(sock), promise_(promise) {}
27
28
void onReadDataAvailable(folly::AsyncSocket* sock) noexcept override {
29
IOBufQueue readQueue;
30
sock->recv(&readQueue);
31
promise_->setValue(std::move(readQueue));
32
delete this;
33
}
34
35
void onReadClosed(folly::AsyncSocket* sock) noexcept override {
36
promise_->setException(std::runtime_error("Connection closed"));
37
delete this;
38
}
39
40
void onReadError(folly::AsyncSocket* sock, const folly::AsyncSocketException& ex) noexcept override {
41
promise_->setException(ex);
42
delete this;
43
}
44
45
private:
46
folly::AsyncSocket* sock_;
47
std::shared_ptr<folly::Promise<IOBufQueue>> promise_;
48
};
49
50
sock->setReadCB(new ReadCoroutineCallback(sock, promise));
51
co_return co_await promise->getFuture(); // 返回 Future，并使用 co_await 转换为协程 awaitable
52
}
在上面的示例中，sendAndReceive 函数使用协程以同步风格编写了发送请求和接收响应的异步流程。asyncReadCoroutine 函数是 asyncRead 的协程版本，它返回 folly::coro::Task<IOBufQueue>，并在内部使用 co_await promise->getFuture() 将 Future 转换为协程 awaitable 对象。
③ 主函数中使用协程：
1
int main() {
2
EventBase evb;
3
AsyncSocket::UniquePtr clientSocket = AsyncSocket::createSocket(&evb);
4
SocketAddress serverAddress("127.0.0.1", 8080);
5
6
folly::coro::blockingWait( // 阻塞等待协程完成
7
connectToServer(clientSocket.get(), serverAddress)
8
.thenValue([&]() { return sendAndReceive(clientSocket.get()); }) // 链式调用协程
9
.thenValue([&]() { LOG(INFO) << "Communication finished."; clientSocket->close(); })
10
.thenError([](const std::exception& ex) { LOG(ERROR) << "Error: " << ex.what(); }));
11
12
evb.loopForever();
13
return 0;
14
}
在主函数中，使用 folly::coro::blockingWait() 函数阻塞等待协程 connectToServer 和 sendAndReceive 执行完成。可以使用 .thenValue() 链式调用多个协程，实现复杂的异步流程。
6.4.4 协程的优势与适用场景
使用协程在 Folly 网络编程中具有以下优势：
① 代码可读性：协程可以将异步代码写成类似于同步代码的风格，极大地提高了代码的可读性和可理解性。避免了 .then() 链式调用和回调函数带来的代码碎片化和逻辑分散问题。
② 代码维护性：同步风格的代码更易于维护和调试。协程使得异步代码的调试和错误追踪更加容易。
③ 异常处理：协程可以使用 try-catch 语句进行异常处理，与同步代码的异常处理方式一致，更加直观和方便。
④ 简化异步流程：对于复杂的异步流程，使用协程可以更加清晰地表达流程逻辑，降低代码复杂度。
协程适用于以下场景：
① 复杂的异步流程：当异步流程比较复杂，需要进行多个异步操作的组合和编排时，协程可以简化代码，提高可读性。
② 需要同步风格异步代码：对于习惯于同步编程的开发者，协程可以降低异步编程的学习曲线，提高开发效率。
③ 需要更好的错误处理：协程的 try-catch 异常处理机制更加直观和方便，适用于需要 robust 错误处理的场景。
需要注意的是，协程虽然简化了异步代码的编写，但并没有改变异步编程的本质。协程仍然是基于异步 I/O 和事件循环的，只是在语法层面提供了一种更高级的抽象。理解异步编程的基本原理仍然是使用协程进行高效网络编程的基础。
6.5 网络安全：SSL/TLS集成 (Network Security: SSL/TLS Integration)
在现代网络应用中，网络安全至关重要。SSL/TLS (Secure Sockets Layer/Transport Layer Security) 协议是目前最广泛使用的网络安全协议，用于在客户端和服务器之间建立加密连接，保护数据传输的机密性和完整性。Folly 库的 folly::Socket 提供了对 SSL/TLS 的集成支持，可以方便地构建安全的网络应用程序。本节将介绍如何在 Folly 网络编程中集成 SSL/TLS，实现安全的网络通信。
6.5.1 SSL/TLS 协议简介
SSL/TLS 协议位于 TCP/IP 协议栈的应用层和传输层之间，为应用层协议（例如 HTTP、SMTP、FTP 等）提供安全保障。SSL/TLS 协议主要提供以下安全功能：
① 机密性 (Confidentiality)：通过加密算法对数据进行加密，防止数据在传输过程中被窃听。常用的加密算法包括 AES、DES、RC4 等。
② 完整性 (Integrity)：通过消息认证码 (MAC) 或数字签名等技术，保证数据在传输过程中没有被篡改。常用的 MAC 算法包括 HMAC-SHA1、HMAC-SHA256 等。
③ 身份验证 (Authentication)：通过数字证书 (digital certificate) 和公钥基础设施 (PKI) 等技术，验证通信双方的身份，防止中间人攻击 (Man-in-the-Middle Attack)。
6.5.2 Folly SSL/TLS 支持
Folly 库通过 folly::SSLContext 和 folly::AsyncSSLSocket 类提供了 SSL/TLS 支持。
① folly::SSLContext：
folly::SSLContext 类用于管理 SSL/TLS 上下文，包括证书、密钥、加密算法、协议版本等配置信息。可以使用 folly::SSLContext 创建服务器端和客户端的 SSL/TLS 上下文。
② folly::AsyncSSLSocket：
folly::AsyncSSLSocket 类是 folly::AsyncSocket 的子类，提供了 SSL/TLS 加密功能的 socket。可以使用 folly::AsyncSSLSocket 创建安全的 socket 连接。
6.5.3 服务器端 SSL/TLS 配置
服务器端需要配置 SSL/TLS 证书和密钥，才能建立安全的 SSL/TLS 连接。
① 创建 folly::SSLContext：
1
auto sslContext = std::make_shared<folly::SSLContext>();
② 加载证书和密钥：
1
sslContext->loadCertFromFile("server.crt"); // 加载服务器证书
2
sslContext->loadKeyFromFile("server.key"); // 加载服务器私钥
需要将服务器证书文件 (server.crt) 和私钥文件 (server.key) 放在程序运行目录下，或者指定正确的路径。可以使用 OpenSSL 等工具生成证书和密钥。
③ 创建 folly::AsyncServerSocket 并设置 SSL 上下文：
1
AsyncServerSocket::UniquePtr serverSocket = AsyncServerSocket::createSocket(&evb);
2
serverSocket->setSSLContext(sslContext); // 设置 SSL 上下文
④ 接受 SSL/TLS 连接：
服务器端接受连接的方式与非 SSL/TLS 连接类似，但接受的 socket 类型是 folly::AsyncSSLSocket。
1
serverSocket->accept().then([&](AsyncSocket::UniquePtr sock) {
2
// 连接建立成功，sock 是 AsyncSSLSocket 类型
3
AsyncSSLSocket* sslSock = dynamic_cast<AsyncSSLSocket*>(sock.get());
4
if (sslSock) {
5
handleSslConnection(std::move(sock)); // 处理 SSL/TLS 连接
6
} else {
7
LOG(ERROR) << "Failed to cast to AsyncSSLSocket";
8
}
9
serverSocket->accept().then( ... ); // 递归 accept
10
});
在 .then() 回调函数中，需要将 AsyncSocket::UniquePtr 转换为 AsyncSSLSocket*，才能使用 SSL/TLS 相关的功能。
6.5.4 客户端 SSL/TLS 配置
客户端也需要配置 SSL/TLS 上下文，才能建立安全的 SSL/TLS 连接。客户端的配置相对简单，通常只需要配置 SSL 上下文，并可以选择是否验证服务器证书。
① 创建 folly::SSLContext：
1
auto sslContext = std::make_shared<folly::SSLContext>();
② （可选）配置证书验证：
如果需要验证服务器证书，可以使用 loadTrustedCertificatesFromFile 方法加载信任的证书颁发机构 (CA) 证书。
1
sslContext->loadTrustedCertificatesFromFile("ca.crt"); // 加载 CA 证书
2
sslContext->setVerificationOption(SSLContext::VerificationOption::VERIFY_PEER); // 启用证书验证
如果不需要验证服务器证书（例如在测试环境中），可以跳过证书验证配置。
③ 创建 folly::AsyncSSLSocket 并设置 SSL 上下文：
1
AsyncSSLSocket::UniquePtr clientSocket = AsyncSSLSocket::createSocket(&evb, sslContext); // 创建 AsyncSSLSocket 并设置 SSL 上下文
④ 连接到 SSL/TLS 服务器：
客户端连接到服务器的方式与非 SSL/TLS 连接类似，但创建的是 folly::AsyncSSLSocket 对象。
1
clientSocket->connect(serverAddress).then([&]() {
2
// SSL/TLS 连接建立成功
3
sendMessage(clientSocket.get(), "Hello Secure Server!");
4
}).thenError(folly::tag_exception<AsyncSocketException>([](const AsyncSocketException& ex) {
5
// 连接失败
6
LOG(ERROR) << "Connect error: " << ex.what();
7
}));
6.5.5 SSL/TLS 加密通信
一旦 SSL/TLS 连接建立成功，后续的数据传输都会自动进行加密和解密，应用程序无需关心底层的加密细节。可以使用 folly::AsyncSSLSocket 的 write 和 read 方法进行安全的发送和接收数据，与非 SSL/TLS 连接的操作方式相同。
1
// 发送加密数据
2
IOBufQueue writeQueue;
3
writeQueue.append(IOBuf::copyBuffer("Secure Message"));
4
clientSocket->write(writeQueue).then([](size_t bytesWritten) {
5
LOG(INFO) << "Sent secure message.";
6
});
7
8
// 接收加密数据 (使用 ReadCallback)
9
class SecureReadCallback : public AsyncSocket::ReadCallback {
10
// ... 实现 ReadCallback 接口，与非 SSL/TLS 连接类似 ...
11
};
12
clientSocket->setReadCB(new SecureReadCallback(clientSocket.get()));
6.5.6 SSL/TLS 性能考量
SSL/TLS 加密和解密操作会引入一定的性能开销。在构建高性能网络应用时，需要考虑 SSL/TLS 对性能的影响。
① CPU 消耗：SSL/TLS 加密和解密算法会消耗 CPU 资源。选择合适的加密算法和密钥长度可以在性能和安全之间取得平衡。
② 握手开销：SSL/TLS 握手过程需要进行多次网络交互，会增加连接建立的延迟。可以使用会话复用 (session reuse) 等技术来减少握手开销。
③ 网络带宽：SSL/TLS 加密后的数据会增加一定的长度，可能会占用更多的网络带宽。
在实际应用中，需要根据具体的安全需求和性能要求，合理配置 SSL/TLS 参数，并进行性能测试和优化。
6.5.7 示例代码：简单的 SSL/TLS Echo 服务器和客户端
下面是一个简单的 SSL/TLS Echo 服务器和客户端示例，演示了如何在 Folly 中集成 SSL/TLS。
SSL/TLS Echo 服务器 (SslEchoServer.cpp)
1
#include <folly/io/async/AsyncServerSocket.h>
2
#include <folly/io/async/AsyncSSLSocket.h>
3
#include <folly/io/async/SSLContext.h>
4
#include <folly/io/IOBufQueue.h>
5
#include <folly/futures/Future.h>
6
#include <folly/SocketAddress.h>
7
#include <folly/EventBase.h>
8
#include <folly/String.h>
9
#include <glog/logging.h>
10
11
using namespace folly;
12
13
// EchoReadCallback 和 main 函数与 EchoServer.cpp 类似，只需修改 socket 类型为 AsyncSSLSocket
14
15
class SslEchoReadCallback : public AsyncSocket::ReadCallback { // 注意基类是 AsyncSocket
16
public:
17
explicit SslEchoReadCallback(AsyncSocket* sock) : sock_(sock) {} // 注意参数类型是 AsyncSocket*
18
19
void onReadDataAvailable(AsyncSocket* sock) noexcept override { // 注意参数类型是 AsyncSocket*
20
IOBufQueue readQueue;
21
sock->recv(&readQueue);
22
processData(readQueue);
23
sock->setReadCB(this);
24
}
25
26
void onReadClosed(AsyncSocket* sock) noexcept override {
27
LOG(INFO) << "SSL Connection closed by peer.";
28
delete this;
29
}
30
31
void onReadError(AsyncSocket* sock, const AsyncSocketException& ex) noexcept override {
32
LOG(ERROR) << "SSL Read error: " << ex.what();
33
delete this;
34
}
35
36
private:
37
void processData(IOBufQueue& readQueue) {
38
while (!readQueue.empty()) {
39
auto buf = readQueue.front();
40
readQueue.pop_front();
41
StringPiece data(reinterpret_cast<const char*>(buf->data()), buf->length());
42
LOG(INFO) << "SSL Received: " << data;
43
44
// Echo back
45
IOBufQueue writeQueue;
46
writeQueue.append(IOBuf::copyBuffer(data));
47
sock_->write(writeQueue).then([](size_t bytesWritten) {
48
LOG(INFO) << "SSL Echoed back " << bytesWritten << " bytes.";
49
});
50
}
51
}
52
53
AsyncSocket* sock_; // 注意成员类型是 AsyncSocket*
54
};
55
56
int main() {
57
EventBase evb;
58
auto sslContext = std::make_shared<SSLContext>();
59
sslContext->loadCertFromFile("server.crt"); // 替换为你的服务器证书路径
60
sslContext->loadKeyFromFile("server.key"); // 替换为你的服务器私钥路径
61
62
AsyncServerSocket::UniquePtr serverSocket = AsyncServerSocket::createSocket(&evb);
63
serverSocket->setSSLContext(sslContext);
64
SocketAddress address("0.0.0.0", 8443); // 使用 8443 端口 (HTTPS 默认端口)
65
serverSocket->bind(address);
66
serverSocket->listen(128);
67
68
serverSocket->accept().then([&](AsyncSocket::UniquePtr sock) {
69
AsyncSSLSocket* sslSock = dynamic_cast<AsyncSSLSocket*>(sock.get());
70
if (sslSock) {
71
LOG(INFO) << "SSL Accepted connection from " << sslSock->getPeerAddress().describe();
72
sslSock->setReadCB(new SslEchoReadCallback(sslSock)); // 注意传递的是 sslSock
73
serverSocket->accept().then( ... ); // 递归 accept
74
} else {
75
LOG(ERROR) << "Failed to cast to AsyncSSLSocket";
76
}
77
});
78
79
LOG(INFO) << "SSL Echo server started on port 8443";
80
evb.loopForever();
81
return 0;
82
}
SSL/TLS Echo 客户端 (SslEchoClient.cpp)
1
#include <folly/io/async/AsyncSSLSocket.h>
2
#include <folly/io/async/SSLContext.h>
3
#include <folly/io/IOBufQueue.h>
4
#include <folly/futures/Future.h>
5
#include <folly/SocketAddress.h>
6
#include <folly/EventBase.h>
7
#include <folly/String.h>
8
#include <glog/logging.h>
9
10
using namespace folly;
11
12
// EchoClientReadCallback 和 main 函数与 EchoClient.cpp 类似，只需修改 socket 类型为 AsyncSSLSocket
13
14
class SslEchoClientReadCallback : public AsyncSocket::ReadCallback { // 注意基类是 AsyncSocket
15
public:
16
explicit SslEchoClientReadCallback(AsyncSocket* sock) : sock_(sock) {} // 注意参数类型是 AsyncSocket*
17
18
void onReadDataAvailable(AsyncSocket* sock) noexcept override { // 注意参数类型是 AsyncSocket*
19
IOBufQueue readQueue;
20
sock->recv(&readQueue);
21
processData(readQueue);
22
sock->setReadCB(this);
23
}
24
25
void onReadClosed(AsyncSocket* sock) noexcept override {
26
LOG(INFO) << "SSL Connection closed by server.";
27
delete this;
28
}
29
30
void onReadError(AsyncSocket* sock, const AsyncSocketException& ex) noexcept override {
31
LOG(ERROR) << "SSL Read error: " << ex.what();
32
delete this;
33
}
34
35
private:
36
void processData(IOBufQueue& readQueue) {
37
while (!readQueue.empty()) {
38
auto buf = readQueue.front();
39
readQueue.pop_front();
40
StringPiece data(reinterpret_cast<const char*>(buf->data()), buf->length());
41
LOG(INFO) << "SSL Received from server: " << data;
42
}
43
}
44
45
AsyncSocket* sock_; // 注意成员类型是 AsyncSocket*
46
};
47
48
int main() {
49
EventBase evb;
50
auto sslContext = std::make_shared<SSLContext>();
51
// sslContext->loadTrustedCertificatesFromFile("ca.crt"); // 可选: 加载 CA 证书进行服务器证书验证
52
// sslContext->setVerificationOption(SSLContext::VerificationOption::VERIFY_PEER); // 可选: 启用证书验证
53
54
AsyncSSLSocket::UniquePtr clientSocket = AsyncSSLSocket::createSocket(&evb, sslContext); // 创建 AsyncSSLSocket 并设置 SSL 上下文
55
SocketAddress serverAddress("127.0.0.1", 8443); // 使用 8443 端口
56
57
clientSocket->connect(serverAddress).then([&]() {
58
LOG(INFO) << "SSL Connected to server.";
59
clientSocket->setReadCB(new SslEchoClientReadCallback(clientSocket.get()));
60
61
// Send messages
62
std::vector<String> messages = {"Hello Secure Server!", "How are you?", "Goodbye!"};
63
for (const auto& msg : messages) {
64
IOBufQueue writeQueue;
65
writeQueue.append(IOBuf::copyBuffer(msg));
66
clientSocket->write(writeQueue).then([msg](size_t bytesWritten) {
67
LOG(INFO) << "SSL Sent '" << msg << "', " << bytesWritten << " bytes.";
68
});
69
}
70
}).thenError(folly::tag_exception<AsyncSocketException>([](const AsyncSocketException& ex) {
71
LOG(ERROR) << "SSL Connect error: " << ex.what();
72
}));
73
74
evb.loopForever();
75
return 0;
76
}
编译和运行 SSL/TLS 示例代码：
1
# 生成服务器证书和私钥 (使用 OpenSSL)
2
openssl req -x509 -newkey rsa:2048 -keyout server.key -out server.crt -days 365 -subj '/CN=localhost'
3
4
# 编译 (需要链接 folly glog crypto)
5
g++ -std=c++17 SslEchoServer.cpp -o SslEchoServer -lfolly -lglog -lcrypto
6
g++ -std=c++17 SslEchoClient.cpp -o SslEchoClient -lfolly -lglog -lcrypto
7
8
# 运行服务器
9
./SslEchoServer
10
11
# 运行客户端 (在另一个终端)
12
./SslEchoClient
运行 SSL/TLS 示例代码前，需要先生成服务器证书和私钥。可以使用 OpenSSL 工具生成自签名证书用于测试。在生产环境中，应该使用受信任的 CA 颁发的证书。
通过这个 SSL/TLS Echo 服务器和客户端示例，可以了解如何在 Folly 网络编程中集成 SSL/TLS，构建安全的网络应用程序。在实际应用中，可以根据具体的安全需求，配置更完善的 SSL/TLS 参数，例如选择合适的加密算法、协议版本、证书验证方式等。
END_OF_CHAPTER
7. chapter 7： Folly并发与并行：充分利用多核性能 (Folly Concurrency and Parallelism: Fully Utilizing Multi-Core Performance)
7.1 Futures与Promises进阶：组合与控制流 (Advanced Futures and Promises: Composition and Control Flow)
在之前的章节中，我们已经了解了 Futures（期物） 和 Promises（承诺） 的基本概念，它们是 Folly 异步编程的基石。本节将深入探讨 Futures 和 Promises 的高级用法，重点介绍如何进行 组合（Composition） 和 控制流管理（Control Flow Management），以便构建更复杂、更健壮的异步程序。
7.1.1 Futures的组合 (Composition of Futures)
Futures 的强大之处在于其组合能力，允许我们将多个异步操作串联或并行执行，并对结果进行处理。Folly 提供了丰富的 API 来实现 Futures 的组合，主要包括以下几种方式：
① then: 链式调用，将一个 Future 的结果作为下一个 Future 的输入。这是最基本的组合方式，用于串行执行异步操作。
1
folly::future<int> future1 = ...;
2
auto future2 = future1.then([](int result) {
3
// 使用 future1 的结果 result 进行下一步异步操作
4
return folly::makeFuture(result * 2);
5
});
在上述代码中，future2 的计算依赖于 future1 的结果。只有当 future1 完成后，then 中提供的 lambda 函数才会被执行，并将 future1 的结果 result 作为输入。then 返回一个新的 Future，其类型由 lambda 函数的返回值类型决定。
② map: 对 Future 的结果进行同步转换，返回一个新的 Future，其结果是转换后的值。map 类似于函数式编程中的 map 操作。
1
folly::future<int> future1 = ...;
2
auto future2 = future1.map([](int result) {
3
// 对 future1 的结果 result 进行同步转换
4
return result + 10;
5
});
map 操作不会引入新的异步操作，它只是对现有 Future 的结果进行同步处理。如果转换函数本身是耗时的，map 操作可能会阻塞事件循环，因此通常用于轻量级的同步转换。
③ flatMap: 类似于 map，但转换函数返回的是一个 Future。flatMap 用于将一个 Future 的结果映射为一个新的 Future，并展平（flatten）结果，避免 Future 的嵌套。
1
folly::future<int> future1 = ...;
2
auto future2 = future1.flatMap([](int result) {
3
// 根据 future1 的结果 result 返回一个新的 Future
4
return fetchDataFromDB(result); // fetchDataFromDB 返回 folly::future<Data>
5
});
flatMap 是构建复杂异步流程的关键。它可以将多个异步操作串联起来，每个操作的执行都依赖于前一个操作的结果，最终得到一个扁平的 Future 链。
④ andThen: 类似于 then，但 andThen 接受的函数不返回值（或者返回 void 或 folly::Unit）。andThen 主要用于在 Future 完成后执行一些副作用操作，例如日志记录、资源清理等。
1
folly::future<int> future1 = ...;
2
auto future2 = future1.andThen([]() {
3
// 在 future1 完成后执行一些副作用操作，例如记录日志
4
LOG(INFO) << "Future 1 completed";
5
});
andThen 返回的 Future 与原始 Future 具有相同的结果类型和值。它主要用于在异步流程中插入一些额外的同步操作，而不会改变异步流程的结果。
⑤ orElse: 处理 Future 失败的情况。如果原始 Future 失败，orElse 提供的函数会被调用，并返回一个新的 Future 作为替代。
1
folly::future<int> future1 = ...;
2
auto future2 = future1.orElse([](const std::exception_ptr& e) {
3
// future1 失败，处理错误 e，并返回一个备用 Future
4
LOG(ERROR) << "Future 1 failed: " << folly::exceptionStr(e);
5
return folly::makeFuture(0); // 返回默认值 0
6
});
orElse 允许我们在异步流程中优雅地处理错误，提供降级方案或默认值，保证程序的健壮性。
⑥ finally: 无论 Future 成功还是失败，finally 提供的函数都会被执行。类似于 try-finally 语句块中的 finally 子句，用于执行清理操作，例如释放资源、关闭连接等。
1
folly::future<int> future1 = ...;
2
auto future2 = future1.finally([]() {
3
// 无论 future1 成功还是失败，都会执行清理操作
4
LOG(INFO) << "Future 1 finished (success or failure)";
5
});
finally 返回的 Future 与原始 Future 具有相同的结果类型和值。它确保清理操作总是会被执行，即使在异步流程中发生错误。
⑦ collectAll 和 collectAny: 用于并行执行多个 Futures。collectAll 等待所有 Futures 完成，并返回一个包含所有结果的 Future 列表。collectAny 只要有一个 Future 完成就返回，并返回第一个完成的 Future 的结果。
1
std::vector<folly::future<int>> futures = {futureA(), futureB(), futureC()};
2
3
// 等待所有 futures 完成
4
auto allFutures = folly::collectAll(futures).then([](std::vector<folly::Try<int>> results) {
5
// results 包含所有 futures 的结果，可能是成功或失败
6
for (const auto& result : results) {
7
if (result.isSuccess()) {
8
LOG(INFO) << "Future succeeded with result: " << result.value();
9
} else {
10
LOG(ERROR) << "Future failed: " << folly::exceptionStr(result.exception());
11
}
12
}
13
});
14
15
// 只要有一个 future 完成就返回
16
auto anyFuture = folly::collectAny(futures).then([](folly::Try<folly::Future<int>> result) {
17
if (result.isSuccess()) {
18
// result.value() 是第一个完成的 future
19
result.value().then([](int firstResult) {
20
LOG(INFO) << "First future completed with result: " << firstResult;
21
});
22
} else {
23
LOG(ERROR) << "collectAny failed: " << folly::exceptionStr(result.exception());
24
}
25
});
collectAll 和 collectAny 是实现并行异步操作的关键工具。它们可以显著提高程序的性能，尤其是在需要同时执行多个独立任务的场景下。
7.1.2 Futures的控制流 (Control Flow of Futures)
除了组合，Futures 还提供了丰富的 API 来控制异步流程的执行，包括错误处理、取消和超时。
① 错误处理 (Error Handling): Futures 使用 folly::Try 来封装异步操作的结果，Try 可以表示成功的结果值，也可以表示失败的异常。通过 isSuccess() 和 isException() 方法可以判断 Try 的状态，通过 value() 和 exception() 方法可以获取结果值或异常。
在 Future 的组合操作中，例如 then、map、flatMap 等，如果前一个 Future 失败，后续的操作默认不会执行，错误会沿着 Future 链传播。可以使用 orElse 来显式处理错误，或者使用 get() 方法捕获最终的异常。
② 取消 (Cancellation): Futures 支持取消操作。可以通过 Promise 对象关联的 CancellationSource 来取消 Future。取消操作是协作式的，需要在异步操作的代码中显式检查取消状态并进行处理。
1
folly::Promise<int> promise;
2
folly::Future<int> future = promise.getFuture();
3
folly::CancellationSource cancellationSource;
4
future.setCancellationSource(cancellationSource);
5
6
// ... 在其他线程中执行异步操作 ...
7
if (cancellationSource.isCancelled()) {
8
// 检查到取消信号，停止异步操作
9
promise.setException(std::make_exception_ptr(std::runtime_error("Cancelled")));
10
return;
11
}
12
// ... 异步操作完成 ...
13
promise.setValue(result);
14
15
// 取消 future
16
cancellationSource.requestCancellation();
取消操作对于长时间运行的异步任务非常重要，可以避免资源浪费，并提高程序的响应性。
③ 超时 (Timeout): 可以使用 folly::futures::timeout 函数为 Future 设置超时时间。如果 Future 在指定时间内没有完成，timeout 函数会返回一个失败的 Future，并抛出 std::timeout_exception 异常。
1
folly::future<int> future1 = ...;
2
auto future2 = folly::futures::timeout(future1, std::chrono::milliseconds(100));
3
4
future2.then([](int result) {
5
// future1 在 100ms 内完成
6
}).orElse([](const std::exception_ptr& e) {
7
if (folly::exception_cast<std::timeout_exception>(e)) {
8
// future1 超时
9
LOG(ERROR) << "Future 1 timeout";
10
} else {
11
// 其他错误
12
LOG(ERROR) << "Future 1 failed: " << folly::exceptionStr(e);
13
}
14
});
超时机制可以防止异步操作无限期地阻塞，保证程序的稳定性和可靠性。
7.1.3 实战代码案例 (Practical Code Example)
下面是一个简单的实战代码案例，演示了 Futures 的组合和控制流的应用。假设我们需要从数据库中获取用户信息，并根据用户角色获取相应的权限列表。
1
folly::future<User> fetchUserFromDB(int userId) {
2
// 模拟从数据库获取用户信息的异步操作
3
return folly::futures::delayed(std::chrono::milliseconds(100), User{userId, "John Doe", "admin"});
4
}
5
6
folly::future<Permissions> fetchPermissionsForRole(const std::string& role) {
7
// 模拟根据角色获取权限列表的异步操作
8
return folly::futures::delayed(std::chrono::milliseconds(50), Permissions{{"read", "write", "delete"}});
9
}
10
11
folly::future<UserInfo> getUserInfo(int userId) {
12
return fetchUserFromDB(userId)
13
.flatMap([](User user) {
14
return fetchPermissionsForRole(user.role).map([user](Permissions permissions) {
15
return UserInfo{user, permissions};
16
});
17
})
18
.timeout(std::chrono::milliseconds(200)) // 设置超时时间
19
.orElse([](const std::exception_ptr& e) {
20
LOG(ERROR) << "Failed to get user info: " << folly::exceptionStr(e);
21
return folly::makeFuture(UserInfo{}); // 返回默认值
22
});
23
}
24
25
int main() {
26
getUserInfo(123).then([](UserInfo userInfo) {
27
if (userInfo.user.id != 0) {
28
LOG(INFO) << "User info: " << userInfo.user.name << ", Permissions: " << userInfo.permissions.list;
29
} else {
30
LOG(WARNING) << "Failed to retrieve user info.";
31
}
32
}).get(); // 等待 Future 完成并获取结果
33
34
return 0;
35
}
在这个案例中，getUserInfo 函数使用了 flatMap 和 map 将 fetchUserFromDB 和 fetchPermissionsForRole 两个异步操作串联起来，并使用 timeout 设置了超时时间，使用 orElse 处理了错误情况。整个异步流程清晰简洁，易于理解和维护。
7.1.4 小结 (Summary)
本节深入探讨了 Folly Futures 和 Promises 的高级用法，包括：
① Futures的组合: 介绍了 then、map、flatMap、andThen、orElse、finally、collectAll 和 collectAny 等组合操作，用于构建复杂的异步流程。
② Futures的控制流: 讲解了错误处理、取消和超时等控制流机制，用于提高异步程序的健壮性和可靠性。
③ 实战代码案例: 通过一个实际案例演示了 Futures 的组合和控制流的应用。
掌握 Futures 的高级用法是构建高效、可靠的异步 C++ 应用的关键。通过灵活运用 Futures 的组合和控制流机制，可以有效地管理并发和并行，充分利用多核处理器的性能。
7.2 Executors框架深入：定制化Executor与调度策略 (Executors Framework Deep Dive: Customized Executors and Scheduling Strategies)
Executors（执行器） 框架是 Folly 并发编程的核心组件之一，它提供了一种抽象的方式来管理和执行任务。在之前的章节中，我们已经了解了 Executors 的基本概念和用法。本节将深入探讨 Executors 框架，重点介绍如何 定制化 Executor（Customized Executor） 和 调度策略（Scheduling Strategies），以满足不同场景下的性能需求。
7.2.1 Executor接口与实现 (Executor Interface and Implementations)
folly::Executor 是 Executors 框架的核心接口，定义了任务提交和执行的基本操作。Executor 接口非常简洁，只包含一个核心方法 schedule(Func func)，用于提交一个函数对象 func 到 Executor 执行。
Folly 提供了多种 Executor 的实现，以满足不同的并发和并行需求：
① ThreadPoolExecutor: 基于线程池的 Executor，是最常用的 Executor 实现。ThreadPoolExecutor 管理着一个线程池，并将提交的任务分配给线程池中的线程执行。可以配置线程池的大小、线程空闲超时时间等参数。
1
// 创建一个固定大小为 4 的线程池 Executor
2
auto executor = std::make_shared<folly::ThreadPoolExecutor>(4);
3
4
executor->schedule([] {
5
// 在线程池中执行的任务
6
LOG(INFO) << "Task executed in ThreadPoolExecutor";
7
});
ThreadPoolExecutor 适用于 CPU 密集型和 IO 密集型任务，可以有效地利用多核处理器的性能，并限制并发任务的数量，防止资源过度消耗。
② IOThreadPoolExecutor: 专门为 IO 密集型任务优化的线程池 Executor。IOThreadPoolExecutor 内部使用了更高效的 IO 事件循环机制，例如 epoll (Linux) 或 kqueue (macOS)，可以更高效地处理大量的并发 IO 操作。
1
// 创建一个 IO 线程池 Executor
2
auto ioExecutor = std::make_shared<folly::IOThreadPoolExecutor>(4);
3
4
ioExecutor->schedule([] {
5
// 在 IO 线程池中执行的 IO 密集型任务
6
LOG(INFO) << "IO task executed in IOThreadPoolExecutor";
7
});
IOThreadPoolExecutor 特别适用于网络编程、文件 IO 等场景，可以显著提高 IO 密集型应用的性能。
③ InlineExecutor: 内联 Executor，直接在当前线程同步执行提交的任务。InlineExecutor 不会创建新的线程，也不会进行任务调度，适用于对延迟非常敏感，且任务执行时间非常短的场景。
1
// 创建一个内联 Executor
2
auto inlineExecutor = folly::InlineExecutor::instance();
3
4
inlineExecutor->schedule([] {
5
// 在当前线程内联执行的任务
6
LOG(INFO) << "Task executed in InlineExecutor";
7
});
InlineExecutor 的开销非常小，但会阻塞当前线程，因此不适用于长时间运行的任务。通常用于同步回调、轻量级任务调度等场景。
④ VirtualExecutor: 虚拟 Executor，不实际执行任务，只返回一个立即完成的 Future。VirtualExecutor 主要用于测试和模拟场景，可以方便地创建立即完成的异步操作。
1
// 创建一个虚拟 Executor
2
auto virtualExecutor = folly::VirtualExecutor::instance();
3
4
virtualExecutor->schedule([] {
5
// 虚拟 Executor 不会实际执行任务
6
LOG(INFO) << "Task scheduled in VirtualExecutor (but not executed)";
7
});
VirtualExecutor 可以用于单元测试、性能基准测试等场景，模拟异步操作的完成，而无需实际执行耗时的操作。
⑤ PrioritizedExecutor: 优先级 Executor，可以根据任务的优先级进行调度。PrioritizedExecutor 内部维护多个优先级队列，优先级高的任务会优先被执行。
1
// 创建一个优先级 Executor，支持 3 个优先级
2
auto prioritizedExecutor = std::make_shared<folly::PrioritizedExecutor>(3);
3
4
prioritizedExecutor->add(folly::makePriorityTask(folly::Func([] {
5
LOG(INFO) << "High priority task";
6
}), 0)); // 优先级 0 (最高)
7
8
prioritizedExecutor->add(folly::makePriorityTask(folly::Func([] {
9
LOG(INFO) << "Low priority task";
10
}), 2)); // 优先级 2 (最低)
PrioritizedExecutor 适用于需要区分任务优先级的场景，例如实时系统、QoS 保障等。
7.2.2 定制化Executor (Customized Executor)
除了 Folly 提供的内置 Executor 实现，我们还可以根据实际需求定制化 Executor。定制化 Executor 主要有两种方式：
① 继承 folly::Executor 接口: 可以创建一个新的类，继承 folly::Executor 接口，并实现 schedule(Func func) 方法。在 schedule 方法中，可以自定义任务的调度和执行逻辑。
1
class MyCustomExecutor : public folly::Executor {
2
public:
3
void schedule(folly::Func func) override {
4
// 自定义任务调度和执行逻辑
5
LOG(INFO) << "Custom Executor scheduling task";
6
std::thread([func]() {
7
func(); // 在新线程中执行任务
8
}).detach();
9
}
10
};
11
12
// 使用自定义 Executor
13
auto customExecutor = std::make_shared<MyCustomExecutor>();
14
customExecutor->schedule([] {
15
LOG(INFO) << "Task executed in MyCustomExecutor";
16
});
通过继承 folly::Executor 接口，可以完全控制任务的调度和执行方式，实现高度定制化的 Executor。
② 组合现有 Executor: 可以组合多个现有的 Executor，例如使用 InlineExecutor 作为基础，添加额外的调度逻辑。
1
class DelayedExecutor : public folly::Executor {
2
public:
3
explicit DelayedExecutor(std::chrono::milliseconds delay) : delay_(delay) {}
4
5
void schedule(folly::Func func) override {
6
folly::InlineExecutor::instance()->schedule([func, delay = delay_] {
7
std::this_thread::sleep_for(delay); // 延迟执行
8
func();
9
});
10
}
11
12
private:
13
std::chrono::milliseconds delay_;
14
};
15
16
// 使用延迟 Executor
17
auto delayedExecutor = std::make_shared<DelayedExecutor>(std::chrono::milliseconds(500));
18
delayedExecutor->schedule([] {
19
LOG(INFO) << "Task executed in DelayedExecutor after 500ms";
20
});
通过组合现有 Executor，可以复用 Folly 提供的 Executor 实现，并在此基础上添加自定义的调度策略。
7.2.3 调度策略 (Scheduling Strategies)
Executors 的调度策略决定了任务的执行顺序和资源分配。不同的调度策略适用于不同的场景。常见的调度策略包括：
① FIFO (First-In-First-Out): 先进先出策略，任务按照提交顺序执行。ThreadPoolExecutor 和 IOThreadPoolExecutor 默认使用 FIFO 策略。FIFO 策略简单公平，适用于大多数场景。
② LIFO (Last-In-First-Out): 后进先出策略，任务按照提交顺序的逆序执行。LIFO 策略适用于栈式任务处理、深度优先搜索等场景。
③ 优先级调度 (Priority Scheduling): 根据任务的优先级进行调度，优先级高的任务优先执行。PrioritizedExecutor 使用优先级调度策略。优先级调度适用于需要区分任务重要性的场景。
④ 公平调度 (Fair Scheduling): 尽量保证每个任务都能获得公平的执行机会，避免某些任务长时间饥饿。公平调度策略通常比较复杂，需要考虑任务的执行时间、资源需求等因素。
⑤ 延迟调度 (Delayed Scheduling): 延迟一段时间后执行任务。DelayedExecutor 实现了延迟调度策略。延迟调度适用于定时任务、延迟重试等场景。
选择合适的调度策略需要根据具体的应用场景和性能需求进行权衡。Folly 提供的 Executors 已经覆盖了大部分常见的调度策略，如果需要更复杂的调度策略，可以考虑定制化 Executor。
7.2.4 Executor与Futures的结合 (Executor and Futures Integration)
Executors 通常与 Futures 结合使用，实现异步任务的调度和执行。folly::via 函数可以将一个 Future 的后续操作切换到指定的 Executor 上执行。
1
folly::future<int> future1 = ...;
2
auto executor = std::make_shared<folly::ThreadPoolExecutor>(4);
3
4
auto future2 = future1.via(executor).then([](int result) {
5
// future2 的后续操作将在 executor 上执行
6
LOG(INFO) << "Task executed in ThreadPoolExecutor after future1";
7
return result * 2;
8
});
via 函数可以控制 Future 链中每个环节的执行线程，实现精细化的线程管理和调度。例如，可以将 IO 密集型操作放在 IOThreadPoolExecutor 上执行，将 CPU 密集型操作放在 ThreadPoolExecutor 上执行，从而最大化地利用系统资源。
7.2.5 实战代码案例 (Practical Code Example)
下面是一个实战代码案例，演示了定制化 Executor 和调度策略的应用。假设我们需要实现一个限流 Executor，限制任务的并发执行数量。
1
class RateLimitingExecutor : public folly::Executor {
2
public:
3
explicit RateLimitingExecutor(int maxConcurrency) : maxConcurrency_(maxConcurrency), currentConcurrency_(0) {}
4
5
void schedule(folly::Func func) override {
6
std::lock_guard<std::mutex> lock(mutex_);
7
if (currentConcurrency_ < maxConcurrency_) {
8
++currentConcurrency_;
9
folly::ThreadPoolExecutor::instance()->schedule([this, func]() {
10
func(); // 在线程池中执行任务
11
{
12
std::lock_guard<std::mutex> lock(mutex_);
13
--currentConcurrency_;
14
}
15
});
16
} else {
17
// 达到并发限制，拒绝任务或放入队列等待
18
LOG(WARNING) << "Rate limit reached, task rejected";
19
// 可以选择将任务放入队列等待，或直接拒绝
20
}
21
}
22
23
private:
24
int maxConcurrency_;
25
std::atomic<int> currentConcurrency_;
26
std::mutex mutex_;
27
};
28
29
int main() {
30
auto rateLimitingExecutor = std::make_shared<RateLimitingExecutor>(2); // 限制最大并发数为 2
31
32
for (int i = 0; i < 5; ++i) {
33
rateLimitingExecutor->schedule([i]() {
34
LOG(INFO) << "Task " << i << " started";
35
std::this_thread::sleep_for(std::chrono::milliseconds(100));
36
LOG(INFO) << "Task " << i << " finished";
37
});
38
}
39
40
std::this_thread::sleep_for(std::chrono::seconds(1)); // 等待任务完成
41
42
return 0;
43
}
在这个案例中，RateLimitingExecutor 通过维护一个 currentConcurrency_ 计数器和一个互斥锁，限制了并发执行的任务数量。当并发数达到 maxConcurrency_ 时，新的任务会被拒绝。这个例子演示了如何通过定制化 Executor 实现特定的调度策略。
7.2.6 小结 (Summary)
本节深入探讨了 Folly Executors 框架，包括：
① Executor接口与实现: 介绍了 folly::Executor 接口和 Folly 提供的多种 Executor 实现，例如 ThreadPoolExecutor、IOThreadPoolExecutor、InlineExecutor、VirtualExecutor 和 PrioritizedExecutor。
② 定制化Executor: 讲解了如何通过继承 folly::Executor 接口或组合现有 Executor 来定制化 Executor，以满足不同的需求。
③ 调度策略: 介绍了常见的调度策略，例如 FIFO、LIFO、优先级调度、公平调度和延迟调度，以及如何选择合适的调度策略。
④ Executor与Futures的结合: 演示了如何使用 folly::via 函数将 Future 的后续操作切换到指定的 Executor 上执行。
⑤ 实战代码案例: 通过一个限流 Executor 的例子，演示了定制化 Executor 和调度策略的应用。
深入理解 Executors 框架，并掌握定制化 Executor 和调度策略的技巧，可以帮助我们构建更高效、更灵活的并发 C++ 应用。
7.3 并发数据结构：ConcurrentHashMap等 (Concurrent Data Structures: ConcurrentHashMap, etc.)
在并发编程中，数据竞争（Data Race） 是一个常见且严重的问题。当多个线程同时访问和修改共享数据时，如果没有适当的同步机制，就可能导致数据不一致、程序崩溃等问题。为了解决数据竞争问题，并提高并发程序的性能，并发数据结构（Concurrent Data Structures） 应运而生。并发数据结构内部实现了高效的并发控制机制，允许多个线程安全地并发访问和修改数据，而无需显式的锁管理。
Folly 提供了丰富的并发数据结构，其中最常用的是 ConcurrentHashMap（并发哈希表）。本节将重点介绍 ConcurrentHashMap，并简要介绍其他常用的并发数据结构。
7.3.1 ConcurrentHashMap (并发哈希表)
folly::ConcurrentHashMap 是 Folly 提供的线程安全的哈希表实现。它允许多个线程并发地进行插入、删除、查找等操作，而无需显式的锁。ConcurrentHashMap 内部使用了 分段锁（Segment Locking） 或 无锁（Lock-Free） 等技术，实现了高效的并发控制。
① 基本用法 (Basic Usage): ConcurrentHashMap 的 API 类似于 std::unordered_map，但它是线程安全的。
1
folly::ConcurrentHashMap<int, std::string> map;
2
3
// 插入元素
4
map.insert(1, "value1");
5
map.emplace(2, "value2");
6
map[3] = "value3";
7
8
// 查找元素
9
auto it = map.find(2);
10
if (it != map.end()) {
11
LOG(INFO) << "Found key 2, value: " << it->second;
12
}
13
14
// 删除元素
15
map.erase(1);
16
17
// 遍历元素
18
for (const auto& pair : map) {
19
LOG(INFO) << "Key: " << pair.first << ", Value: " << pair.second;
20
}
21
22
// 获取大小
23
size_t size = map.size();
24
LOG(INFO) << "Map size: " << size;
ConcurrentHashMap 提供了与 std::unordered_map 类似的 API，例如 insert、emplace、find、erase、size 等，可以方便地进行元素的插入、删除、查找和遍历操作。
② 并发安全性 (Concurrency Safety): ConcurrentHashMap 的核心优势在于其并发安全性。多个线程可以同时对 ConcurrentHashMap 进行读写操作，而不会发生数据竞争。
1
folly::ConcurrentHashMap<int, int> concurrentMap;
2
3
std::vector<std::thread> threads;
4
for (int i = 0; i < 10; ++i) {
5
threads.emplace_back([&concurrentMap, i]() {
6
for (int j = 0; j < 1000; ++j) {
7
concurrentMap[j] += i; // 并发更新 map
8
}
9
});
10
}
11
12
for (auto& thread : threads) {
13
thread.join();
14
}
15
16
LOG(INFO) << "Concurrent map size: " << concurrentMap.size();
在上述代码中，10 个线程同时并发地更新 concurrentMap，由于 ConcurrentHashMap 的线程安全性，不会发生数据竞争，最终的结果是正确的。
③ 性能考量 (Performance Considerations): ConcurrentHashMap 为了实现并发安全性，牺牲了一定的性能。在单线程环境下，ConcurrentHashMap 的性能通常比 std::unordered_map 略差。但在多线程环境下，ConcurrentHashMap 的并发性能远高于使用互斥锁保护的 std::unordered_map。
ConcurrentHashMap 的性能受到多种因素的影响，例如哈希函数的质量、负载因子、并发线程数等。在实际应用中，需要根据具体的场景进行性能测试和调优。
④ 适用场景 (Use Cases): ConcurrentHashMap 适用于需要高并发读写操作的场景，例如缓存系统、会话管理、在线服务等。在这些场景下，ConcurrentHashMap 可以有效地提高程序的并发性能和吞吐量。
7.3.2 其他并发数据结构 (Other Concurrent Data Structures)
除了 ConcurrentHashMap，Folly 和 C++ 标准库还提供了其他常用的并发数据结构，例如：
① ConcurrentQueue (并发队列): folly::ConcurrentQueue 是 Folly 提供的线程安全的队列实现。它允许多个生产者线程并发地向队列中添加元素，多个消费者线程并发地从队列中取出元素。ConcurrentQueue 适用于生产者-消费者模式、消息队列等场景。
② AtomicHashMap (原子哈希表): folly::AtomicHashMap 是 Folly 提供的基于原子操作的哈希表实现。与 ConcurrentHashMap 相比，AtomicHashMap 更加轻量级，适用于读多写少的场景。
③ std::atomic<T> (原子类型): C++ 标准库提供的原子类型，例如 std::atomic<int>、std::atomic<bool> 等。原子类型提供了原子操作，例如原子加、原子减、原子交换等，可以用于实现简单的并发控制。
④ std::mutex、std::condition_variable (互斥锁和条件变量): C++ 标准库提供的同步原语，可以用于构建更复杂的并发数据结构和同步机制。
选择合适的并发数据结构需要根据具体的应用场景和需求进行权衡。ConcurrentHashMap 适用于通用的并发哈希表场景，ConcurrentQueue 适用于并发队列场景，AtomicHashMap 适用于读多写少的场景，原子类型和同步原语适用于构建更底层的并发控制机制。
7.3.3 并发数据结构的选择原则 (Selection Principles of Concurrent Data Structures)
在选择并发数据结构时，需要考虑以下几个原则：
① 并发安全性 (Concurrency Safety): 首要原则是保证数据结构的并发安全性，避免数据竞争。选择线程安全的数据结构，或者使用适当的同步机制来保护共享数据。
② 性能 (Performance): 在保证并发安全的前提下，尽量选择性能更高的并发数据结构。不同的并发数据结构具有不同的性能特点，需要根据具体的应用场景进行选择。
③ 功能 (Functionality): 选择功能满足需求的数据结构。例如，如果需要哈希表，可以选择 ConcurrentHashMap 或 AtomicHashMap；如果需要队列，可以选择 ConcurrentQueue。
④ 复杂性 (Complexity): 权衡数据结构的复杂性和易用性。一些高级的并发数据结构可能具有更高的性能，但也可能更复杂，更难使用和维护。
⑤ 可维护性 (Maintainability): 选择易于理解和维护的并发数据结构。代码的可维护性对于长期项目的开发和维护至关重要。
7.3.4 实战代码案例 (Practical Code Example)
下面是一个实战代码案例，演示了 ConcurrentHashMap 在缓存系统中的应用。假设我们需要实现一个简单的缓存系统，用于缓存用户数据。
1
class UserCache {
2
public:
3
std::string getUserName(int userId) {
4
auto it = cache_.find(userId);
5
if (it != cache_.end()) {
6
LOG(INFO) << "Cache hit for user " << userId;
7
return it->second; // 从缓存中获取
8
} else {
9
LOG(INFO) << "Cache miss for user " << userId;
10
std::string userName = fetchUserNameFromDB(userId); // 从数据库获取
11
cache_.insert(userId, userName); // 放入缓存
12
return userName;
13
}
14
}
15
16
private:
17
folly::ConcurrentHashMap<int, std::string> cache_;
18
std::string fetchUserNameFromDB(int userId) {
19
// 模拟从数据库获取用户名的操作
20
std::this_thread::sleep_for(std::chrono::milliseconds(50));
21
return "User " + std::to_string(userId);
22
}
23
};
24
25
int main() {
26
UserCache userCache;
27
28
std::vector<std::thread> threads;
29
for (int i = 0; i < 10; ++i) {
30
threads.emplace_back([&userCache, i]() {
31
for (int j = 0; j < 5; ++j) {
32
std::string userName = userCache.getUserName(i * 10 + j);
33
LOG(INFO) << "User name for " << i * 10 + j << ": " << userName;
34
}
35
});
36
}
37
38
for (auto& thread : threads) {
39
thread.join();
40
}
41
42
return 0;
43
}
在这个案例中，UserCache 类使用 ConcurrentHashMap 作为缓存存储用户数据。多个线程可以并发地访问 getUserName 方法，由于 ConcurrentHashMap 的线程安全性，缓存的读写操作是线程安全的。这个例子演示了 ConcurrentHashMap 在缓存系统中的应用。
7.3.5 小结 (Summary)
本节介绍了并发数据结构，重点讲解了 Folly 提供的 ConcurrentHashMap，并简要介绍了其他常用的并发数据结构，例如 ConcurrentQueue、AtomicHashMap、std::atomic<T>、std::mutex 和 std::condition_variable。
① ConcurrentHashMap: 详细介绍了 ConcurrentHashMap 的基本用法、并发安全性、性能考量和适用场景。
② 其他并发数据结构: 简要介绍了其他常用的并发数据结构及其适用场景。
③ 并发数据结构的选择原则: 总结了选择并发数据结构时需要考虑的原则，例如并发安全性、性能、功能、复杂性和可维护性。
④ 实战代码案例: 通过一个缓存系统的例子，演示了 ConcurrentHashMap 在实际应用中的使用。
掌握并发数据结构是构建高性能并发 C++ 应用的重要基础。合理选择和使用并发数据结构，可以有效地提高程序的并发性能和可伸缩性，并简化并发编程的复杂性。
7.4 原子操作与内存模型 (Atomic Operations and Memory Model)
原子操作（Atomic Operations） 是指不可中断的操作。在多线程环境下，原子操作可以保证对共享变量的访问和修改是原子性的，即一个线程在执行原子操作的过程中，不会被其他线程打断，从而避免数据竞争。内存模型（Memory Model） 定义了多线程程序中内存访问的规则和顺序，它决定了不同线程对共享变量的修改何时对其他线程可见。理解原子操作和内存模型是进行底层并发编程的关键。
本节将介绍原子操作的基本概念、C++ 内存模型以及如何在 Folly 中使用原子操作。
7.4.1 原子操作的基本概念 (Basic Concepts of Atomic Operations)
原子操作的核心特性是 原子性（Atomicity）。原子性保证了操作的完整性，要么操作完全执行成功，要么完全不执行，不会出现中间状态。在多线程环境下，原子操作可以保证对共享变量的访问和修改是互斥的，避免数据竞争。
常见的原子操作包括：
① 原子加载 (Atomic Load): 原子地读取共享变量的值。原子加载保证读取操作是不可中断的，读取到的值要么是操作开始前的原始值，要么是某个线程完成原子存储操作后的新值，不会出现部分更新的情况。
② 原子存储 (Atomic Store): 原子地写入共享变量的值。原子存储保证写入操作是不可中断的，写入的值会立即对其他线程可见（根据内存模型的规定）。
③ 原子交换 (Atomic Exchange): 原子地将共享变量的值替换为新值，并返回旧值。原子交换是复合操作，但整个操作过程是原子性的。
④ 原子比较并交换 (Atomic Compare-and-Swap, CAS): 原子地比较共享变量的值与预期值，如果相等，则将共享变量的值替换为新值。CAS 操作是实现无锁编程的重要基石。
⑤ 原子加/减 (Atomic Add/Subtract): 原子地对共享变量进行加法或减法操作。原子加/减操作常用于计数器、引用计数等场景。
C++ 标准库提供了 <atomic> 头文件，定义了原子类型 std::atomic<T> 和相关的原子操作函数。Folly 也提供了 folly/AtomicHashMap.h 等基于原子操作的并发数据结构。
7.4.2 C++ 内存模型 (C++ Memory Model)
C++ 内存模型定义了多线程程序中内存访问的规则和顺序。内存模型的核心概念是 内存顺序（Memory Ordering），它指定了原子操作的顺序约束，以及对其他线程的可见性。
C++ 内存模型提供了六种内存顺序选项：
① std::memory_order_seq_cst (顺序一致性): 最强的内存顺序，也是默认的内存顺序。顺序一致性保证了所有线程看到的原子操作顺序都是一致的，并且与程序代码的顺序一致。顺序一致性开销较大，性能相对较低。
② std::memory_order_release (释放): 用于写操作，表示当前线程的写操作对其他线程可见，并且之前的写操作也对其他线程可见。释放操作通常与获取操作配对使用，用于实现同步和互斥。
③ std::memory_order_acquire (获取): 用于读操作，表示当前线程可以看到其他线程的释放操作，并且之后的读写操作都不能重排到获取操作之前。获取操作通常与释放操作配对使用。
④ std::memory_order_acq_rel (获取-释放): 同时具有获取和释放语义，用于读-修改-写操作，例如原子交换、CAS 等。
⑤ std::memory_order_consume (消费): 类似于获取操作，但只保证依赖于当前读操作的结果的后续读操作不会重排到消费操作之前。消费操作的语义比较复杂，使用较少。
⑥ std::memory_order_relaxed (宽松): 最弱的内存顺序，只保证原子性，不保证顺序性和可见性。宽松顺序开销最小，性能最高，但需要仔细考虑其适用场景。
选择合适的内存顺序需要根据具体的同步需求和性能要求进行权衡。顺序一致性最安全，但性能最低；宽松顺序性能最高，但最容易出错。通常情况下，可以使用顺序一致性作为默认选项，在性能敏感的场景下，可以考虑使用更弱的内存顺序，但需要仔细分析和测试。
7.4.3 Folly中的原子操作 (Atomic Operations in Folly)
Folly 并没有提供额外的原子操作 API，而是直接使用 C++ 标准库的 <atomic> 头文件。Folly 的并发数据结构，例如 AtomicHashMap，也是基于 C++ 标准库的原子操作实现的。
1
#include <atomic>
2
#include <thread>
3
#include <iostream>
4
5
std::atomic<int> counter(0);
6
7
void increment_counter() {
8
for (int i = 0; i < 100000; ++i) {
9
counter++; // 原子加操作，默认使用 std::memory_order_seq_cst
10
}
11
}
12
13
int main() {
14
std::thread t1(increment_counter);
15
std::thread t2(increment_counter);
16
17
t1.join();
18
t2.join();
19
20
std::cout << "Counter value: " << counter << std::endl; // 输出结果接近 200000
21
22
return 0;
23
}
在上述代码中，counter 是一个原子整型变量，counter++ 操作是原子性的，即使在多线程环境下，也能保证计数结果的正确性。
7.4.4 内存屏障 (Memory Barriers)
内存屏障（Memory Barriers），也称为 内存栅栏（Memory Fences），是一种 CPU 指令，用于强制内存顺序，保证某些内存操作的顺序性和可见性。内存屏障可以用于实现更细粒度的内存控制，例如控制特定类型的内存操作的顺序。
C++ 内存模型中，释放和获取操作隐含了内存屏障。例如，释放操作相当于插入了一个 释放屏障（Release Fence），保证之前的写操作在释放操作之前完成，并对其他线程可见；获取操作相当于插入了一个 获取屏障（Acquire Fence），保证之后的读操作在获取操作之后执行，并能看到其他线程的释放操作。
可以使用 std::atomic_thread_fence 函数显式地插入内存屏障。std::atomic_thread_fence 函数接受一个内存顺序参数，指定屏障的类型。
1
std::atomic<bool> ready(false);
2
int data = 0;
3
4
void writer_thread() {
5
data = 42;
6
std::atomic_thread_fence(std::memory_order_release); // 释放屏障
7
ready.store(true, std::memory_order_relaxed);
8
}
9
10
void reader_thread() {
11
while (!ready.load(std::memory_order_relaxed)) {
12
// 等待 ready 变为 true
13
}
14
std::atomic_thread_fence(std::memory_order_acquire); // 获取屏障
15
std::cout << "Data value: " << data << std::endl; // 保证能看到 writer_thread 中 data 的修改
16
}
在上述代码中，writer_thread 使用释放屏障，reader_thread 使用获取屏障，保证了 reader_thread 能够正确地看到 writer_thread 中对 data 的修改。
7.4.5 实战代码案例 (Practical Code Example)
下面是一个实战代码案例，演示了原子操作和内存模型在实现自旋锁（Spin Lock）中的应用。自旋锁是一种忙等待锁，当锁被占用时，线程会不断循环检查锁是否释放，而不是进入阻塞状态。
1
class SpinLock {
2
public:
3
SpinLock() : locked_(false) {}
4
5
void lock() {
6
while (locked_.exchange(true, std::memory_order_acquire)) {
7
// 自旋等待锁释放
8
while (locked_.load(std::memory_order_relaxed)) {
9
std::this_thread::yield(); // 让出 CPU 时间片
10
}
11
}
12
}
13
14
void unlock() {
15
locked_.store(false, std::memory_order_release);
16
}
17
18
private:
19
std::atomic<bool> locked_;
20
};
21
22
SpinLock spinLock;
23
int shared_data = 0;
24
25
void worker_thread(int thread_id) {
26
for (int i = 0; i < 1000; ++i) {
27
spinLock.lock(); // 获取自旋锁
28
shared_data++; // 访问共享数据
29
LOG(INFO) << "Thread " << thread_id << ", shared_data: " << shared_data;
30
spinLock.unlock(); // 释放自旋锁
31
}
32
}
33
34
int main() {
35
std::vector<std::thread> threads;
36
for (int i = 0; i < 2; ++i) {
37
threads.emplace_back(worker_thread, i);
38
}
39
40
for (auto& thread : threads) {
41
thread.join();
42
}
43
44
std::cout << "Final shared_data: " << shared_data << std::endl; // 输出结果接近 2000
45
46
return 0;
47
}
在这个案例中，SpinLock 类使用原子布尔变量 locked_ 和原子交换操作 exchange 以及原子加载操作 load 实现了自旋锁。lock 方法使用 acquire 内存顺序，unlock 方法使用 release 内存顺序，保证了锁的互斥性和内存可见性。
7.4.6 小结 (Summary)
本节介绍了原子操作和 C++ 内存模型，包括：
① 原子操作的基本概念: 讲解了原子操作的原子性特性，以及常见的原子操作类型，例如原子加载、原子存储、原子交换、CAS 和原子加/减。
② C++ 内存模型: 介绍了 C++ 内存模型的内存顺序选项，例如顺序一致性、释放、获取、获取-释放、消费和宽松顺序，以及如何选择合适的内存顺序。
③ Folly中的原子操作: 说明了 Folly 直接使用 C++ 标准库的原子操作 API。
④ 内存屏障: 介绍了内存屏障的概念和作用，以及如何使用 std::atomic_thread_fence 函数显式插入内存屏障。
⑤ 实战代码案例: 通过一个自旋锁的例子，演示了原子操作和内存模型在实现底层同步机制中的应用。
深入理解原子操作和内存模型是进行底层并发编程，实现高性能、高效率并发程序的关键。掌握原子操作和内存模型的知识，可以帮助我们构建更精细、更高效的并发控制机制，并避免常见的并发错误。
7.5 无锁编程实践 (Lock-Free Programming Practices)
无锁编程（Lock-Free Programming） 是一种并发编程技术，旨在避免使用传统的互斥锁（Mutex Locks）等阻塞同步机制，从而提高程序的并发性能和响应性。无锁编程通常使用原子操作和内存模型来实现线程间的同步和数据共享。虽然无锁编程具有诸多优点，但也带来了更高的复杂性和风险。
本节将介绍无锁编程的基本概念、优势与挑战、常用技术以及实践指南。
7.5.1 无锁编程的基本概念 (Basic Concepts of Lock-Free Programming)
无锁编程的核心思想是 非阻塞（Non-Blocking）。在无锁编程中，线程不会因为等待锁而进入阻塞状态，而是会不断尝试执行操作，直到成功为止。如果操作失败，线程会重试，或者执行其他操作，但不会被挂起。
无锁编程主要依赖于 原子操作（Atomic Operations） 和 内存模型（Memory Model）。原子操作保证了对共享变量的访问和修改是原子性的，内存模型定义了多线程程序中内存访问的规则和顺序。通过巧妙地组合原子操作和内存顺序，可以实现线程间的同步和数据共享，而无需显式的锁。
无锁编程主要分为两种类型：
① 无等待（Wait-Free）: 最强的无锁形式。无等待算法保证每个线程在有限步骤内完成操作，无论其他线程的执行速度如何。无等待算法通常比较复杂，实现难度较高。
② 锁自由（Lock-Free）: 较弱的无锁形式。锁自由算法保证至少有一个线程在不断取得进展，即使其他线程被延迟或暂停。锁自由算法相对容易实现，应用也更广泛。
本节主要讨论锁自由编程。
7.5.2 无锁编程的优势与挑战 (Advantages and Challenges of Lock-Free Programming)
优势 (Advantages):
① 更高的并发性能 (Higher Concurrency Performance): 无锁编程避免了锁的竞争和阻塞，减少了线程上下文切换的开销，可以显著提高并发性能，尤其是在高并发、低延迟的场景下。
② 更好的响应性 (Better Responsiveness): 无锁编程是非阻塞的，线程不会因为等待锁而挂起，可以更快地响应外部事件，提高程序的响应性。
③ 避免死锁 (Deadlock Avoidance): 无锁编程不使用锁，因此天然地避免了死锁问题。死锁是多线程编程中常见且难以调试的问题，无锁编程可以从根本上解决死锁。
④ 更强的容错性 (Improved Fault Tolerance): 在某些情况下，无锁编程可以提高程序的容错性。例如，如果一个线程在持有锁的情况下崩溃，可能会导致其他线程永久阻塞。而无锁编程没有锁的概念，可以避免这种问题。
挑战 (Challenges):
① 更高的复杂性 (Higher Complexity): 无锁编程比基于锁的编程更复杂，需要深入理解原子操作、内存模型、并发算法等知识。无锁代码更难编写、调试和维护。
② 活锁和饥饿 (Livelock and Starvation): 无锁编程虽然避免了死锁，但可能出现活锁和饥饿问题。活锁是指多个线程不断重试操作，但始终无法成功，导致程序空转。饥饿是指某些线程长时间无法获得执行机会。
③ ABA 问题 (ABA Problem): ABA 问题是无锁编程中常见的问题。当一个线程读取一个值 A，在操作过程中，另一个线程将值修改为 B，又修改回 A。当第一个线程完成操作时，可能会误认为值没有发生变化，导致错误。
④ 调试难度 (Debugging Difficulty): 无锁代码的调试难度较高。由于没有锁的同步，线程间的交互更加复杂，错误更难定位和复现。
7.5.3 常用无锁编程技术 (Common Lock-Free Programming Techniques)
① 原子操作 (Atomic Operations): 原子操作是无锁编程的基础。通过原子操作，可以实现对共享变量的原子读写、原子交换、CAS 等操作，保证数据的一致性。
② CAS (Compare-and-Swap) 操作: CAS 操作是实现无锁数据结构和算法的核心。CAS 操作原子地比较共享变量的值与预期值，如果相等，则将共享变量的值替换为新值。CAS 操作可以用于实现无锁的原子更新操作。
③ 循环重试 (Retry Loops): 在无锁编程中，当操作失败时，通常需要循环重试。重试循环需要 carefully 设计，避免无限循环和活锁。
④ 内存屏障 (Memory Barriers): 内存屏障用于强制内存顺序，保证原子操作的顺序性和可见性。在无锁编程中，需要根据具体的内存模型和同步需求，选择合适的内存顺序和内存屏障。
⑤ RCU (Read-Copy-Update): RCU 是一种高效的无锁并发控制机制，适用于读多写少的场景。RCU 允许多个读者线程并发地读取共享数据，写者线程在更新数据时，先复制一份数据副本，在副本上进行修改，然后通过原子操作切换指针，完成更新。RCU 可以实现非常高的读性能。
7.5.4 无锁编程实践指南 (Practical Guidelines for Lock-Free Programming)
① 谨慎选择无锁编程 (Choose Lock-Free Programming Carefully): 无锁编程的复杂性和风险较高，并非所有场景都适合使用无锁编程。在选择无锁编程之前，需要仔细评估其必要性和可行性。对于简单的并发场景，使用传统的互斥锁可能更简单、更可靠。
② 深入理解原子操作和内存模型 (Deeply Understand Atomic Operations and Memory Model): 无锁编程需要深入理解原子操作的语义和内存模型的规则。不正确的原子操作和内存顺序可能导致严重的并发错误。
③ 从小规模开始，逐步迭代 (Start Small and Iterate Gradually): 无锁编程的开发过程应该从小规模开始，逐步迭代。先实现简单的无锁数据结构或算法，验证其正确性和性能，再逐步扩展到更复杂的场景。
④ 充分测试和验证 (Thoroughly Test and Verify): 无锁代码的测试和验证非常重要。需要设计全面的测试用例，覆盖各种并发场景和边界条件，确保无锁代码的正确性和健壮性。可以使用并发测试工具，例如 ThreadSanitizer、Valgrind 等，辅助测试和调试。
⑤ 考虑使用成熟的无锁库 (Consider Using Mature Lock-Free Libraries): 如果需要使用无锁数据结构或算法，可以考虑使用成熟的无锁库，例如 Boost.Lockfree、folly::AtomicHashMap 等。这些库经过了广泛的测试和验证，可以降低无锁编程的风险和复杂性。
⑥ 保持代码简洁和可读性 (Keep Code Simple and Readable): 无锁代码通常比较复杂，更需要保持代码的简洁和可读性。使用清晰的命名、注释和代码结构，提高代码的可维护性。
7.5.5 实战代码案例 (Practical Code Example)
下面是一个实战代码案例，演示了使用 CAS 操作实现无锁栈（Lock-Free Stack）。无锁栈是一种常用的无锁数据结构，用于实现线程安全的栈操作。
1
#include <atomic>
2
#include <memory>
3
4
template <typename T>
5
class LockFreeStack {
6
private:
7
struct Node {
8
std::shared_ptr<T> data;
9
Node* next;
10
11
Node(const T& data) : data(std::make_shared<T>(data)), next(nullptr) {}
12
};
13
14
std::atomic<Node*> head_;
15
16
public:
17
void push(const T& data) {
18
Node* new_node = new Node(data);
19
Node* old_head = head_.load(std::memory_order_relaxed);
20
do {
21
new_node->next = old_head;
22
} while (!head_.compare_exchange_weak(old_head, new_node, std::memory_order_release, std::memory_order_relaxed));
23
}
24
25
std::shared_ptr<T> pop() {
26
Node* old_head = head_.load(std::memory_order_acquire);
27
while (old_head && !head_.compare_exchange_weak(old_head, old_head->next, std::memory_order_acq_rel, std::memory_order_relaxed));
28
if (old_head) {
29
return old_head->data;
30
} else {
31
return nullptr;
32
}
33
}
34
};
35
36
int main() {
37
LockFreeStack<int> stack;
38
39
std::vector<std::thread> threads;
40
for (int i = 0; i < 2; ++i) {
41
threads.emplace_back([&stack, i]() {
42
for (int j = 0; j < 10; ++j) {
43
stack.push(i * 10 + j);
44
std::this_thread::sleep_for(std::chrono::milliseconds(1));
45
}
46
});
47
}
48
49
for (auto& thread : threads) {
50
thread.join();
51
}
52
53
LOG(INFO) << "Pop from stack:";
54
while (auto data = stack.pop()) {
55
LOG(INFO) << *data;
56
}
57
58
return 0;
59
}
在这个案例中，LockFreeStack 类使用原子指针 head_ 和 CAS 操作 compare_exchange_weak 实现了无锁栈的 push 和 pop 操作。push 操作使用 release 内存顺序，pop 操作使用 acquire 和 acq_rel 内存顺序，保证了栈操作的线程安全性和无锁性。
7.5.6 小结 (Summary)
本节介绍了无锁编程实践，包括：
① 无锁编程的基本概念: 讲解了无锁编程的非阻塞特性，以及无等待和锁自由两种类型。
② 无锁编程的优势与挑战: 分析了无锁编程的优势，例如更高的并发性能、更好的响应性、避免死锁等，以及挑战，例如更高的复杂性、活锁和饥饿、ABA 问题和调试难度。
③ 常用无锁编程技术: 介绍了原子操作、CAS 操作、循环重试、内存屏障和 RCU 等常用无锁编程技术。
④ 无锁编程实践指南: 总结了无锁编程的实践指南，例如谨慎选择无锁编程、深入理解原子操作和内存模型、从小规模开始、充分测试和验证等。
⑤ 实战代码案例: 通过一个无锁栈的例子，演示了使用 CAS 操作实现无锁数据结构。
无锁编程是一种高级的并发编程技术，可以提高程序的并发性能和响应性。但无锁编程的复杂性和风险也较高，需要谨慎选择和使用。在实际应用中，需要根据具体的场景和需求，权衡无锁编程的优势和挑战，选择合适的并发编程方法。
END_OF_CHAPTER
8. chapter 8： Thrift高级特性与最佳实践 (Advanced Thrift Features and Best Practices)
8.1 Thrift中间件 (Middleware) 与拦截器 (Interceptors)：请求处理的扩展与定制 (Thrift Middleware and Interceptors: Extension and Customization of Request Processing)
在构建复杂的Thrift应用时，我们经常需要在请求处理流程中添加一些通用的、可复用的逻辑。例如，日志记录、性能监控、身份验证、授权、请求转换等。为了优雅地实现这些功能，Thrift 引入了中间件 (Middleware) 和 拦截器 (Interceptors) 的概念。它们允许我们在不修改核心业务逻辑的情况下，对请求处理流程进行扩展和定制，提高代码的模块化、可维护性和可扩展性。
中间件 (Middleware) 和 拦截器 (Interceptors) 的核心思想都是责任链模式 (Chain of Responsibility Pattern) 的应用。它们构成一个处理链，每个组件负责处理特定的任务，并将请求传递给链中的下一个组件。这种模式使得我们可以灵活地组合和配置不同的处理逻辑，以满足不同的需求。
8.1.1 中间件 (Middleware) 的概念与应用 (Concept and Application of Middleware)
中间件 (Middleware) 通常应用于服务端，它位于Thrift 服务处理请求的核心逻辑之前或之后，用于处理横切关注点 (Cross-Cutting Concerns)。可以将中间件视为请求处理管道中的一个个环节，每个环节都可以对请求进行预处理、后处理，或者直接终止请求。
常见应用场景：
① 日志记录 (Logging)：在请求开始和结束时记录日志，方便追踪请求处理过程和排查问题。
② 性能监控 (Performance Monitoring)： 记录请求的耗时、吞吐量等指标，用于性能分析和优化。
③ 身份验证 (Authentication)： 验证客户端的身份，确保只有授权用户才能访问服务。
④ 授权 (Authorization)： 检查用户是否具有访问特定资源的权限。
⑤ 请求转换 (Request Transformation)： 修改请求参数或请求头，以适应后端服务的需求。
⑥ 错误处理 (Error Handling)： 统一处理服务端的异常，返回规范的错误响应。
⑦ 追踪 (Tracing)： 为请求添加追踪ID，方便在分布式系统中追踪请求的完整链路。
中间件的优势：
⚝ 解耦 (Decoupling)： 将横切关注点与核心业务逻辑分离，提高代码的模块化和可读性。
⚝ 复用 (Reusability)： 中间件可以被多个服务复用，减少重复代码。
⚝ 灵活 (Flexibility)： 可以根据需要灵活地组合和配置中间件，定制请求处理流程。
⚝ 可维护性 (Maintainability)： 易于维护和扩展，修改中间件不会影响核心业务逻辑。
示例：C++ Thrift 中间件的简单实现
虽然 Thrift 框架本身没有直接提供内置的中间件机制，但我们可以利用 C++ 的特性，例如 函数对象 (Function Object) 或 Lambda 表达式 (Lambda Expression)，来模拟中间件的实现。
1
#include <iostream>
2
#include <functional>
3
4
// 定义中间件类型，接受一个处理函数并返回一个新的处理函数
5
using Middleware = std::function<std::function<void(int)> (std::function<void(int)>)>;
6
7
// 示例中间件：日志记录中间件
8
Middleware loggingMiddleware = [](std::function<void(int)> next) {
9
return [next](int request) {
10
std::cout << "Request received: " << request << std::endl;
11
next(request);
12
std::cout << "Request processed: " << request << std::endl;
13
};
14
};
15
16
// 示例中间件：身份验证中间件 (简化版)
17
Middleware authMiddleware = [](std::function<void(int)> next) {
18
return [next](int request) {
19
if (request % 2 == 0) { // 简单示例：只允许偶数请求
20
std::cout << "Authentication passed." << std::endl;
21
next(request);
22
} else {
23
std::cout << "Authentication failed." << std::endl;
24
}
25
};
26
};
27
28
// 核心业务处理函数
29
void processRequest(int request) {
30
std::cout << "Processing request: " << request << std::endl;
31
}
32
33
int main() {
34
// 将中间件链式组合
35
auto handler = loggingMiddleware(authMiddleware(processRequest));
36
37
handler(10); // 处理请求 10 (偶数，通过验证)
38
handler(11); // 处理请求 11 (奇数，验证失败)
39
40
return 0;
41
}
代码解释：
⚝ Middleware 类型定义了一个中间件，它是一个接受一个处理函数 (std::function<void(int)>) 并返回一个新的处理函数的函数对象。
⚝ loggingMiddleware 和 authMiddleware 是两个示例中间件，分别实现了日志记录和身份验证的功能。
⚝ processRequest 是核心业务处理函数。
⚝ 在 main 函数中，我们使用 函数组合 (Function Composition) 的方式，将中间件链式组合起来，形成最终的处理链 handler。
⚝ 调用 handler(request) 时，请求会依次经过 loggingMiddleware、authMiddleware 和 processRequest 的处理。
注意： 这只是一个简化的示例，用于说明中间件的概念。在实际的 Thrift 应用中，中间件的实现会更加复杂，可能需要考虑请求上下文 (Request Context)、异常处理、异步处理等问题。一些 Thrift 框架或库可能会提供更完善的中间件支持。
8.1.2 拦截器 (Interceptors) 的概念与应用 (Concept and Application of Interceptors)
拦截器 (Interceptors) 的概念与中间件非常相似，在某些上下文中，这两个术语可以互换使用。然而，在 Thrift 的语境下，拦截器 (Interceptors) 更常用于描述客户端和服务端在 RPC (Remote Procedure Call) 调用过程中，对请求和响应进行拦截和处理的机制。
拦截器 (Interceptors) 可以应用于客户端和服务端，在 RPC 调用的不同阶段进行拦截：
⚝ 客户端拦截器 (Client Interceptors)：
▮▮▮▮⚝ 请求拦截 (Request Interception)： 在客户端发送请求之前拦截，可以修改请求参数、添加请求头、进行身份验证等。
▮▮▮▮⚝ 响应拦截 (Response Interception)： 在客户端接收到服务端响应之后拦截，可以处理响应结果、记录响应日志、处理错误等。
⚝ 服务端拦截器 (Server Interceptors)：
▮▮▮▮⚝ 请求拦截 (Request Interception)： 在服务端接收到客户端请求之后，但在调用服务处理函数之前拦截，可以进行身份验证、授权、日志记录、性能监控等。
▮▮▮▮⚝ 响应拦截 (Response Interception)： 在服务端服务处理函数执行完毕之后，但在将响应发送回客户端之前拦截，可以修改响应结果、记录响应日志、处理异常等。
常见应用场景 (与中间件类似，但更侧重于 RPC 调用过程)：
① 客户端请求重试 (Client Request Retry)： 在客户端请求失败时，根据策略进行自动重试。
② 客户端负载均衡 (Client Load Balancing)： 客户端根据负载均衡策略选择服务端实例。
③ 客户端请求追踪 (Client Request Tracing)： 为客户端请求添加追踪信息，方便分布式追踪。
④ 服务端身份验证与授权 (Server Authentication and Authorization)： 验证客户端身份，控制访问权限。
⑤ 服务端请求日志与监控 (Server Request Logging and Monitoring)： 记录服务端请求日志，监控服务性能。
⑥ 服务端错误处理与转换 (Server Error Handling and Transformation)： 统一处理服务端错误，返回规范的错误响应。
拦截器的优势：
⚝ 细粒度控制 (Fine-grained Control)： 拦截器可以精确地控制 RPC 调用的各个阶段，提供更细粒度的扩展能力.
⚝ 跨客户端/服务端 (Cross-Client/Server)： 拦截器可以同时应用于客户端和服务端，实现端到端的请求处理定制。
⚝ 与 RPC 框架集成 (RPC Framework Integration)： 拦截器通常与 RPC 框架紧密集成，可以方便地访问 RPC 上下文信息。
示例： gRPC Interceptors (gRPC 的拦截器机制与 Thrift 类似)
虽然 Thrift 自身没有像 gRPC 那样明确的 "Interceptor" 接口，但 gRPC 的拦截器机制可以很好地说明拦截器的概念和用法。gRPC 提供了客户端和服务端拦截器，允许开发者在 RPC 调用的不同阶段插入自定义逻辑。
1
// gRPC C++ 示例 (仅为说明概念，非 Thrift 代码)
2
3
#include <grpcpp/grpcpp.h>
4
5
// 示例客户端拦截器：日志记录拦截器
6
class LoggingInterceptor : public grpc::ClientInterceptor {
7
public:
8
grpc::ClientUnaryReactor*拦截器InterceptUnary(
9
grpc::ClientRpcInfo* rpc_info,
10
grpc::string_ref method,
11
grpc::ClientContext* context,
12
grpc::ClientUnaryReactor* reactor) override {
13
std::cout << "Client Request: Method=" << method << std::endl;
14
return reactor; // 继续执行后续拦截器或发送请求
15
}
16
17
grpc::ClientWriteReactor<grpc::ByteBuffer>* InterceptStreamingWrite(
18
grpc::ClientRpcInfo* rpc_info,
19
grpc::string_ref method,
20
grpc::ClientContext* context,
21
grpc::ClientWriteReactor<grpc::ByteBuffer>* reactor) override {
22
std::cout << "Client Streaming Write: Method=" << method << std::endl;
23
return reactor;
24
}
25
// ... 其他拦截方法 (StreamingRead, StreamingFullDuplex)
26
};
27
28
// 示例服务端拦截器：身份验证拦截器 (简化版)
29
class AuthInterceptor : public grpc::ServerInterceptor {
30
public:
31
grpc::ServerUnaryReactor* InterceptCall(
32
grpc::CallbackServerContext* context,
33
grpc::CallbackUnaryHandler method_handler,
34
grpc::ServerRpcInfo* info) override {
35
const std::string& token = context->credentials()->auth_context()->FindProperty("token");
36
if (token == "valid_token") { // 简单示例：验证 token
37
std::cout << "Server Authentication passed." << std::endl;
38
return method_handler(context, info); // 继续执行服务处理函数
39
} else {
40
std::cout << "Server Authentication failed." << std::endl;
41
context->AddInitialMetadata("error", "Authentication failed");
42
return grpc::ServerInterceptor::PrependInterceptor(
43
[](grpc::CallbackServerContext* context, grpc::ServerRpcInfo* info) {
44
return grpc::Status(grpc::StatusCode::UNAUTHENTICATED, "Authentication failed");
45
})(context, info); // 返回错误状态
46
}
47
}
48
// ... 其他拦截方法 (Streaming...)
49
};
50
51
int main() {
52
// ... 创建 gRPC Channel 和 Stub
53
// ... 创建拦截器链
54
std::vector<std::unique_ptr<grpc::ClientInterceptorFactoryInterface>> interceptor_factories;
55
interceptor_factories.push_back(std::make_unique<LoggingInterceptor::Factory>());
56
57
// ... 使用拦截器链创建 Channel
58
// ... 调用 gRPC 服务
59
return 0;
60
}
代码解释 (gRPC 示例)：
⚝ LoggingInterceptor 和 AuthInterceptor 是 gRPC 的客户端和服务端拦截器示例。
⚝ InterceptUnary 和 InterceptCall 等方法分别拦截不同类型的 RPC 调用 (Unary, Streaming 等)。
⚝ 拦截器可以访问 RPC 上下文信息 (ClientContext, ServerContext, ServerRpcInfo)，并可以修改请求、响应或直接终止调用。
⚝ gRPC 提供了方便的机制来注册和链式组合拦截器。
Thrift 中实现拦截器：
虽然 Thrift C++ 库没有像 gRPC 那样提供官方的拦截器接口，但我们可以通过以下方式在 Thrift 中实现类似拦截器的功能：
⚝ 手动包装处理器 (Manual Handler Wrapping)： 在服务端，我们可以手动包装生成的服务处理器 (Processor)，在包装器中实现拦截逻辑，例如日志记录、身份验证等。
⚝ 自定义传输层 (Custom Transport Layer)： 可以自定义 Thrift 的传输层 (Transport)，在传输层中拦截请求和响应，实现更底层的拦截功能。
⚝ 代码生成插件 (Code Generation Plugins)： 可以开发 Thrift 代码生成插件，在生成的代码中自动插入拦截器代码。
总结：
中间件 (Middleware) 和 拦截器 (Interceptors) 都是用于扩展和定制请求处理流程的重要机制。它们通过责任链模式，将横切关注点与核心业务逻辑解耦，提高了代码的模块化、可复用性和可维护性。在 Thrift 应用中，我们可以根据具体需求选择合适的实现方式，例如手动包装处理器、自定义传输层或代码生成插件，来构建灵活可扩展的请求处理管道。
8.2 Thrift服务治理：负载均衡、熔断、限流 (Thrift Service Governance: Load Balancing, Circuit Breaking, Rate Limiting)
在构建微服务架构 (Microservice Architecture) 或 分布式系统 (Distributed System) 时，服务治理 (Service Governance) 至关重要。服务治理是指为了保证服务的高可用性 (High Availability)、稳定性 (Stability) 和 可扩展性 (Scalability) 而采取的一系列措施和策略。对于基于 Thrift 构建的服务，服务治理同样不可或缺。
本节将介绍 Thrift 服务治理中三个核心概念：负载均衡 (Load Balancing)、熔断 (Circuit Breaking) 和 限流 (Rate Limiting)，并探讨如何在 Thrift 应用中实现这些治理策略。
8.2.1 负载均衡 (Load Balancing)
负载均衡 (Load Balancing) 是指将客户端请求均匀地分发到多个服务端实例上，以提高系统的整体性能和可用性。当服务部署多个实例时，负载均衡可以有效地利用所有实例的资源，避免单个实例过载，从而提高系统的吞吐量和响应速度。同时，当某个实例发生故障时，负载均衡可以将请求自动切换到其他健康实例，保证服务的持续可用性。
常见的负载均衡策略：
① 轮询 (Round Robin)： 请求依次轮流分配到每个服务端实例。策略简单，但未考虑实例的实际负载情况。
② 加权轮询 (Weighted Round Robin)： 根据服务端实例的性能配置权重，权重高的实例分配更多的请求。
③ 最少连接 (Least Connections)： 将请求分配到当前连接数最少的实例。适用于长连接场景。
④ 随机 (Random)： 随机选择一个服务端实例。
⑤ IP Hash (IP Hash)： 根据客户端 IP 地址的 Hash 值选择服务端实例。保证来自同一客户端的请求始终路由到同一实例 (会话保持)。
⑥ 一致性哈希 (Consistent Hashing)： 将请求的某个属性 (例如请求 ID) 进行哈希，映射到服务端实例。当实例数量变化时，影响范围较小。
Thrift 中的负载均衡实现：
Thrift 客户端本身不直接提供内置的负载均衡功能。负载均衡通常需要在客户端或专门的负载均衡器 (例如 Nginx, HAProxy, Consul, ZooKeeper 等) 中实现。
实现方式：
⚝ 客户端负载均衡 (Client-Side Load Balancing)：
▮▮▮▮⚝ 客户端维护服务端实例列表 (例如从 服务发现 (Service Discovery) 组件获取)。
▮▮▮▮⚝ 客户端根据负载均衡策略选择一个实例，并直接向该实例发送请求。
▮▮▮▮⚝ 优点： 减少了中间负载均衡器的网络跳数，降低了延迟。
▮▮▮▮⚝ 缺点： 客户端需要实现负载均衡逻辑，增加了客户端的复杂性。客户端需要感知服务端实例的健康状态。
⚝ 服务端负载均衡 (Server-Side Load Balancing)：
▮▮▮▮⚝ 客户端将所有请求发送到一个或多个 负载均衡器 (Load Balancer)。
▮▮▮▮⚝ 负载均衡器根据配置的策略将请求转发到后端的 Thrift 服务实例。
▮▮▮▮⚝ 优点： 客户端无需关心负载均衡细节，简化了客户端的实现。负载均衡器可以集中管理和监控服务端实例。
▮▮▮▮⚝ 缺点： 增加了中间负载均衡器的网络跳数，可能增加延迟。负载均衡器本身可能成为单点故障。
Thrift 客户端负载均衡示例 (C++，伪代码)：
1
#include "gen-cpp/YourService.h" // Thrift 生成的代码
2
#include <thrift/transport/TSocket.h>
3
#include <thrift/transport/TBufferedTransport.h>
4
#include <thrift/protocol/TBinaryProtocol.h>
5
#include <vector>
6
#include <random>
7
8
using namespace apache::thrift;
9
using namespace apache::thrift::transport;
10
using namespace apache::thrift::protocol;
11
12
int main() {
13
std::vector<std::string> server_addresses = {"server1:9090", "server2:9090", "server3:9090"}; // 服务端实例地址列表
14
std::random_device rd;
15
std::mt19937 gen(rd());
16
std::uniform_int_distribution<> distrib(0, server_addresses.size() - 1);
17
18
for (int i = 0; i < 10; ++i) { // 发送 10 个请求
19
int server_index = distrib(gen); // 随机选择服务端实例 (简单随机策略)
20
std::string server_address = server_addresses[server_index];
21
size_t colon_pos = server_address.find(':');
22
std::string host = server_address.substr(0, colon_pos);
23
int port = std::stoi(server_address.substr(colon_pos + 1));
24
25
std::shared_ptr<TTransport> socket(new TSocket(host, port));
26
std::shared_ptr<TTransport> transport(new TBufferedTransport(socket));
27
std::shared_ptr<TProtocol> protocol(new TBinaryProtocol(transport));
28
YourServiceClient client(protocol);
29
30
try {
31
transport->open();
32
int result = client.yourMethod(i); // 调用 Thrift 服务方法
33
std::cout << "Request " << i << " to " << server_address << ", result: " << result << std::endl;
34
transport->close();
35
} catch (TException& tx) {
36
std::cerr << "Error: " << tx.what() << std::endl;
37
}
38
}
39
return 0;
40
}
代码解释 (伪代码)：
⚝ server_addresses 存储服务端实例的地址列表。
⚝ 使用 std::random_device 和 std::mt19937 生成随机数，实现简单的随机负载均衡策略。
⚝ 每次请求随机选择一个服务端实例地址，创建 Thrift 客户端并调用服务方法。
实际应用中，更推荐使用专业的负载均衡器或服务发现组件，例如：
⚝ Nginx/HAProxy (服务端负载均衡器)： 成熟的 HTTP 和 TCP 负载均衡器，可以用于 Thrift 服务的负载均衡。
⚝ Consul/ZooKeeper/etcd (服务发现与配置中心)： 可以用于服务注册与发现，客户端可以从服务发现组件获取服务端实例列表，并实现客户端负载均衡。
⚝ Kubernetes Service (容器编排平台)： 在 Kubernetes 环境中，可以使用 Service 资源实现 Thrift 服务的负载均衡。
8.2.2 熔断 (Circuit Breaking)
熔断 (Circuit Breaking) 是一种保护分布式系统的设计模式，用于防止服务雪崩效应。当某个服务出现故障或延迟升高时，熔断器可以快速切断对该服务的请求，避免故障蔓延到整个系统。熔断器类似于电路中的保险丝，当电流过大时会自动熔断，保护电路。
熔断器的三种状态：
① 关闭 (Closed)： 默认状态。请求正常流向后端服务。熔断器会监控请求的成功率或错误率。
② 打开 (Open)： 当错误率超过阈值时，熔断器从关闭状态切换到打开状态。在打开状态下，所有请求都会被快速失败，不会发送到后端服务。
③ 半开 (Half-Open)： 经过一段时间后 (例如 重试超时 (Retry Timeout))，熔断器会从打开状态切换到半开状态。在半开状态下，熔断器允许少量请求 (例如 探测请求 (Probe Request)) 发送到后端服务，探测服务是否恢复。如果探测请求成功，熔断器切换回关闭状态；如果探测请求失败，熔断器切换回打开状态。
熔断器的工作流程：
- 监控 (Monitoring)： 熔断器监控对后端服务的请求，记录成功次数、失败次数、延迟等指标。
- 阈值判断 (Threshold Check)： 熔断器根据监控指标判断是否需要熔断。例如，如果错误率在一定时间内超过阈值 (例如 50%)，则触发熔断。
- 状态切换 (State Transition)： 当满足熔断条件时，熔断器从关闭状态切换到打开状态。当需要探测服务恢复时，从打开状态切换到半开状态。
- 请求处理 (Request Handling)： 在关闭状态下，请求正常发送到后端服务。在打开状态下，请求快速失败。在半开状态下，允许少量探测请求。
Thrift 中的熔断实现：
Thrift 客户端本身没有内置熔断器功能。熔断器通常需要在客户端或专门的服务治理组件中实现。
实现方式：
⚝ 客户端熔断器 (Client-Side Circuit Breaker)：
▮▮▮▮⚝ 客户端集成熔断器库 (例如 Netflix Hystrix, Resilience4j, Polly 等的 C++ 版本或类似实现)。
▮▮▮▮⚝ 熔断器库负责监控请求、管理熔断器状态、执行熔断逻辑。
▮▮▮▮⚝ 优点： 熔断逻辑与客户端集成，响应速度快。
▮▮▮▮⚝ 缺点： 客户端需要引入熔断器库，增加了客户端的复杂性。
⚝ 服务网格 (Service Mesh) 熔断器：
▮▮▮▮⚝ 在 服务网格 (Service Mesh) 环境 (例如 Istio, Linkerd) 中，服务网格的 Sidecar Proxy (边车代理) 可以提供熔断功能。
▮▮▮▮⚝ 优点： 无需修改客户端代码，熔断策略由服务网格统一管理。
▮▮▮▮⚝ 缺点： 增加了服务网格的部署和维护成本。
客户端熔断器示例 (C++，伪代码，使用简单的状态机模拟)：
1
#include "gen-cpp/YourService.h" // Thrift 生成的代码
2
#include <thrift/transport/TSocket.h>
3
#include <thrift/transport/TBufferedTransport.h>
4
#include <thrift/protocol/TBinaryProtocol.h>
5
#include <chrono>
6
#include <iostream>
7
#include <atomic>
8
9
using namespace apache::thrift;
10
using namespace apache::thrift::transport;
11
using namespace apache::thrift::protocol;
12
using namespace std::chrono;
13
14
enum class CircuitBreakerState { CLOSED, OPEN, HALF_OPEN };
15
16
class SimpleCircuitBreaker {
17
public:
18
SimpleCircuitBreaker() : state_(CircuitBreakerState::CLOSED), failure_count_(0), last_failure_time_(steady_clock::now()) {}
19
20
bool isCallAllowed() {
21
CircuitBreakerState current_state = state_.load();
22
if (current_state == CircuitBreakerState::OPEN) {
23
if (steady_clock::now() - last_failure_time_ > retry_timeout_) {
24
if (state_.compare_exchange_strong(current_state, CircuitBreakerState::HALF_OPEN)) { // 尝试切换到 HALF_OPEN
25
std::cout << "Circuit Breaker HALF_OPEN" << std::endl;
26
return true; // 允许探测请求
27
}
28
}
29
return false; // OPEN 状态，且未超时，拒绝请求
30
}
31
return true; // CLOSED 或 HALF_OPEN 状态，允许请求
32
}
33
34
void onCallSuccess() {
35
if (state_.load() == CircuitBreakerState::HALF_OPEN) {
36
state_.store(CircuitBreakerState::CLOSED); // HALF_OPEN 探测成功，切换回 CLOSED
37
failure_count_.store(0);
38
std::cout << "Circuit Breaker CLOSED (recovered)" << std::endl;
39
} else {
40
failure_count_.store(0); // CLOSED 状态，成功请求，重置失败计数
41
}
42
}
43
44
void onCallFailure() {
45
failure_count_.fetch_add(1);
46
last_failure_time_ = steady_clock::now();
47
if (failure_count_.load() > failure_threshold_) {
48
if (state_.compare_exchange_strong(CircuitBreakerState::CLOSED, CircuitBreakerState::OPEN)) { // 尝试切换到 OPEN
49
std::cout << "Circuit Breaker OPEN" << std::endl;
50
}
51
}
52
}
53
54
private:
55
std::atomic<CircuitBreakerState> state_;
56
std::atomic<int> failure_count_;
57
time_point<steady_clock> last_failure_time_;
58
const int failure_threshold_ = 5; // 失败次数阈值
59
const milliseconds retry_timeout_ = milliseconds(5000); // 重试超时时间
60
};
61
62
int main() {
63
SimpleCircuitBreaker circuitBreaker;
64
std::string server_address = "localhost:9090";
65
size_t colon_pos = server_address.find(':');
66
std::string host = server_address.substr(0, colon_pos);
67
int port = std::stoi(server_address.substr(colon_pos + 1));
68
69
for (int i = 0; i < 20; ++i) {
70
if (!circuitBreaker.isCallAllowed()) {
71
std::cout << "Circuit Breaker OPEN, request " << i << " rejected." << std::endl;
72
continue; // 熔断器打开，拒绝请求
73
}
74
75
std::shared_ptr<TTransport> socket(new TSocket(host, port));
76
std::shared_ptr<TTransport> transport(new TBufferedTransport(socket));
77
std::shared_ptr<TProtocol> protocol(new TBinaryProtocol(transport));
78
YourServiceClient client(protocol);
79
80
try {
81
transport->open();
82
int result = client.yourMethod(i);
83
std::cout << "Request " << i << " success, result: " << result << std::endl;
84
circuitBreaker.onCallSuccess(); // 请求成功，通知熔断器
85
transport->close();
86
} catch (TException& tx) {
87
std::cerr << "Request " << i << " failed: " << tx.what() << std::endl;
88
circuitBreaker.onCallFailure(); // 请求失败，通知熔断器
89
}
90
std::this_thread::sleep_for(milliseconds(200)); // 模拟请求间隔
91
}
92
return 0;
93
}
代码解释 (伪代码)：
⚝ SimpleCircuitBreaker 类实现了一个简单的熔断器，包含 CLOSED, OPEN, HALF_OPEN 三种状态。
⚝ isCallAllowed() 方法判断是否允许请求通过熔断器。
⚝ onCallSuccess() 和 onCallFailure() 方法分别在请求成功和失败时被调用，用于更新熔断器状态。
⚝ 示例代码模拟了请求失败场景，当失败次数超过阈值时，熔断器会打开，拒绝后续请求。一段时间后，熔断器会尝试半开，探测服务是否恢复。
实际应用中，建议使用成熟的熔断器库，例如：
⚝ Netflix Hystrix (Java, C++)： Netflix 开源的熔断器库，功能强大，但已进入维护模式。
⚝ Resilience4j (Java)： 轻量级的熔断器库，基于 Java 8 函数式编程，功能丰富。
⚝ Polly (.NET, C++)： .NET 和 C++ 的弹性策略库，包含熔断器、重试、超时等策略。
8.2.3 限流 (Rate Limiting)
限流 (Rate Limiting) 是指限制服务在单位时间内接收的请求数量，以保护服务免受过载的影响。当请求量超过服务处理能力时，限流可以防止服务崩溃，保证服务的稳定性和可用性。限流是服务治理的重要手段之一，尤其是在应对突发流量或恶意攻击时。
常见的限流算法：
① 计数器 (Counter)： 最简单的限流算法。在单位时间内，记录请求数量，当请求数量超过阈值时，拒绝后续请求。
▮▮▮▮⚝ 固定窗口计数器 (Fixed Window Counter)： 在固定的时间窗口内 (例如 1 秒)，计数器从 0 开始计数，当计数器达到阈值时，拒绝后续请求。时间窗口结束后，计数器重置为 0。
▮▮▮▮⚝ 滑动窗口计数器 (Sliding Window Counter)： 比固定窗口计数器更精确。将时间窗口划分为更小的格子，滑动窗口随着时间滑动，统计当前窗口内的请求数量。
② 令牌桶 (Token Bucket)： 以恒定速率向令牌桶中放入令牌，每个请求需要从令牌桶中获取一个令牌才能被处理。如果令牌桶中没有令牌，则拒绝请求。令牌桶算法允许一定程度的突发流量。
③ 漏桶 (Leaky Bucket)： 类似于令牌桶，但漏桶以恒定速率从桶中漏出请求 (而不是令牌)。请求先进入漏桶，如果漏桶已满，则拒绝请求。漏桶算法可以平滑突发流量。
Thrift 中的限流实现：
Thrift 客户端和服务端都可以实现限流。
实现方式：
⚝ 客户端限流 (Client-Side Rate Limiting)： 客户端在发送请求之前进行限流，防止客户端请求过快导致服务端过载。客户端限流通常用于保护下游服务。
⚝ 服务端限流 (Server-Side Rate Limiting)： 服务端在接收到请求之后进行限流，保护服务端自身免受过载影响。服务端限流是更常见的限流方式。
服务端限流示例 (C++，使用令牌桶算法)：
1
#include "gen-cpp/YourService.h" // Thrift 生成的代码
2
#include <thrift/transport/TServerSocket.h>
3
#include <thrift/transport/TBufferedTransport.h>
4
#include <thrift/protocol/TBinaryProtocol.h>
5
#include <chrono>
6
#include <mutex>
7
#include <condition_variable>
8
#include <iostream>
9
10
using namespace apache::thrift;
11
using namespace apache::thrift::transport;
12
using namespace apache::thrift::protocol;
13
using namespace std::chrono;
14
15
class TokenBucketRateLimiter {
16
public:
17
TokenBucketRateLimiter(int capacity, double rate) :
18
capacity_(capacity), rate_(rate), tokens_(capacity), last_refill_time_(steady_clock::now()) {}
19
20
bool allowRequest() {
21
std::unique_lock<std::mutex> lock(mutex_);
22
refillTokens(); // 先补充令牌
23
if (tokens_ > 0) {
24
tokens_--;
25
return true; // 允许请求
26
} else {
27
return false; // 拒绝请求
28
}
29
}
30
31
private:
32
void refillTokens() {
33
auto now = steady_clock::now();
34
duration<double> time_elapsed = now - last_refill_time_;
35
int tokens_to_add = static_cast<int>(time_elapsed.count() * rate_); // 计算需要补充的令牌数量
36
if (tokens_to_add > 0) {
37
tokens_ = std::min(tokens_ + tokens_to_add, capacity_); // 补充令牌，不超过桶的容量
38
last_refill_time_ = now;
39
}
40
}
41
42
int capacity_; // 令牌桶容量
43
double rate_; // 令牌生成速率 (令牌/秒)
44
int tokens_; // 当前令牌数量
45
time_point<steady_clock> last_refill_time_;
46
std::mutex mutex_;
47
};
48
49
class YourServiceHandler : virtual public YourServiceIf {
50
public:
51
YourServiceHandler(TokenBucketRateLimiter& limiter) : limiter_(limiter) {}
52
53
int yourMethod(int req) override {
54
if (limiter_.allowRequest()) {
55
std::cout << "Request " << req << " allowed." << std::endl;
56
// ... 实际业务逻辑
57
return req * 2;
58
} else {
59
std::cout << "Request " << req << " rejected (rate limited)." << std::endl;
60
throw TException("Rate limit exceeded"); // 抛出异常或返回错误码
61
}
62
}
63
64
private:
65
TokenBucketRateLimiter& limiter_;
66
};
67
68
int main() {
69
int port = 9090;
70
TokenBucketRateLimiter limiter(10, 5.0); // 令牌桶容量 10，令牌生成速率 5 个/秒
71
72
std::shared_ptr<YourServiceHandler> handler(new YourServiceHandler(limiter));
73
std::shared_ptr<TProcessor> processor(new YourServiceProcessor(handler));
74
std::shared_ptr<TServerTransport> serverTransport(new TServerSocket(port));
75
std::shared_ptr<TTransportFactory> transportFactory(new TBufferedTransportFactory());
76
std::shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());
77
78
TSimpleServer server(processor, serverTransport, transportFactory, protocolFactory);
79
std::cout << "Starting server on port " << port << std::endl;
80
server.serve();
81
return 0;
82
}
代码解释 (伪代码)：
⚝ TokenBucketRateLimiter 类实现了令牌桶限流算法。
⚝ allowRequest() 方法尝试从令牌桶中获取令牌，如果成功则返回 true，否则返回 false。
⚝ YourServiceHandler 在处理请求之前，先调用 limiter_.allowRequest() 进行限流检查。
⚝ 如果请求被限流，则抛出 TException 异常或返回错误码。
实际应用中，可以使用更成熟的限流库或组件，例如：
⚝ Guava RateLimiter (Java)： Google Guava 库提供的令牌桶限流器。
⚝ Redis/令牌桶模块 (Redis-Cell)： 可以使用 Redis 实现分布式限流，例如使用 Redis-Cell 模块实现令牌桶算法。
⚝ Nginx/OpenResty 限流模块： Nginx 和 OpenResty 提供了丰富的限流模块，例如 ngx_http_limit_req_module (基于漏桶算法)。
⚝ 服务网格 (Service Mesh) 限流： 服务网格可以提供统一的限流策略管理。
总结：
负载均衡 (Load Balancing)、熔断 (Circuit Breaking) 和 限流 (Rate Limiting) 是 Thrift 服务治理中至关重要的三个方面。它们共同保障了 Thrift 服务的 高可用性 (High Availability)、稳定性 (Stability) 和 可扩展性 (Scalability)。在实际应用中，需要根据具体场景和需求选择合适的治理策略和实现方式，例如客户端负载均衡或服务端负载均衡，客户端熔断器或服务网格熔断器，服务端令牌桶限流或 Nginx 限流等。合理的服务治理策略是构建健壮可靠的 Thrift 分布式系统的关键。
8.3 Thrift监控与日志：性能分析与故障排查 (Thrift Monitoring and Logging: Performance Analysis and Troubleshooting)
监控 (Monitoring) 和 日志 (Logging) 是分布式系统中不可或缺的组成部分。对于基于 Thrift 构建的服务，有效的监控和日志系统能够帮助我们实时了解服务的运行状态、性能指标，及时发现和解决问题，保障服务的稳定性和可靠性。
本节将介绍 Thrift 监控与日志的关键要素，以及如何利用监控和日志进行性能分析和故障排查。
8.3.1 Thrift 监控 (Thrift Monitoring)
监控 (Monitoring) 是指对 Thrift 服务的关键指标进行实时采集、分析和展示，以便及时了解服务的运行状况。监控可以帮助我们：
① 实时了解服务状态 (Real-time Service Status)： 监控服务的 请求量 (Request Volume)、响应时间 (Response Time)、错误率 (Error Rate)、资源利用率 (Resource Utilization) (CPU, 内存, 网络等) 等指标，实时掌握服务的健康状况。
② 性能分析与优化 (Performance Analysis and Optimization)： 通过监控数据分析服务的性能瓶颈，例如慢请求、高延迟等，并进行性能优化。
③ 故障预警与快速定位 (Fault Alerting and Rapid Localization)： 当监控指标异常 (例如错误率升高、延迟增加) 时，及时发出告警，帮助运维人员快速定位故障原因。
④ 容量规划 (Capacity Planning)： 根据历史监控数据和业务增长趋势，进行容量规划，预测服务所需的资源，避免资源瓶颈。
Thrift 监控指标：
⚝ 请求指标 (Request Metrics)：
▮▮▮▮⚝ 总请求量 (Total Requests)： 服务接收的总请求数量。
▮▮▮▮⚝ 成功请求量 (Successful Requests)： 服务成功处理的请求数量。
▮▮▮▮⚝ 失败请求量 (Failed Requests)： 服务处理失败的请求数量。
▮▮▮▮⚝ 请求错误率 (Request Error Rate)： 失败请求量占总请求量的比例。
▮▮▮▮⚝ 请求延迟 (Request Latency)： 请求从客户端发送到服务端响应返回的耗时。可以统计平均延迟、最大延迟、P50, P90, P99 延迟等。
▮▮▮▮⚝ 请求吞吐量 (Request Throughput)： 单位时间内服务处理的请求数量 (例如 QPS, Queries Per Second)。
⚝ 资源指标 (Resource Metrics)：
▮▮▮▮⚝ CPU 使用率 (CPU Utilization)： 服务进程的 CPU 使用率。
▮▮▮▮⚝ 内存使用率 (Memory Utilization)： 服务进程的内存使用率。
▮▮▮▮⚝ 磁盘 I/O (Disk I/O)： 服务进程的磁盘读写速率。
▮▮▮▮⚝ 网络 I/O (Network I/O)： 服务进程的网络收发速率。
▮▮▮▮⚝ 连接数 (Connection Count)： 服务进程的 TCP 连接数。
▮▮▮▮⚝ 线程数 (Thread Count)： 服务进程的线程数。
▮▮▮▮⚝ 句柄数 (File Descriptor Count)： 服务进程的文件句柄数。
⚝ JVM 指标 (如果 Thrift 服务使用 Java 实现)：
▮▮▮▮⚝ JVM 内存使用情况 (Heap/Non-Heap Memory Usage)： JVM 堆内存和非堆内存的使用情况。
▮▮▮▮⚝ 垃圾回收 (Garbage Collection) 统计： GC 次数、GC 耗时等。
▮▮▮▮⚝ 线程池 (ThreadPool) 状态： 线程池活跃线程数、队列长度等。
Thrift 监控实现方案：
① Thrift 内置监控 (Thrift Built-in Monitoring)： Thrift 框架本身没有内置完善的监控功能。但可以通过自定义 传输层 (Transport) 或 协议层 (Protocol)，在请求处理过程中埋点，采集监控指标。
② Metrics 库集成 (Metrics Library Integration)： 集成成熟的 Metrics 库 (Metrics Library)，例如 Prometheus Client Library, Micrometer, Dropwizard Metrics 等。
▮▮▮▮⚝ 在 Thrift 服务代码中，使用 Metrics 库提供的 API 注册和更新监控指标。
▮▮▮▮⚝ Metrics 库负责指标的采集、聚合和导出。
▮▮▮▮⚝ 优点： 功能强大，生态完善，支持多种监控系统。
▮▮▮▮⚝ 缺点： 需要引入 Metrics 库，增加代码依赖。
③ APM 系统集成 (Application Performance Monitoring System Integration)： 集成 APM 系统 (Application Performance Monitoring System)，例如 SkyWalking, Jaeger, Zipkin, Pinpoint 等。
▮▮▮▮⚝ APM 系统可以提供更全面的监控功能，包括 分布式追踪 (Distributed Tracing)、性能分析 (Profiling)、告警 (Alerting) 等。
▮▮▮▮⚝ APM 系统通常提供 Agent (代理) 或 SDK (软件开发工具包)，需要集成到 Thrift 服务中。
▮▮▮▮⚝ 优点： 功能强大，提供全链路追踪和性能分析，适用于复杂的微服务架构。
▮▮▮▮⚝ 缺点： 部署和维护成本较高，需要学习和配置 APM 系统。
④ 自定义监控系统 (Custom Monitoring System)： 根据自身需求，开发自定义监控系统。
▮▮▮▮⚝ 可以使用 StatsD, Graphite, InfluxDB, Prometheus 等时序数据库存储监控数据。
▮▮▮▮⚝ 可以使用 Grafana, Kibana 等可视化工具展示监控数据。
▮▮▮▮⚝ 优点： 灵活性高，可以根据需求定制监控指标和展示界面。
▮▮▮▮⚝ 缺点： 开发和维护成本较高。
Prometheus + Grafana 监控 Thrift 服务示例 (概念性描述)：
- 集成 Prometheus Client Library (C++) 到 Thrift 服务端代码中。
- 定义 Thrift 监控指标，例如请求量、延迟、错误率等，并使用 Prometheus Client Library 注册指标。
- 在 Thrift 服务处理请求的过程中，更新监控指标。例如，在请求开始时记录开始时间，在请求结束时计算延迟，并更新延迟直方图指标。
- 暴露 Prometheus Metrics Endpoint (/metrics)，用于 Prometheus Server 抓取监控数据。
- 部署 Prometheus Server，配置 Prometheus Server 抓取 Thrift 服务的 /metrics Endpoint。
- 部署 Grafana，配置 Grafana 数据源为 Prometheus Server。
- 在 Grafana 中创建监控 Dashboard，展示 Thrift 服务的监控指标，例如请求量、延迟、错误率、资源利用率等。
8.3.2 Thrift 日志 (Thrift Logging)
日志 (Logging) 是指记录 Thrift 服务运行过程中的各种事件和信息，用于故障排查、审计、安全分析等。良好的日志系统可以帮助我们：
① 故障排查 (Troubleshooting)： 当服务出现故障时，通过分析日志，可以快速定位故障原因，例如错误信息、异常堆栈、请求参数等。
② 审计 (Auditing)： 记录用户的操作行为、访问日志等，用于安全审计和合规性检查。
③ 性能分析 (Performance Analysis)： 通过分析日志中的请求延迟、慢查询日志等，可以进行性能分析和优化。
④ 安全分析 (Security Analysis)： 分析日志中的异常访问、攻击行为等，进行安全事件分析和响应。
⑤ 业务分析 (Business Analysis)： 分析日志中的用户行为、业务数据等，进行业务指标统计和分析。
Thrift 日志内容：
⚝ 请求日志 (Request Logs)： 记录每个请求的详细信息，例如：
▮▮▮▮⚝ 请求 ID (Request ID)： 唯一标识请求的 ID，用于追踪请求链路。
▮▮▮▮⚝ 请求时间 (Request Time)： 请求到达服务端的时间。
▮▮▮▮⚝ 客户端 IP (Client IP)： 客户端的 IP 地址。
▮▮▮▮⚝ 请求方法 (Method Name)： Thrift 服务方法名。
▮▮▮▮⚝ 请求参数 (Request Parameters)： 请求的参数。
▮▮▮▮⚝ 响应时间 (Response Time)： 请求处理耗时。
▮▮▮▮⚝ 响应状态 (Response Status)： 请求处理结果 (成功/失败)。
▮▮▮▮⚝ 错误信息 (Error Message)： 如果请求失败，记录错误信息。
⚝ 应用日志 (Application Logs)： 记录服务运行过程中的各种事件和信息，例如：
▮▮▮▮⚝ 启动日志 (Startup Logs)： 服务启动时的日志信息。
▮▮▮▮⚝ 配置加载日志 (Configuration Loading Logs)： 加载配置文件的日志信息。
▮▮▮▮⚝ 业务逻辑日志 (Business Logic Logs)： 业务逻辑执行过程中的日志信息。
▮▮▮▮⚝ 异常日志 (Exception Logs)： 服务运行过程中发生的异常信息，包括异常类型、堆栈信息等。
▮▮▮▮⚝ 调试日志 (Debug Logs)： 用于调试的详细日志信息 (通常在开发和测试环境开启)。
▮▮▮▮⚝ 安全日志 (Security Logs)： 安全相关的日志信息，例如身份验证失败、授权失败等。
⚝ 系统日志 (System Logs)： 操作系统和系统组件的日志，例如：
▮▮▮▮⚝ 操作系统日志 (Operating System Logs)： 例如 Linux 的 /var/log/messages, /var/log/syslog 等。
▮▮▮▮⚝ Thrift 框架日志 (Thrift Framework Logs)： Thrift 框架自身的日志信息 (如果 Thrift 框架有日志输出)。
Thrift 日志级别 (Log Levels)：
⚝ DEBUG： 调试信息，最详细的日志级别，通常用于开发和测试环境。
⚝ INFO： 一般信息，记录服务运行状态、关键事件等。
⚝ WARN： 警告信息，表示可能存在潜在问题，但不影响服务正常运行。
⚝ ERROR： 错误信息，表示服务发生错误，可能影响服务功能。
⚝ FATAL： 致命错误，表示服务发生严重错误，可能导致服务崩溃。
Thrift 日志实现方案：
① 标准输出/标准错误 (Standard Output/Standard Error)： 最简单的日志输出方式，将日志信息输出到标准输出或标准错误流。适用于简单的应用或开发调试。
② 日志文件 (Log Files)： 将日志信息写入到日志文件中。
▮▮▮▮⚝ 优点： 日志持久化存储，方便后续分析。
▮▮▮▮⚝ 缺点： 日志文件管理 (例如切割、压缩、清理) 需要额外处理。
③ 日志库 (Logging Library)： 集成成熟的 日志库 (Logging Library)，例如 log4cplus, spdlog, glog (gflags), Folly Logging 等。
▮▮▮▮⚝ 日志库提供丰富的功能，例如日志级别控制、日志格式化、日志输出目标 (文件、控制台、网络等)、日志切割、异步日志等。
▮▮▮▮⚝ 优点： 功能强大，性能高，易于配置和管理。
▮▮▮▮⚝ 缺点： 需要引入日志库，增加代码依赖。
④ 集中式日志系统 (Centralized Logging System)： 将日志信息集中收集到 集中式日志系统 (Centralized Logging System)，例如 ELK Stack (Elasticsearch, Logstash, Kibana), Splunk, Graylog 等。
▮▮▮▮⚝ 集中式日志系统提供日志收集、存储、搜索、分析、可视化等功能。
▮▮▮▮⚝ 优点： 方便日志管理和分析，适用于复杂的分布式系统。
▮▮▮▮⚝ 缺点： 部署和维护成本较高，需要学习和配置集中式日志系统。
ELK Stack 日志系统示例 (概念性描述)：
- 集成日志库 (例如 spdlog, Folly Logging) 到 Thrift 服务端代码中。
- 配置日志库，将日志输出目标设置为 Logstash 或 Elasticsearch (例如使用 TCP 或 HTTP 协议)。
- 在 Thrift 服务代码中，使用日志库 API 记录日志，例如请求日志、应用日志、异常日志等。
- 部署 Logstash，配置 Logstash 从 Thrift 服务接收日志，并解析日志格式，将日志数据发送到 Elasticsearch。
- 部署 Elasticsearch，用于存储和索引日志数据。
- 部署 Kibana，配置 Kibana 数据源为 Elasticsearch。
- 在 Kibana 中创建日志 Dashboard，搜索、过滤、分析和可视化 Thrift 服务的日志数据。
8.3.3 性能分析与故障排查 (Performance Analysis and Troubleshooting)
利用监控和日志进行性能分析：
⚝ 识别性能瓶颈 (Identify Performance Bottlenecks)： 通过监控数据 (例如延迟、吞吐量、资源利用率)，识别服务的性能瓶颈，例如慢请求、CPU 瓶颈、内存瓶颈、网络瓶颈等。
⚝ 分析慢请求 (Analyze Slow Requests)： 通过监控系统或 APM 系统，追踪慢请求的调用链，定位慢请求的原因，例如数据库查询慢、外部服务调用慢、代码逻辑耗时等。
⚝ 性能优化 (Performance Optimization)： 根据性能分析结果，进行性能优化，例如优化代码逻辑、优化数据库查询、增加缓存、调整线程池大小、升级硬件资源等。
利用监控和日志进行故障排查：
⚝ 快速定位故障 (Rapid Fault Localization)： 当监控系统发出告警时，通过查看监控数据和日志信息，快速定位故障发生的服务和组件。
⚝ 分析错误日志 (Analyze Error Logs)： 查看错误日志，分析错误类型、错误信息、异常堆栈等，定位故障原因。
⚝ 追踪请求链路 (Trace Request Path)： 使用分布式追踪系统，追踪请求在分布式系统中的完整链路，定位请求失败的环节。
⚝ 复现故障场景 (Reproduce Fault Scenarios)： 根据日志信息和监控数据，尝试复现故障场景，以便更深入地分析和解决问题。
最佳实践：
⚝ 监控指标全面 (Comprehensive Monitoring Metrics)： 监控 Thrift 服务的关键指标，包括请求指标、资源指标、JVM 指标 (如果使用 Java)。
⚝ 日志级别合理 (Reasonable Log Levels)： 根据环境和需求设置合理的日志级别，避免日志量过大或过小。
⚝ 日志格式规范 (Standardized Log Format)： 使用结构化日志格式 (例如 JSON)，方便日志解析和分析。
⚝ 日志集中管理 (Centralized Log Management)： 使用集中式日志系统管理和分析日志。
⚝ 监控告警及时 (Timely Monitoring Alerts)： 配置监控告警规则，及时发现和处理异常情况。
⚝ 定期性能分析 (Regular Performance Analysis)： 定期分析监控数据和日志信息，进行性能优化和容量规划。
总结：
监控 (Monitoring) 和 日志 (Logging) 是 Thrift 服务运维的基石。完善的监控和日志系统能够帮助我们实时了解服务状态、快速定位故障、进行性能分析和优化，保障 Thrift 服务的稳定性和可靠性。在实际应用中，需要根据服务的规模和复杂度选择合适的监控和日志方案，并持续优化和完善监控和日志系统。
8.4 Thrift版本管理与兼容性 (Thrift Version Management and Compatibility)
在分布式系统中，版本管理 (Version Management) 和 兼容性 (Compatibility) 是至关重要的问题，尤其是在服务迭代升级过程中。对于基于 Thrift 构建的服务，Thrift IDL (Interface Definition Language) 的版本管理和服务的兼容性设计直接影响到系统的稳定性和可维护性。
本节将深入探讨 Thrift 版本管理和兼容性问题，并提供最佳实践。
8.4.1 Thrift IDL 版本管理 (Thrift IDL Version Management)
Thrift IDL (Interface Definition Language) 定义了 Thrift 服务的接口和数据结构。当服务需要升级或添加新功能时，通常需要修改 Thrift IDL。版本管理 (Version Management) 的目标是有效地管理 Thrift IDL 的不同版本，并确保不同版本的服务和客户端能够协同工作。
版本管理策略：
① 语义化版本控制 (Semantic Versioning)： 采用 语义化版本控制 (Semantic Versioning) 规范 (SemVer) 来管理 Thrift IDL 版本。
▮▮▮▮⚝ 版本号格式： MAJOR.MINOR.PATCH
▮▮▮▮⚝ MAJOR 主版本号： 当进行不兼容的 API 修改时，增加主版本号。
▮▮▮▮⚝ MINOR 次版本号： 当以向后兼容的方式添加功能时，增加次版本号。
▮▮▮▮⚝ PATCH 修订号： 当进行向后兼容的 Bug 修复时，增加修订号。
▮▮▮▮⚝ 例如： 1.0.0, 1.1.0, 2.0.0
② Git 版本控制 (Git Version Control)： 使用 Git 等版本控制系统来管理 Thrift IDL 文件。
▮▮▮▮⚝ 将 Thrift IDL 文件存储在 Git 仓库中，每次修改都提交到 Git 仓库。
▮▮▮▮⚝ 可以使用 Git 分支 (Branch) 和标签 (Tag) 来管理不同版本的 Thrift IDL。
▮▮▮▮⚝ 例如，可以使用 main 分支作为主版本，创建 v1.0, v1.1, v2.0 等标签来标记不同版本。
③ Thrift 命名空间 (Namespace)： 使用 Thrift 命名空间 (Namespace) 来区分不同版本的 Thrift IDL。
▮▮▮▮⚝ 在 Thrift IDL 文件中，使用 namespace 关键字定义命名空间，例如 namespace cpp com.example.service.v1。
▮▮▮▮⚝ 不同版本的 Thrift IDL 可以使用不同的命名空间，例如 com.example.service.v1, com.example.service.v2。
▮▮▮▮⚝ 代码生成时，不同版本的代码会生成在不同的命名空间下，避免命名冲突。
④ Thrift Include 机制 (Thrift Include Mechanism)： 使用 Thrift Include 机制 (Include Mechanism) 来模块化 Thrift IDL，并方便版本管理。
▮▮▮▮⚝ 将 Thrift IDL 拆分为多个文件，例如 common.thrift, user.thrift, order.thrift 等。
▮▮▮▮⚝ 使用 include 关键字在 Thrift IDL 文件中引入其他 Thrift IDL 文件。
▮▮▮▮⚝ 可以对公共的 Thrift IDL 文件 (例如 common.thrift) 进行版本管理，不同版本的服务可以引用不同版本的公共 IDL 文件。
最佳实践：
⚝ 采用语义化版本控制 (Semantic Versioning)： 清晰地标识 Thrift IDL 的版本，方便客户端和服务端识别和兼容。
⚝ 使用 Git 版本控制 (Git Version Control)： 管理 Thrift IDL 文件的版本历史，方便回溯和协作。
⚝ 使用 Thrift 命名空间 (Namespace)： 避免不同版本 IDL 的命名冲突，提高代码可维护性。
⚝ 模块化 Thrift IDL (Modularize Thrift IDL)： 使用 Include 机制将 IDL 拆分为模块，方便版本管理和复用。
⚝ 文档化版本变更 (Document Version Changes)： 清晰地记录每个版本 IDL 的变更内容，方便开发者了解版本差异。
8.4.2 Thrift 服务兼容性 (Thrift Service Compatibility)
兼容性 (Compatibility) 是指不同版本的 Thrift 服务和客户端之间能够正常通信和协同工作的能力。在服务升级过程中，需要尽可能地保持 向后兼容性 (Backward Compatibility) 和 向前兼容性 (Forward Compatibility)。
⚝ 向后兼容性 (Backward Compatibility)： 新版本的服务能够兼容旧版本的客户端。旧版本的客户端可以继续调用新版本的服务，即使新服务添加了新功能或修改了接口。
⚝ 向前兼容性 (Forward Compatibility)： 旧版本的服务能够兼容新版本的客户端。新版本的客户端可以调用旧版本的服务，即使旧服务不理解新客户端发送的新字段或新功能。
兼容性策略：
① 添加字段 (Adding Fields)： 在 Thrift IDL 中添加新的 可选字段 (Optional Fields)。
▮▮▮▮⚝ 新版本的服务可以使用新字段，旧版本的客户端可以忽略新字段。
▮▮▮▮⚝ 向后兼容： 旧版本的客户端可以继续调用新版本的服务。
▮▮▮▮⚝ 向前兼容： 旧版本的服务可以忽略新版本的客户端发送的新字段。
② 添加方法 (Adding Methods)： 在 Thrift IDL 中添加新的服务方法。
▮▮▮▮⚝ 新版本的客户端可以使用新方法，旧版本的客户端可以继续使用旧方法。
▮▮▮▮⚝ 向后兼容： 旧版本的客户端可以继续调用新版本的服务。
▮▮▮▮⚝ 向前兼容： 旧版本的服务不理解新版本的客户端调用的新方法 (会报错，需要客户端处理)。
③ 枚举类型扩展 (Enum Type Extension)： 在 Thrift IDL 中扩展 枚举类型 (Enum Type)，添加新的枚举值。
▮▮▮▮⚝ 新版本的服务可以使用新的枚举值，旧版本的客户端可以忽略新枚举值 (如果客户端没有处理未知枚举值的逻辑，可能会报错)。
▮▮▮▮⚝ 向后兼容： 如果旧版本的客户端能够处理未知枚举值，则可以保持向后兼容。
▮▮▮▮⚝ 向前兼容： 旧版本的服务可以忽略新版本的客户端发送的新枚举值。
④ 结构体类型扩展 (Struct Type Extension)： 在 Thrift IDL 中扩展 结构体类型 (Struct Type)，添加新的可选字段。
▮▮▮▮⚝ 与添加字段类似，新版本的服务可以使用新字段，旧版本的客户端可以忽略新字段。
▮▮▮▮⚝ 向后兼容 和 向前兼容： 与添加字段类似。
⑤ 避免修改字段类型 (Avoid Modifying Field Types)： 尽量避免修改 Thrift IDL 中已有的字段类型。
▮▮▮▮⚝ 修改字段类型可能会导致 不兼容 (Incompatibility)，例如将 i32 修改为 string。
▮▮▮▮⚝ 如果必须修改字段类型，需要谨慎评估兼容性影响，并进行充分的测试和灰度发布。
⑥ 废弃字段或方法 (Deprecating Fields or Methods)： 如果需要废弃 Thrift IDL 中的字段或方法，可以添加 deprecated 注解 (Annotation)。
▮▮▮▮⚝ @deprecated 注解可以标记字段或方法为已废弃，但仍然保留在 IDL 中，以保持向后兼容性。
▮▮▮▮⚝ 新版本的服务和客户端应该避免使用已废弃的字段或方法。
▮▮▮▮⚝ 在未来的版本中，可以移除已废弃的字段或方法 (需要进行主版本升级)。
⑦ 协议和传输层兼容性 (Protocol and Transport Compatibility)： 在服务升级过程中，尽量保持 Thrift 协议 (Protocol) 和 传输层 (Transport) 的兼容性。
▮▮▮▮⚝ 例如，如果旧版本服务使用 Binary Protocol (二进制协议) 和 Buffered Transport (缓冲传输)，新版本服务也应该尽量使用相同的协议和传输层，以保持兼容性。
▮▮▮▮⚝ 如果需要升级协议或传输层，需要评估兼容性影响，并进行充分的测试和灰度发布。
最佳实践：
⚝ 优先保持向后兼容性 (Prioritize Backward Compatibility)： 在服务升级过程中，尽量保持向后兼容性，确保旧版本的客户端可以继续调用新版本的服务。
⚝ 使用可选字段 (Use Optional Fields)： 添加新字段时，尽量使用可选字段，以保持兼容性。
⚝ 避免修改字段类型 (Avoid Modifying Field Types)： 尽量避免修改已有的字段类型，如果必须修改，需要谨慎评估兼容性影响。
⚝ 使用 @deprecated 注解 (Use @deprecated Annotation)： 标记已废弃的字段或方法，方便开发者识别和迁移。
⚝ 充分测试兼容性 (Thoroughly Test Compatibility)： 在服务升级发布前，进行充分的兼容性测试，包括向后兼容性测试和向前兼容性测试。
⚝ 灰度发布 (Gray Release)： 采用 灰度发布 (Gray Release) 策略，逐步将新版本服务发布到生产环境，并监控服务运行情况，及时发现和解决兼容性问题。
⚝ 版本协商机制 (Version Negotiation Mechanism)： 在复杂的场景下，可以考虑实现 版本协商机制 (Version Negotiation Mechanism)，客户端和服务端在建立连接时协商使用的 Thrift IDL 版本和协议版本。
总结：
Thrift 版本管理 (Version Management) 和 兼容性 (Compatibility) 是构建稳定可靠的 Thrift 分布式系统的关键。通过合理的版本管理策略和兼容性设计，可以有效地管理 Thrift IDL 的版本迭代，并确保不同版本的服务和客户端能够平滑升级和协同工作。在实际应用中，需要根据服务的具体情况选择合适的版本管理和兼容性策略，并严格遵循最佳实践，以降低服务升级的风险，提高系统的可维护性和可扩展性。
8.5 Thrift安全：认证与授权 (Thrift Security: Authentication and Authorization)
在构建分布式系统时，安全 (Security) 是至关重要的考虑因素。对于基于 Thrift 构建的服务，需要采取一系列安全措施，保护服务免受未经授权的访问和恶意攻击。认证 (Authentication) 和 授权 (Authorization) 是 Thrift 安全的核心组成部分。
本节将深入探讨 Thrift 安全的 认证 (Authentication) 和 授权 (Authorization) 机制，并提供最佳实践。
8.5.1 认证 (Authentication)：身份验证 (Authentication: Identity Verification)
认证 (Authentication) 是指验证客户端身份的过程，确认客户端是否是其声称的身份。认证的目标是防止 身份冒充 (Identity Spoofing)，确保只有合法的客户端才能访问 Thrift 服务。
常见的认证方式：
① 无认证 (No Authentication)： 不进行任何身份验证，任何人都可以访问服务。适用于公开服务或内部可信环境。不推荐在生产环境中使用。
② 基于用户名/密码认证 (Username/Password Authentication)： 客户端在请求中提供用户名和密码，服务端验证用户名和密码是否正确。
▮▮▮▮⚝ 优点： 简单易用。
▮▮▮▮⚝ 缺点： 安全性较低，密码容易泄露，容易受到 暴力破解 (Brute-Force Attack) 和 重放攻击 (Replay Attack)。不推荐在生产环境中使用明文密码。
③ 基于令牌认证 (Token-Based Authentication)： 客户端使用 令牌 (Token) 进行身份验证。
▮▮▮▮⚝ 流程：
1. 客户端使用用户名和密码或其他凭证向 认证服务器 (Authentication Server) 请求令牌。
2. 认证服务器验证凭证，如果验证通过，颁发令牌 (例如 JWT, JSON Web Token)。
3. 客户端在后续请求中携带令牌 (例如在请求头中)。
4. Thrift 服务端验证令牌的有效性，如果验证通过，则认为客户端已认证。
▮▮▮▮⚝ 优点： 安全性较高，令牌有效期可控，支持 无状态认证 (Stateless Authentication)，适用于 微服务架构 (Microservice Architecture)。
▮▮▮▮⚝ 缺点： 需要额外的认证服务器和令牌管理机制。
④ 基于双向 TLS 认证 (Mutual TLS Authentication)： 使用 双向 TLS (Mutual TLS, mTLS) 进行身份验证。
▮▮▮▮⚝ 流程：
1. 客户端和服务端都配置 TLS 证书 (TLS Certificate)。
2. 在 TLS 握手过程中，客户端和服务端互相验证对方的证书。
3. 只有双方证书验证通过，才能建立 TLS 连接。
▮▮▮▮⚝ 优点： 安全性极高，基于 PKI (Public Key Infrastructure) 体系，可以有效防止中间人攻击和身份冒充。
▮▮▮▮⚝ 缺点： 配置和管理证书较为复杂，性能开销较大。适用于对安全性要求极高的场景。
⑤ 基于 Kerberos 认证 (Kerberos Authentication)： 使用 Kerberos 协议进行身份验证。
▮▮▮▮⚝ Kerberos 是一种网络认证协议，基于 票据 (Ticket) 机制，提供强身份验证和授权。
▮▮▮▮⚝ 优点： 安全性高，成熟可靠，适用于大型企业内部网络环境。
▮▮▮▮⚝ 缺点： 配置和管理复杂，需要部署 Kerberos 服务。
Thrift 中实现认证：
⚝ 自定义传输层 (Custom Transport Layer)： 可以自定义 Thrift 传输层 (Transport)，在传输层中实现认证逻辑。例如，在建立连接时进行 TLS 握手和证书验证，或在请求头中传递令牌。
⚝ Thrift 中间件/拦截器 (Thrift Middleware/Interceptors)： 可以使用 Thrift 中间件 (Middleware) 或 拦截器 (Interceptors) 在服务端实现认证逻辑。例如，拦截请求，从请求头中提取令牌，验证令牌的有效性。
⚝ Thrift 认证框架 (Thrift Authentication Framework)： 一些 Thrift 框架或库可能提供内置的认证框架，例如 Facebook Fizz, Apache Thrift Server 等。
基于令牌认证的 Thrift 中间件示例 (C++，伪代码)：
1
#include "gen-cpp/YourService.h" // Thrift 生成的代码
2
#include <thrift/transport/TServerSocket.h>
3
#include <thrift/transport/TBufferedTransport.h>
4
#include <thrift/protocol/TBinaryProtocol.h>
5
#include <iostream>
6
#include <string>
7
#include <unordered_set>
8
9
using namespace apache::thrift;
10
using namespace apache::thrift::transport;
11
using namespace apache::thrift::protocol;
12
13
// 模拟令牌验证函数 (实际应用中需要调用认证服务或验证 JWT 签名)
14
bool validateToken(const std::string& token) {
15
static const std::unordered_set<std::string> valid_tokens = {"token123", "token456"};
16
return valid_tokens.count(token) > 0;
17
}
18
19
class AuthMiddleware {
20
public:
21
AuthMiddleware(std::shared_ptr<YourServiceIf> next_handler) : next_handler_(next_handler) {}
22
23
int yourMethod(int req) override {
24
// 从请求上下文中获取令牌 (假设令牌在请求头 "Authorization" 中)
25
std::string token = getRequestContextToken(); // 需要根据实际情况实现
26
27
if (validateToken(token)) {
28
std::cout << "Authentication passed for request " << req << std::endl;
29
return next_handler_->yourMethod(req); // 调用下一个处理器
30
} else {
31
std::cerr << "Authentication failed for request " << req << std::endl;
32
throw TException("Authentication failed"); // 抛出认证失败异常
33
}
34
}
35
36
private:
37
std::shared_ptr<YourServiceIf> next_handler_;
38
39
// 获取请求上下文令牌 (需要根据 Thrift 框架和传输层实现)
40
std::string getRequestContextToken() {
41
// ... 从 Thrift 请求上下文中获取令牌，例如从请求头中
42
// ... 示例：假设从请求头 "Authorization" 中获取令牌
43
// ... 这部分代码需要根据具体的 Thrift 框架和传输层实现
44
return "token123"; // 示例：返回一个有效的令牌
45
}
46
};
47
48
class YourServiceHandler : virtual public YourServiceIf {
49
public:
50
int yourMethod(int req) override {
51
std::cout << "Processing request " << req << std::endl;
52
return req * 2;
53
}
54
};
55
56
int main() {
57
int port = 9090;
58
59
std::shared_ptr<YourServiceHandler> handler(new YourServiceHandler());
60
std::shared_ptr<AuthMiddleware> auth_handler(new AuthMiddleware(handler)); // 使用认证中间件包装处理器
61
std::shared_ptr<TProcessor> processor(new YourServiceProcessor(auth_handler));
62
std::shared_ptr<TServerTransport> serverTransport(new TServerSocket(port));
63
std::shared_ptr<TTransportFactory> transportFactory(new TBufferedTransportFactory());
64
std::shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());
65
66
TSimpleServer server(processor, serverTransport, transportFactory, protocolFactory);
67
std::cout << "Starting server on port " << port << std::endl;
68
server.serve();
69
return 0;
70
}
代码解释 (伪代码)：
⚝ AuthMiddleware 类实现了一个认证中间件，包装了核心服务处理器 YourServiceHandler。
⚝ validateToken() 函数模拟令牌验证逻辑 (实际应用中需要替换为真实的令牌验证逻辑)。
⚝ getRequestContextToken() 函数用于从 Thrift 请求上下文中获取令牌 (需要根据具体的 Thrift 框架和传输层实现)。
⚝ 在 yourMethod() 方法中，认证中间件首先验证令牌，如果验证通过，则调用下一个处理器 next_handler_->yourMethod(req)，否则抛出认证失败异常。
实际应用中，需要根据具体的 Thrift 框架和传输层实现请求上下文令牌获取和传递，以及令牌验证逻辑。可以使用 JWT 库 (例如 jwt-cpp) 来验证 JWT 令牌。
8.5.2 授权 (Authorization)：访问控制 (Authorization: Access Control)
授权 (Authorization) 是指在认证通过后，进一步验证客户端是否具有访问特定资源的权限。授权的目标是实现 访问控制 (Access Control)，确保只有授权用户才能访问受保护的资源。
常见的授权模型：
① 基于角色的访问控制 (RBAC, Role-Based Access Control)： 将用户分配到不同的 角色 (Role)，每个角色拥有不同的 权限 (Permission)。授权时，检查用户所属的角色是否具有访问资源的权限。
▮▮▮▮⚝ 优点： 简单易用，易于管理，适用于权限结构相对固定的场景。
▮▮▮▮⚝ 缺点： 角色数量过多时，角色管理可能变得复杂。
② 基于属性的访问控制 (ABAC, Attribute-Based Access Control)： 基于 属性 (Attribute) 来定义访问控制策略。属性可以包括用户属性、资源属性、环境属性等。授权时，根据访问控制策略和属性值进行判断。
▮▮▮▮⚝ 优点： 灵活性高，可以实现细粒度的访问控制，适用于复杂的权限管理场景。
▮▮▮▮⚝ 缺点： 策略管理和评估较为复杂。
③ 基于策略的访问控制 (PBAC, Policy-Based Access Control)： 使用 策略 (Policy) 来定义访问控制规则。策略可以使用各种规则引擎 (例如 OPA, Open Policy Agent) 来评估。
▮▮▮▮⚝ 优点： 策略管理集中化，策略定义灵活，支持复杂的访问控制逻辑。
▮▮▮▮⚝ 缺点： 策略管理和规则引擎部署需要额外成本。
Thrift 中实现授权：
⚝ Thrift 中间件/拦截器 (Thrift Middleware/Interceptors)： 可以使用 Thrift 中间件 (Middleware) 或 拦截器 (Interceptors) 在服务端实现授权逻辑。例如，在认证中间件之后，添加授权中间件，拦截请求，根据用户身份和请求资源，检查用户是否具有访问权限。
⚝ Thrift 授权框架 (Thrift Authorization Framework)： 一些 Thrift 框架或库可能提供内置的授权框架，例如 Facebook Fizz, Apache Thrift Server 等。
基于 RBAC 授权的 Thrift 中间件示例 (C++，伪代码，假设已完成认证)：
1
#include "gen-cpp/YourService.h" // Thrift 生成的代码
2
#include <thrift/transport/TServerSocket.h>
3
#include <thrift/transport/TBufferedTransport.h>
4
#include <thrift/protocol/TBinaryProtocol.h>
5
#include <iostream>
6
#include <string>
7
#include <unordered_map>
8
9
using namespace apache::thrift;
10
using namespace apache::thrift::transport;
11
using namespace apache::thrift::protocol;
12
13
// 模拟角色权限信息 (实际应用中需要从数据库或配置中心加载)
14
std::unordered_map<std::string, std::unordered_set<std::string>> role_permissions = {
15
{"admin", {"yourMethod", "adminMethod"}},
16
{"user", {"yourMethod"}}
17
};
18
19
// 模拟用户角色信息 (实际应用中需要从用户服务或认证信息中获取)
20
std::string getUserRole(const std::string& token) {
21
// ... 根据令牌获取用户角色 (示例：假设令牌 "token123" 对应 "admin" 角色，"token456" 对应 "user" 角色)
22
if (token == "token123") {
23
return "admin";
24
} else if (token == "token456") {
25
return "user";
26
} else {
27
return ""; // 未知角色
28
}
29
}
30
31
class AuthzMiddleware { // Authz: Authorization
32
public:
33
AuthzMiddleware(std::shared_ptr<YourServiceIf> next_handler) : next_handler_(next_handler) {}
34
35
int yourMethod(int req) override {
36
return checkPermission("yourMethod", req);
37
}
38
39
int adminMethod(int req) override {
40
return checkPermission("adminMethod", req);
41
}
42
43
private:
44
std::shared_ptr<YourServiceIf> next_handler_;
45
46
int checkPermission(const std::string& method_name, int req) {
47
// 从请求上下文中获取令牌 (假设令牌已在认证中间件中验证)
48
std::string token = getRequestContextToken(); // 需要根据实际情况实现
49
std::string user_role = getUserRole(token);
50
51
if (user_role.empty()) {
52
std::cerr << "Authorization failed: Unknown role for request " << req << std::endl;
53
throw TException("Authorization failed: Unknown role");
54
}
55
56
if (role_permissions.count(user_role) > 0 && role_permissions[user_role].count(method_name) > 0) {
57
std::cout << "Authorization passed for request " << req << ", method: " << method_name << ", role: " << user_role << std::endl;
58
if (method_name == "yourMethod") {
59
return next_handler_->yourMethod(req);
60
} else if (method_name == "adminMethod") {
61
return next_handler_->adminMethod(req);
62
}
63
} else {
64
std::cerr << "Authorization failed: Role '" << user_role << "' does not have permission to access method '" << method_name << "' for request " << req << std::endl;
65
throw TException("Authorization failed: Insufficient permissions");
66
}
67
return -1; // 不应该执行到这里
68
}
69
70
// 获取请求上下文令牌 (需要根据 Thrift 框架和传输层实现)
71
std::string getRequestContextToken() {
72
// ... 从 Thrift 请求上下文中获取令牌，例如从请求头中
73
// ... 示例：假设从请求头 "Authorization" 中获取令牌
74
// ... 这部分代码需要根据具体的 Thrift 框架和传输层实现
75
return "token123"; // 示例：返回一个有效的令牌
76
}
77
};
78
79
class YourServiceHandler : virtual public YourServiceIf {
80
public:
81
int yourMethod(int req) override {
82
std::cout << "Processing yourMethod request " << req << std::endl;
83
return req * 2;
84
}
85
86
int adminMethod(int req) override {
87
std::cout << "Processing adminMethod request " << req << std::endl;
88
return req * 3;
89
}
90
};
91
92
93
int main() {
94
int port = 9090;
95
96
std::shared_ptr<YourServiceHandler> handler(new YourServiceHandler());
97
std::shared_ptr<AuthzMiddleware> authz_handler(new AuthzMiddleware(handler)); // 使用授权中间件包装处理器
98
std::shared_ptr<TProcessor> processor(new YourServiceProcessor(authz_handler));
99
std::shared_ptr<TServerTransport> serverTransport(new TServerSocket(port));
100
std::shared_ptr<TTransportFactory> transportFactory(new TBufferedTransportFactory());
101
std::shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());
102
103
TSimpleServer server(processor, serverTransport, transportFactory, protocolFactory);
104
std::cout << "Starting server on port " << port << std::endl;
105
server.serve();
106
return 0;
107
}
代码解释 (伪代码)：
⚝ AuthzMiddleware 类实现了一个基于 RBAC 的授权中间件，包装了核心服务处理器 YourServiceHandler。
⚝ role_permissions 模拟角色权限信息 (实际应用中需要从数据库或配置中心加载)。
⚝ getUserRole() 函数模拟根据令牌获取用户角色信息 (实际应用中需要从用户服务或认证信息中获取)。
⚝ checkPermission() 方法检查用户角色是否具有访问特定方法的权限。
⚝ 在 yourMethod() 和 adminMethod() 方法中，授权中间件调用 checkPermission() 进行授权检查，如果授权通过，则调用下一个处理器，否则抛出授权失败异常。
实际应用中，需要根据具体的业务需求和安全策略，选择合适的授权模型和实现方式。可以使用 OPA (Open Policy Agent) 等策略引擎来实现更复杂的 ABAC 或 PBAC 授权模型。
Thrift 安全最佳实践：
⚝ 选择合适的认证方式 (Choose Appropriate Authentication Method)： 根据安全需求和场景选择合适的认证方式，例如令牌认证、双向 TLS 认证等。避免使用无认证或基于明文密码的认证方式。
⚝ 实施授权机制 (Implement Authorization Mechanism)： 实施授权机制，控制用户对资源的访问权限，例如 RBAC, ABAC, PBAC 等。
⚝ 使用 TLS 加密传输 (Use TLS for Transport Encryption)： 使用 TLS 加密 Thrift 服务的传输通道，防止数据在传输过程中被窃听或篡改。
⚝ 安全审计日志 (Security Audit Logs)： 记录安全相关的日志，例如认证失败、授权失败、异常访问等，用于安全审计和分析。
⚝ 定期安全漏洞扫描 (Regular Security Vulnerability Scanning)： 定期对 Thrift 服务进行安全漏洞扫描，及时修复安全漏洞。
⚝ 遵循安全开发最佳实践 (Follow Secure Development Best Practices)： 在 Thrift 服务开发过程中，遵循安全开发最佳实践，例如输入验证、防止 SQL 注入、防止跨站脚本攻击 (XSS) 等 (虽然 Thrift 主要用于 RPC，但仍然需要注意安全问题)。
⚝ 最小权限原则 (Principle of Least Privilege)： 在授权配置中，遵循 最小权限原则 (Principle of Least Privilege)，只授予用户完成任务所需的最小权限。
总结：
认证 (Authentication) 和 授权 (Authorization) 是 Thrift 安全的关键组成部分。通过合理的认证和授权机制，可以有效地保护 Thrift 服务免受未经授权的访问和恶意攻击。在实际应用中，需要根据服务的安全需求和场景选择合适的认证和授权方式，并严格遵循安全最佳实践，构建安全可靠的 Thrift 分布式系统。
END_OF_CHAPTER
9. chapter 9： Folly高级应用与技巧 (Advanced Folly Applications and Techniques)
9.1 配置管理：使用Folly Options与Flags (Configuration Management: Using Folly Options and Flags)
在大型软件项目中，配置管理（Configuration Management）是至关重要的环节。有效的配置管理能够帮助我们灵活地调整应用程序的行为，而无需重新编译代码。Folly 提供了 Options 和 Flags 机制，用于优雅地处理应用程序的配置需求。本节将深入探讨 Folly 的 Options 和 Flags，并展示如何在实际项目中使用它们进行配置管理。
9.1.1 Folly Options：结构化配置的基石 (Folly Options: Cornerstone of Structured Configuration)
Options 是 Folly 提供的一种结构化的配置管理方式，它允许你定义一组选项，并在应用程序启动时通过命令行、配置文件或其他方式进行设置。Options 的核心优势在于其类型安全和结构化特性，使得配置管理更加清晰和可靠。
① Options 的定义
使用 Folly Options，你需要首先定义一个 Options 类，该类继承自 folly::OptionsBase。在 Options 类中，你可以使用宏来声明各种类型的选项，例如 DEFINE_bool、DEFINE_int、DEFINE_string 等。
1
#include <folly/Options.h>
2
#include <iostream>
3
4
FOLLY_DECLARE_string(server_address); // 声明，在其他地方定义
5
FOLLY_DECLARE_int(server_port); // 声明，在其他地方定义
6
7
namespace my_app {
8
9
class MyAppOptions : public folly::OptionsBase {
10
public:
11
// 定义布尔类型选项
12
DEFINE_bool(verbose, false, "Enable verbose logging");
13
14
// 定义整型选项
15
DEFINE_int(threads, 4, "Number of threads to use");
16
17
// 定义字符串类型选项，使用 FOLLY_DECLARE_string 声明的全局变量
18
DEFINE_string(address, FOLLY_FLAGS(server_address), "Server address to connect to");
19
20
// 定义带验证器的选项
21
DEFINE_int_validate(port, FOLLY_FLAGS(server_port), 8080, "Server port number", [](int port) {
22
if (port <= 0 || port > 65535) {
23
throw std::runtime_error("Invalid port number");
24
}
25
});
26
27
// 获取选项值的方法
28
bool isVerbose() const { return FLAGS_verbose; }
29
int getThreads() const { return FLAGS_threads; }
30
std::string getServerAddress() const { return FLAGS_address; }
31
int getServerPort() const { return FLAGS_port; }
32
};
33
34
} // namespace my_app
在上面的例子中：
⚝ DEFINE_bool(verbose, false, "Enable verbose logging") 定义了一个名为 verbose 的布尔类型选项，默认值为 false，描述为 "Enable verbose logging"。
⚝ DEFINE_int(threads, 4, "Number of threads to use") 定义了一个名为 threads 的整型选项，默认值为 4，描述为 "Number of threads to use"。
⚝ DEFINE_string(address, FOLLY_FLAGS(server_address), "Server address to connect to") 定义了一个字符串类型选项 address，其默认值使用了 FOLLY_FLAGS(server_address)，这意味着它会使用全局 Flag server_address 的值作为默认值。
⚝ DEFINE_int_validate 定义了一个带验证器的整型选项 port，默认值为 8080，并提供了一个 Lambda 函数作为验证器，确保端口号在有效范围内。
② Options 的使用
在 main 函数中，你可以创建 MyAppOptions 对象，并使用 parse 方法解析命令行参数。解析后，你可以通过 FLAGS_ 前缀访问选项的值。
1
#include <folly/init/Init.h>
2
#include "MyAppOptions.h" // 假设 Options 定义在 MyAppOptions.h 中
3
4
// 定义全局 Flag，用于 Options 的默认值
5
FOLLY_DEFINE_string(server_address, "localhost", "Default server address");
6
FOLLY_DEFINE_int(server_port, 8080, "Default server port");
7
8
int main(int argc, char** argv) {
9
folly::init(&argc, &argv); // 初始化 Folly，解析命令行参数
10
11
my_app::MyAppOptions options;
12
try {
13
options.parseCommandLineFlags(); // 解析命令行参数
14
} catch (const std::exception& e) {
15
std::cerr << "Error parsing options: " << e.what() << std::endl;
16
return 1;
17
}
18
19
if (options.isVerbose()) {
20
std::cout << "Verbose logging enabled." << std::endl;
21
}
22
std::cout << "Using " << options.getThreads() << " threads." << std::endl;
23
std::cout << "Connecting to server: " << options.getServerAddress() << ":" << options.getServerPort() << std::endl;
24
25
// ... 应用程序逻辑 ...
26
27
return 0;
28
}
编译并运行上述代码，你可以通过命令行参数来修改选项的值：
1
./my_app --verbose --threads=8 --address=192.168.1.100 --port=9000
这将设置 verbose 为 true，threads 为 8，address 为 192.168.1.100，port 为 9000。
③ Options 的优势
⚝ 类型安全：Options 强制选项的类型，避免了因类型错误导致的配置问题。
⚝ 结构化：Options 将配置组织成类，使得配置管理更加结构化和模块化。
⚝ 验证：Options 支持选项验证，可以在解析配置时检查选项值的有效性。
⚝ 描述信息：每个选项都可以附带描述信息，方便用户理解选项的用途。
9.1.2 Folly Flags：全局配置的便捷方式 (Folly Flags: Convenient Way for Global Configuration)
Flags 是 Folly 提供的另一种配置管理方式，它更侧重于全局配置。Flags 允许你在代码中定义全局变量，并通过命令行参数或配置文件来修改这些全局变量的值。Flags 的优点是使用简单便捷，适用于简单的配置场景。
① Flags 的定义
使用 Flags，你需要使用 FOLLY_DEFINE_ 宏来定义全局 Flag 变量。
1
#include <folly/Flags.h>
2
3
// 定义布尔类型 Flag
4
FOLLY_DEFINE_bool(enable_feature_x, false, "Enable feature X");
5
6
// 定义整型 Flag
7
FOLLY_DEFINE_int(max_connections, 100, "Maximum number of connections");
8
9
// 定义字符串类型 Flag
10
FOLLY_DEFINE_string(log_dir, "/var/log/myapp", "Directory for log files");
11
12
// 定义 double 类型 Flag
13
FOLLY_DEFINE_double(sample_rate, 0.5, "Sampling rate for metrics");
在上面的例子中，我们定义了不同类型的 Flag，并为每个 Flag 提供了默认值和描述信息。
② Flags 的使用
在代码中，你可以直接使用 FLAGS_ 前缀访问 Flag 变量的值。在 main 函数中，你需要调用 folly::init 来解析命令行参数。
1
#include <folly/init/Init.h>
2
#include <folly/Flags.h>
3
#include <iostream>
4
5
// 定义 Flag (假设定义在单独的 .h 文件或本文件顶部)
6
FOLLY_DEFINE_bool(enable_feature_x, false, "Enable feature X");
7
FOLLY_DEFINE_int(max_connections, 100, "Maximum number of connections");
8
9
int main(int argc, char** argv) {
10
folly::init(&argc, &argv); // 初始化 Folly，解析命令行参数
11
12
if (FLAGS_enable_feature_x) {
13
std::cout << "Feature X is enabled." << std::endl;
14
} else {
15
std::cout << "Feature X is disabled." << std::endl;
16
}
17
std::cout << "Maximum connections: " << FLAGS_max_connections << std::endl;
18
19
// ... 应用程序逻辑 ...
20
21
return 0;
22
}
编译并运行上述代码，你可以通过命令行参数来修改 Flag 的值：
1
./my_app --enable_feature_x --max_connections=200 --log_dir=/tmp/logs
这将设置 enable_feature_x 为 true，max_connections 为 200，log_dir 为 /tmp/logs。
③ Flags 的优势
⚝ 简单易用：Flags 的定义和使用都非常简单，无需额外的类定义。
⚝ 全局访问：Flags 是全局变量，可以在代码的任何地方直接访问。
⚝ 快速配置：适用于简单的配置场景，快速修改应用程序的行为。
9.1.3 Options 与 Flags 的选择 (Choosing Between Options and Flags)
Options 和 Flags 都是 Folly 提供的配置管理工具，它们各有优缺点，适用于不同的场景。
⚝ Options 适用于需要结构化配置、类型安全和验证的场景。当你的应用程序有大量的配置项，并且需要对配置进行分组管理和验证时，Options 是更好的选择。例如，复杂的服务器应用程序，需要管理数据库连接、网络参数、线程池大小等多个配置项，可以使用 Options 来组织这些配置。
⚝ Flags 适用于简单的全局配置场景，例如功能开关、日志级别、默认端口号等。当你的应用程序只需要少量全局配置项，并且对配置的结构化和验证要求不高时，Flags 更加方便快捷。例如，一个简单的命令行工具，只需要几个配置参数，可以使用 Flags 来快速实现配置管理。
在实际项目中，你可以根据项目的复杂程度和配置需求，选择合适的配置管理方式。对于大型项目，建议使用 Options 来管理主要的配置，并结合 Flags 来处理一些简单的全局配置。
9.1.4 高级配置技巧 (Advanced Configuration Techniques)
① 配置文件加载
除了命令行参数，Options 和 Flags 也支持从配置文件加载配置。Folly 提供了 folly::parseConfigFile 函数，可以解析 INI 格式的配置文件，并将配置值应用到 Options 或 Flags。
1
#include <folly/Options.h>
2
#include <folly/init/Init.h>
3
#include <folly/config/Config.h>
4
#include <iostream>
5
6
FOLLY_DEFINE_string(config_file, "myapp.conf", "Path to configuration file");
7
FOLLY_DEFINE_int(server_port, 8080, "Default server port");
8
9
int main(int argc, char** argv) {
10
folly::init(&argc, &argv);
11
12
// 解析配置文件
13
try {
14
folly::parseConfigFile(FLAGS_config_file);
15
} catch (const std::exception& e) {
16
std::cerr << "Error parsing config file: " << e.what() << std::endl;
17
// 可以选择继续运行，使用默认值或命令行参数
18
}
19
20
// 解析命令行参数，命令行参数会覆盖配置文件中的值
21
folly::parseCommandLineFlags(&argc, &argv);
22
23
std::cout << "Server port: " << FLAGS_server_port << std::endl;
24
25
// ... 应用程序逻辑 ...
26
27
return 0;
28
}
配置文件 myapp.conf 示例：
1
server_port=9000
2
enable_feature_x=true
② 动态配置更新
在某些场景下，你可能需要在应用程序运行时动态更新配置。Folly 的 Flags 提供了 folly::updateFlagValue 函数，可以动态修改 Flag 的值。但是，动态配置更新需要谨慎使用，并确保线程安全。
1
#include <folly/Flags.h>
2
#include <folly/init/Init.h>
3
#include <iostream>
4
#include <thread>
5
#include <chrono>
6
7
FOLLY_DEFINE_int(dynamic_value, 0, "Dynamic value");
8
9
void update_flag() {
10
std::this_thread::sleep_for(std::chrono::seconds(5));
11
folly::updateFlagValue("dynamic_value", 100); // 动态更新 Flag 值
12
std::cout << "Flag 'dynamic_value' updated to: " << FLAGS_dynamic_value << std::endl;
13
}
14
15
int main(int argc, char** argv) {
16
folly::init(&argc, &argv);
17
18
std::thread updater_thread(update_flag);
19
20
for (int i = 0; i < 10; ++i) {
21
std::cout << "Current dynamic_value: " << FLAGS_dynamic_value << std::endl;
22
std::this_thread::sleep_for(std::chrono::seconds(1));
23
}
24
25
updater_thread.join();
26
27
return 0;
28
}
③ 环境变量集成
你可以结合环境变量来扩展配置方式。例如，在 Options 或 Flags 的默认值中，可以使用 getenv 函数获取环境变量的值。
1
#include <folly/Flags.h>
2
#include <cstdlib> // for getenv
3
4
FOLLY_DEFINE_string(api_key, getenv("API_KEY") ? getenv("API_KEY") : "", "API key for authentication");
这样，如果设置了环境变量 API_KEY，则 api_key Flag 的默认值将使用环境变量的值，否则使用空字符串。
通过灵活运用 Folly Options 和 Flags，结合配置文件、动态更新和环境变量等高级技巧，你可以构建出强大而灵活的配置管理系统，从而更好地管理和维护你的 C++ 应用程序。
9.2 日志系统：Folly Logging详解 (Logging System: Folly Logging Deep Dive)
日志（Logging）是软件开发中不可或缺的一部分。一个完善的日志系统能够帮助开发者追踪程序运行状态、诊断错误、进行性能分析和安全审计。Folly 提供了强大且灵活的日志系统 folly::logging，本节将深入解析 Folly Logging 的各个方面，帮助你构建高效可靠的日志系统。
9.2.1 Folly Logging 架构 (Folly Logging Architecture)
Folly Logging 采用了分层架构，主要由以下几个核心组件构成：
① Logger (日志器)：Logger 是日志系统的入口点。开发者通过 Logger 对象记录日志消息。每个 Logger 都有一个名称，用于区分不同的日志来源。你可以通过 folly::Logger::get(name) 获取指定名称的 Logger 实例。
② Log Message (日志消息)：Log Message 封装了要记录的日志内容，包括日志级别、时间戳、日志消息、文件名、行号等信息。Log Message 对象会被传递给 Handler 进行处理。
③ Handler (处理器)：Handler 负责处理 Log Message。Handler 可以将日志消息输出到不同的目标，例如控制台、文件、网络等。Folly 提供了多种内置的 Handler，例如 StreamHandler（输出到流）、FileHandler（输出到文件）、AsyncFileHandler（异步输出到文件）等。你也可以自定义 Handler 来满足特定的需求。
④ Formatter (格式化器)：Formatter 负责将 Log Message 格式化成字符串。Folly 提供了多种内置的 Formatter，例如 SimpleFormatter、JSONFormatter 等。你可以自定义 Formatter 来定义日志消息的输出格式。
⑤ Category (类别)：Category 用于对日志消息进行分类。你可以为每个 Logger 分配一个或多个 Category。Category 可以用于日志过滤和路由。
⑥ Filter (过滤器)：Filter 用于过滤日志消息。你可以根据日志级别、Category、日志消息内容等条件来过滤日志消息。Filter 可以应用于 Logger 或 Handler。
⑦ Sinks (接收器)：Sink 是 Handler 的底层实现，负责实际的日志输出操作。例如，FileSink 负责将日志写入文件，ConsoleSink 负责将日志输出到控制台。
这些组件协同工作，构成了 Folly Logging 灵活且强大的日志系统。
9.2.2 基本日志记录 (Basic Logging)
使用 Folly Logging 非常简单。首先，你需要获取一个 Logger 实例，然后使用不同的日志级别宏来记录日志消息。
① 获取 Logger 实例
1
#include <folly/logging/Logger.h>
2
3
// 获取名为 "my_logger" 的 Logger 实例
4
folly::Logger& logger = folly::Logger::get("my_logger");
② 日志级别宏
Folly Logging 提供了以下日志级别宏：
⚝ VLOG(verbosity_level)：详细日志，用于记录详细的调试信息。verbosity_level 是一个整数，数值越小，日志级别越高。
⚝ DLOG(level)：调试日志，用于记录调试信息。level 是一个 folly::LogLevel 枚举值，例如 folly::LogLevel::DBG、folly::LogLevel::INFO 等。
⚝ LOG(level)：通用日志，用于记录一般信息、警告和错误。level 是一个 folly::LogLevel 枚举值，例如 folly::LogLevel::INFO、folly::LogLevel::WARN、folly::LogLevel::ERR、folly::LogLevel::CRITICAL。
⚝ PLOG(level)：系统调用错误日志，用于记录系统调用错误信息，会自动包含 errno 的错误描述。
⚝ CHECK(condition) / CHECK_EQ(val1, val2) / ...：断言日志，用于检查程序状态，如果条件不满足，则记录错误日志并终止程序。
③ 日志记录示例
1
#include <folly/logging/Logger.h>
2
#include <folly/init/Init.h>
3
4
int main(int argc, char** argv) {
5
folly::init(&argc, &argv);
6
7
folly::Logger& logger = folly::Logger::get("my_logger");
8
9
VLOG(5) << "This is a very detailed debug message."; // Verbosity level 5
10
DLOG(INFO) << "This is an informational message.";
11
LOG(WARN) << "This is a warning message.";
12
LOG(ERR) << "This is an error message.";
13
PLOG(ERR) << "System call failed"; // 自动包含 errno 信息
14
CHECK(1 + 1 == 2) << "Assertion failed!"; // 如果条件不满足，会记录错误并终止程序
15
16
return 0;
17
}
默认情况下，Folly Logging 会将 LOG(INFO) 及以上级别的日志输出到标准错误输出（stderr）。你可以通过配置 Handler 和 Filter 来修改日志输出行为。
9.2.3 配置 Handler 和 Formatter (Configuring Handlers and Formatters)
Folly Logging 提供了灵活的配置方式，你可以通过代码或配置文件来配置 Handler、Formatter 和 Filter。
① 代码配置
你可以通过 folly::LoggerRegistry 来配置全局的 Handler 和 Formatter。
1
#include <folly/logging/Logger.h>
2
#include <folly/logging/handler/StreamHandler.h>
3
#include <folly/logging/formatter/SimpleFormatter.h>
4
#include <folly/init/Init.h>
5
6
int main(int argc, char** argv) {
7
folly::init(&argc, &argv);
8
9
// 创建 StreamHandler，输出到标准输出 (stdout)
10
auto stdoutHandler = std::make_shared<folly::StreamHandler>(&std::cout);
11
// 设置 Formatter
12
stdoutHandler->setFormatter(std::make_shared<folly::SimpleFormatter>());
13
// 注册 Handler 到 root logger
14
folly::LoggerRegistry::get().rootLogger().addHandler(stdoutHandler);
15
16
folly::Logger& logger = folly::Logger::get("my_logger");
17
LOG(INFO) << "This message will be output to stdout.";
18
19
return 0;
20
}
上面的代码创建了一个 StreamHandler，将日志输出到标准输出，并使用 SimpleFormatter 进行格式化。然后将该 Handler 添加到 root logger，这样所有的 logger 都会使用这个 handler。
② 配置文件配置
Folly Logging 支持通过配置文件进行配置。你可以创建一个 YAML 或 JSON 格式的配置文件，并在程序启动时加载该配置文件。
YAML 配置文件 logging_config.yaml 示例：
1
handlers:
2
console:
3
class: folly.logging.handler.StreamHandler
4
stream: stdout
5
formatter: simple
6
7
formatters:
8
simple:
9
class: folly.logging.formatter.SimpleFormatter
10
11
root:
12
handlers: [console]
13
level: INFO
加载配置文件：
1
#include <folly/logging/Logger.h>
2
#include <folly/logging/config/Config.h>
3
#include <folly/init/Init.h>
4
5
int main(int argc, char** argv) {
6
folly::init(&argc, &argv);
7
8
// 加载配置文件
9
folly::logging::config::configure("logging_config.yaml");
10
11
folly::Logger& logger = folly::Logger::get("my_logger");
12
LOG(INFO) << "This message will be output according to config file.";
13
14
return 0;
15
}
配置文件方式更加灵活，可以在不修改代码的情况下调整日志配置。
9.2.4 高级日志特性 (Advanced Logging Features)
① 异步日志 (Asynchronous Logging)
对于高性能应用，同步日志输出可能会成为性能瓶颈。Folly 提供了 AsyncFileHandler 和 AsyncWriter，可以将日志输出操作异步化，从而提高性能。
1
#include <folly/logging/Logger.h>
2
#include <folly/logging/handler/AsyncFileHandler.h>
3
#include <folly/logging/formatter/SimpleFormatter.h>
4
#include <folly/init/Init.h>
5
6
int main(int argc, char** argv) {
7
folly::init(&argc, &argv);
8
9
// 创建 AsyncFileHandler，异步输出到文件
10
auto asyncFileHandler = std::make_shared<folly::AsyncFileHandler>("myapp.log");
11
// 设置 Formatter
12
asyncFileHandler->setFormatter(std::make_shared<folly::SimpleFormatter>());
13
// 注册 Handler 到 root logger
14
folly::LoggerRegistry::get().rootLogger().addHandler(asyncFileHandler);
15
16
folly::Logger& logger = folly::Logger::get("my_logger");
17
LOG(INFO) << "This message will be asynchronously written to file.";
18
19
return 0;
20
}
② 日志过滤 (Log Filtering)
你可以使用 Filter 来过滤日志消息，只记录特定级别的日志或特定来源的日志。
1
#include <folly/logging/Logger.h>
2
#include <folly/logging/handler/StreamHandler.h>
3
#include <folly/logging/formatter/SimpleFormatter.h>
4
#include <folly/logging/filter/LevelFilter.h>
5
#include <folly/init/Init.h>
6
7
int main(int argc, char** argv) {
8
folly::init(&argc, &argv);
9
10
// 创建 StreamHandler
11
auto stdoutHandler = std::make_shared<folly::StreamHandler>(&std::cout);
12
stdoutHandler->setFormatter(std::make_shared<folly::SimpleFormatter>());
13
14
// 创建 LevelFilter，只记录 WARN 及以上级别的日志
15
auto levelFilter = std::make_shared<folly::LevelFilter>(folly::LogLevel::WARN);
16
stdoutHandler->addFilter(levelFilter); // 将 Filter 添加到 Handler
17
18
// 注册 Handler 到 root logger
19
folly::LoggerRegistry::get().rootLogger().addHandler(stdoutHandler);
20
21
folly::Logger& logger = folly::Logger::get("my_logger");
22
LOG(INFO) << "This INFO message will be filtered out.";
23
LOG(WARN) << "This WARN message will be logged.";
24
25
return 0;
26
}
③ 自定义 Handler 和 Formatter (Custom Handlers and Formatters)
你可以根据需要自定义 Handler 和 Formatter。例如，你可以自定义一个 Handler 将日志发送到远程服务器，或者自定义一个 Formatter 输出特定格式的日志消息。
自定义 Handler 示例：
1
#include <folly/logging/handler/Handler.h>
2
#include <folly/logging/LogMessage.h>
3
#include <iostream>
4
5
namespace my_app {
6
7
class MyCustomHandler : public folly::Handler {
8
public:
9
void write(const folly::LogMessage& message) override {
10
std::cout << "[Custom Handler] " << message.message() << std::endl;
11
}
12
};
13
14
} // namespace my_app
使用自定义 Handler：
1
#include <folly/logging/Logger.h>
2
#include "MyCustomHandler.h" // 假设自定义 Handler 定义在 MyCustomHandler.h 中
3
#include <folly/init/Init.h>
4
5
int main(int argc, char** argv) {
6
folly::init(&argc, &argv);
7
8
// 创建自定义 Handler
9
auto customHandler = std::make_shared<my_app::MyCustomHandler>();
10
// 注册 Handler 到 root logger
11
folly::LoggerRegistry::get().rootLogger().addHandler(customHandler);
12
13
folly::Logger& logger = folly::Logger::get("my_logger");
14
LOG(INFO) << "This message will be handled by custom handler.";
15
16
return 0;
17
}
Folly Logging 提供了丰富的特性和灵活的配置选项，可以满足各种复杂的日志需求。通过深入理解和合理使用 Folly Logging，你可以构建出高效、可靠且易于管理的日志系统，为你的 C++ 应用程序提供强大的支持。
9.3 性能分析与调优：使用Folly Benchmark与Profiling工具 (Performance Analysis and Tuning: Using Folly Benchmark and Profiling Tools)
性能分析（Performance Analysis）和调优（Performance Tuning）是软件开发生命周期中至关重要的环节。对于高性能 C++ 应用，精确的性能测量和瓶颈识别是优化性能的关键。Folly 提供了 Benchmark 工具用于微基准测试，并可以与各种 Profiling 工具集成，帮助开发者进行全面的性能分析和调优。
9.3.1 Folly Benchmark：微基准测试利器 (Folly Benchmark: Micro-benchmarking Tool)
Folly Benchmark 是一个轻量级、易于使用的微基准测试框架，用于测量 C++ 代码片段的执行性能。它可以帮助你精确地评估代码的性能，并比较不同实现方案的效率。
① Benchmark 的基本使用
使用 Folly Benchmark，你需要定义一个或多个 benchmark 函数，并使用 BENCHMARK 宏进行注册。
1
#include <folly/Benchmark.h>
2
3
BENCHMARK(StringCreation) {
4
std::string s = "hello world";
5
}
6
7
BENCHMARK(VectorPushBack) {
8
std::vector<int> v;
9
for (int i = 0; i < 1000; ++i) {
10
v.push_back(i);
11
}
12
}
13
14
int main() {
15
folly::runBenchmarks();
16
return 0;
17
}
编译并运行上述代码，Folly Benchmark 会自动运行注册的 benchmark 函数，并输出性能测试结果。
1
./benchmark_example
2
==================== Benchmark Results ====================
3
StringCreation: 10000000 loops, 100.000 ns/loop
4
VectorPushBack: 1000000 loops, 1000.000 ns/loop
5
===========================================================
结果显示了每个 benchmark 函数的循环次数和每次循环的平均执行时间（纳秒/循环）。
② Benchmark 参数化
你可以使用 BENCHMARK_PARAM 宏来定义参数化的 benchmark 函数，以便测试不同参数下的性能。
1
#include <folly/Benchmark.h>
2
3
BENCHMARK_PARAM(StringCopy, size) {
4
std::string src(size, 'a');
5
std::string dst;
6
dst = src; // 字符串拷贝
7
}
8
9
int main() {
10
folly::runBenchmarks();
11
return 0;
12
}
13
14
// 注册参数
15
static std::vector<int> sizes = {10, 100, 1000, 10000};
16
BENCHMARK_DRAW_PARAM(StringCopy, sizes);
上面的代码定义了一个 StringCopy benchmark 函数，并使用 BENCHMARK_PARAM 宏接受一个 size 参数。BENCHMARK_DRAW_PARAM 宏用于注册参数列表，Folly Benchmark 会自动为每个参数值运行 benchmark 函数。
③ Benchmark 组 (Benchmark Groups)
你可以将相关的 benchmark 函数组织成 benchmark 组，方便管理和运行。
1
#include <folly/Benchmark.h>
2
3
// Benchmark 组 "string_ops"
4
namespace string_ops {
5
6
BENCHMARK(StringCreation) {
7
std::string s = "hello world";
8
}
9
10
BENCHMARK_PARAM(StringCopy, size) {
11
std::string src(size, 'a');
12
std::string dst;
13
dst = src;
14
}
15
BENCHMARK_DRAW_PARAM(StringCopy, sizes); // 使用之前的 sizes 参数列表
16
17
} // namespace string_ops
18
19
int main() {
20
folly::runBenchmarks();
21
return 0;
22
}
你可以使用 --bm_regex 命令行参数来运行特定的 benchmark 组或 benchmark 函数。例如，--bm_regex=string_ops 运行 string_ops 组的所有 benchmark，--bm_regex=StringCreation 只运行 StringCreation benchmark。
④ Benchmark 进阶技巧
⚝ Setup 和 Teardown：你可以使用 BENCHMARK_SETUP 和 BENCHMARK_TEARDOWN 宏来定义 benchmark 函数的 setup 和 teardown 代码，用于初始化和清理测试环境。
⚝ 计时器控制：Folly Benchmark 允许你自定义计时器，例如使用 CPU 时钟周期或硬件性能计数器进行计时。
⚝ 多线程 Benchmark：你可以创建多线程 benchmark，测试代码在多线程环境下的性能。
⚝ 输出格式：Folly Benchmark 支持多种输出格式，例如 JSON、CSV 等，方便数据分析和可视化。
9.3.2 Profiling 工具集成 (Profiling Tools Integration)
Folly Benchmark 主要用于微基准测试，评估代码片段的性能。对于更全面的性能分析，你需要结合 Profiling 工具，例如 gprof、perf、火焰图（Flame Graph）等。
① gprof 集成
gprof 是一个常用的性能分析工具，可以分析程序的函数调用关系和执行时间。你可以使用 -pg 编译选项编译程序，并使用 gprof 工具进行 profiling。
编译 benchmark 程序：
1
g++ -pg benchmark_example.cpp -o benchmark_example
运行 benchmark 程序并生成 gprof 数据：
1
./benchmark_example
2
gprof benchmark_example gmon.out > profile.txt
分析 profile.txt 文件，可以查看函数调用图和性能瓶颈。
② perf 集成
perf 是 Linux 系统自带的性能分析工具，功能强大，可以进行 CPU profiling、内存 profiling、系统调用 tracing 等。
使用 perf 进行 CPU profiling：
1
perf record ./benchmark_example
2
perf report
perf report 命令会显示性能报告，包括热点函数和指令。
③ 火焰图 (Flame Graph)
火焰图是一种直观的可视化性能分析工具，可以清晰地展示程序的函数调用栈和 CPU 占用情况。你可以结合 perf 和火焰图生成火焰图。
生成火焰图步骤：
- 使用 perf record 收集性能数据：
1
perf record -F 99 -g -p $(pidof benchmark_example) sleep 30 # 采样 30 秒
- 使用 perf script 生成 perf script 输出：
1
perf script > perf.data
- 使用火焰图工具生成火焰图 (需要安装火焰图工具，例如 Brendan Gregg 的 FlameGraph)：
1
./FlameGraph/stackcollapse-perf.pl perf.data | ./FlameGraph/flamegraph.pl > flamegraph.svg
打开 flamegraph.svg 文件，即可查看火焰图。火焰图的 X 轴表示 CPU 时间，Y 轴表示函数调用栈。火焰越高，表示该函数及其调用链占用的 CPU 时间越多，可能是性能瓶颈。
9.3.3 性能调优策略 (Performance Tuning Strategies)
通过 Folly Benchmark 和 Profiling 工具，你可以识别出代码的性能瓶颈。接下来，你需要根据瓶颈类型采取相应的调优策略。
① 算法优化
检查算法的时间复杂度，选择更高效的算法。例如，将 \(O(n^2)\) 的算法优化为 \(O(n \log n)\) 或 \(O(n)\) 的算法。
② 数据结构优化
选择合适的数据结构，提高数据访问和操作效率。例如，使用 std::unordered_map 替代 std::map，使用 folly::FBVector 替代 std::vector 在某些场景下可以获得更好的性能。
③ 代码优化
⚝ 减少内存分配：频繁的内存分配和释放会降低性能。可以使用对象池、内存池等技术减少内存分配次数。Folly 提供了 folly::SimpleObjectPool 和 folly::LifoSem 等工具用于对象池和内存池管理。
⚝ 减少拷贝：避免不必要的对象拷贝，使用移动语义（move semantics）或引用传递（reference passing）。Folly 的 StringPiece 可以避免字符串拷贝。
⚝ 内联函数：将频繁调用的短小函数声明为内联函数（inline function），减少函数调用开销。
⚝ 循环展开：对于循环次数固定的循环，可以进行循环展开（loop unrolling），减少循环控制开销。
⚝ 缓存优化：优化数据访问模式，提高缓存命中率。例如，使用局部性原理，减少 cache miss。
④ 并发和并行优化
⚝ 多线程：利用多核 CPU 的并行处理能力，使用多线程或多进程并行执行任务。Folly 提供了 Futures、Promises 和 Executors 等工具用于并发编程。
⚝ 异步 IO：使用异步 IO 模型，提高 IO 操作的并发性。Folly 的 Asio 库可以用于构建高性能网络应用。
⚝ 无锁编程：在某些场景下，可以使用无锁数据结构和算法，避免锁竞争，提高并发性能。Folly 提供了 ConcurrentHashMap 等并发数据结构。
性能调优是一个迭代的过程。你需要不断地进行性能分析、瓶颈识别、策略选择和代码优化，并使用 Folly Benchmark 和 Profiling 工具验证优化效果，最终达到最佳的性能。
9.4 Folly与第三方库集成 (Folly Integration with Third-Party Libraries)
在实际项目开发中，我们经常需要与各种第三方库集成，以利用已有的功能和提高开发效率。Folly 作为一个强大的 C++ 库，可以与众多第三方库良好地集成。本节将介绍 Folly 与一些常用第三方库的集成方法和最佳实践。
9.4.1 与 gRPC 集成 (Integration with gRPC)
gRPC 是一个高性能、通用的开源 RPC 框架，广泛应用于微服务架构中。Folly 可以与 gRPC 集成，构建高性能的 gRPC 服务和客户端。
① 使用 Folly Futures 作为 gRPC 异步 API
gRPC 默认使用自身的异步 API，基于 Completion Queue。Folly Futures 提供了更现代、更易用的异步编程模型。你可以使用 gRPC 的 Folly 插件，将 gRPC 的异步 API 转换为 Folly Futures。
在 gRPC 的 CMakeLists.txt 中，启用 Folly 插件：
1
grpc_cpp_plugin(
2
your_proto_plugin
3
PROTO_FILES your_service.proto
4
PLUGIN "grpc_cpp_plugin_folly_future" # 启用 Folly Future 插件
5
)
重新编译 proto 文件后，生成的 gRPC 服务端和客户端代码将提供基于 Folly Futures 的异步接口。
② 在 gRPC 服务中使用 Folly 组件
在 gRPC 服务端的实现中，你可以自由地使用 Folly 的各种组件，例如 FBString、FBVector、Futures、Executors 等，来提高服务端的性能和开发效率。
例如，在 gRPC 服务端使用 Folly Executors 来处理请求：
1
#include <grpcpp/grpcpp.h>
2
#include <folly/executors/ThreadPoolExecutor.h>
3
#include "your_service.grpc.pb.h"
4
5
class YourServiceImpl final : public YourService::Service {
6
public:
7
grpc::Status YourMethod(grpc::ServerContext* context, const YourRequest* request, YourResponse* response) override {
8
executor_->add([request, response]() { // 使用 Folly Executor 异步处理请求
9
// ... 服务端逻辑 ...
10
response->set_message("Hello, " + request->name());
11
});
12
return grpc::Status::OK;
13
}
14
15
private:
16
folly::ThreadPoolExecutor executor_{4}; // 创建 Folly 线程池
17
};
③ 在 gRPC 客户端中使用 Folly 组件
同样，在 gRPC 客户端的实现中，你也可以使用 Folly 组件，例如使用 Folly Futures 来处理异步 RPC 调用结果。
1
#include <grpcpp/grpcpp.h>
2
#include <folly/Future.h>
3
#include "your_service.grpc.pb.h"
4
5
int main() {
6
auto channel = grpc::CreateChannel("localhost:50051", grpc::InsecureChannelCredentials());
7
std::unique_ptr<YourService::Stub> stub = YourService::NewStub(channel);
8
9
YourRequest request;
10
request.set_name("World");
11
12
folly::Future<grpc::ClientContext, YourResponse> future = // 使用 Folly Future 异步调用
13
stub->future()->YourMethod(request);
14
15
future.then([](folly::Try<std::pair<grpc::ClientContext, YourResponse>>&& result) {
16
if (result.hasValue()) {
17
std::cout << "Response: " << result.value().second.message() << std::endl;
18
} else {
19
std::cerr << "RPC failed: " << result.exception().what() << std::endl;
20
}
21
});
22
23
// ... 等待 Future 完成 ...
24
future.wait();
25
26
return 0;
27
}
9.4.2 与 Protobuf 集成 (Integration with Protobuf)
Protobuf (Protocol Buffers) 是 Google 开发的语言无关、平台无关、可扩展的序列化结构数据的方法，常用于数据序列化和 RPC 协议。Folly 可以与 Protobuf 集成，高效地处理 Protobuf 消息。
① 使用 Folly StringPiece 处理 Protobuf 字符串
Protobuf 的 string 类型在 C++ 中通常表示为 std::string。当处理大量的 Protobuf 消息时，频繁的 std::string 拷贝可能会影响性能。你可以使用 Folly StringPiece 来避免字符串拷贝，提高性能。
例如，在处理 Protobuf 消息时，使用 StringPiece 访问字符串字段：
1
#include <folly/StringPiece.h>
2
#include "your_message.pb.h"
3
4
void process_message(const YourMessage& message) {
5
folly::StringPiece name = message.name(); // 使用 StringPiece，避免拷贝
6
std::cout << "Name: " << name.toString() << std::endl; // 需要时转换为 std::string
7
}
② 使用 Folly FBString 替代 std::string
在某些场景下，你可以考虑使用 Folly FBString 替代 std::string 来存储 Protobuf 字符串。FBString 在某些操作上可能比 std::string 更高效，例如小字符串优化。
③ 使用 Folly Dynamic 解析 Protobuf JSON
Folly Dynamic 可以方便地解析 JSON 数据。你可以将 Protobuf 消息转换为 JSON 格式，然后使用 Dynamic 进行解析和访问。
1
#include <folly/dynamic.h>
2
#include <google/protobuf/util/json_util.h>
3
#include "your_message.pb.h"
4
5
void process_json_message(const YourMessage& message) {
6
std::string json_string;
7
google::protobuf::util::MessageToJsonString(message, &json_string); // Protobuf 消息转 JSON
8
9
folly::dynamic dynamic_message = folly::parseJson(json_string); // 解析 JSON
10
11
std::string name = dynamic_message["name"].asString(); // 使用 Dynamic 访问字段
12
std::cout << "Name from JSON: " << name << std::endl;
13
}
9.4.3 与 Boost 库集成 (Integration with Boost Libraries)
Boost 库是一个广泛使用的 C++ 标准库扩展，提供了大量的实用工具和算法。Folly 与 Boost 库可以很好地协同工作。
① 使用 Boost Asio 替代 Folly Asio
虽然 Folly 提供了 Asio 库，但 Boost Asio 更加成熟和广泛使用。在某些项目中，你可能需要使用 Boost Asio 替代 Folly Asio。Folly 可以与 Boost Asio 集成，例如使用 Boost Asio 的 IO 服务和 socket。
② 使用 Boost Algorithm 替代 std::algorithm
Boost Algorithm 库提供了更多更强大的算法，例如字符串算法、数值算法等。你可以根据需要选择使用 Boost Algorithm 替代 std::algorithm。
③ 使用 Boost Date-Time 替代 Folly Time
Boost Date-Time 库提供了丰富的日期和时间处理功能。如果你的项目需要复杂的日期时间操作，可以考虑使用 Boost Date-Time 替代 Folly Time。
9.4.4 与其他库集成 (Integration with Other Libraries)
Folly 可以与众多其他第三方库集成，例如：
⚝ 数据库库：libpq (PostgreSQL), mysqlclient (MySQL), RocksDB, LevelDB 等。Folly 可以与这些数据库库集成，构建高性能的数据库应用。
⚝ HTTP 客户端库：libcurl, libevent http client, asio http client 等。Folly 可以与这些 HTTP 客户端库集成，构建高性能的 HTTP 客户端应用。
⚝ JSON 库：RapidJSON, nlohmann_json 等。虽然 Folly 提供了 Dynamic 和 JSON 解析功能，但在某些场景下，你可能需要使用更专业的 JSON 库。
⚝ 压缩库：zlib, lz4, zstd 等。Folly 可以与这些压缩库集成，实现数据压缩和解压缩功能。
在与第三方库集成时，需要注意以下几点：
⚝ 依赖管理：使用 CMake 或其他构建工具管理第三方库的依赖。
⚝ 版本兼容性：确保 Folly 版本和第三方库版本兼容。
⚝ 性能测试：集成第三方库后，进行性能测试，评估集成对性能的影响。
⚝ 代码风格一致性：保持代码风格与 Folly 和第三方库的代码风格一致，提高代码可读性和可维护性。
通过合理地与第三方库集成，你可以充分利用 Folly 的强大功能，并结合第三方库的优势，构建出高效、可靠、功能丰富的 C++ 应用程序。
9.5 Folly在大型项目中的应用案例分析 (Case Study: Folly in Large-Scale Projects)
Folly 作为 Facebook 开源的核心 C++ 库，已经在众多大型项目中得到了广泛应用。通过分析 Folly 在这些项目中的应用案例，我们可以更深入地理解 Folly 的价值和优势，并学习如何在大型项目中有效地使用 Folly。
9.5.1 Facebook 内部应用 (Facebook Internal Applications)
Folly 最初就是为了满足 Facebook 内部高性能、高可靠性应用的需求而开发的。Facebook 内部的许多核心系统都使用了 Folly，例如：
① Facebook 基础设施
Folly 是 Facebook 基础设施的核心组件，支撑着 Facebook 的各种服务和应用。例如，Facebook 的网络基础设施、存储系统、数据库系统、消息队列系统等都使用了 Folly。
② 高性能服务器
Facebook 开发了大量的高性能服务器，用于处理海量的用户请求和数据。这些服务器广泛使用了 Folly 的网络库（Asio）、并发库（Futures, Executors）、字符串库（FBString, StringPiece）、容器库（FBVector, F14Map）等组件，以实现高性能和低延迟。
③ 数据处理和分析系统
Facebook 的数据处理和分析系统也使用了 Folly。例如，用于大规模数据处理的批处理框架、实时数据流处理系统、机器学习平台等都使用了 Folly 的并发库、容器库、算法库等组件，以提高数据处理效率和性能。
9.5.2 开源项目应用 (Open Source Project Applications)
除了 Facebook 内部应用，Folly 也被许多开源项目采用，例如：
① RocksDB
RocksDB 是一个高性能的嵌入式 key-value 存储引擎，由 Facebook 开源。RocksDB 广泛使用了 Folly 的并发库、容器库、字符串库、内存管理库等组件，以实现高性能和低延迟的存储服务。
② HHVM (HipHop Virtual Machine)
HHVM 是 Facebook 开发的用于执行 Hack 和 PHP 代码的虚拟机。HHVM 内部使用了 Folly 的许多组件，例如并发库、网络库、字符串库、容器库等，以提高虚拟机的性能和效率。
③ Proxygen
Proxygen 是 Facebook 开源的 C++ HTTP/2 和 HTTP/1.1 客户端和服务器库。Proxygen 基于 Folly 构建，使用了 Folly 的 Asio、Futures、Executors、StringPiece 等组件，实现了高性能的 HTTP 协议处理。
④ Wangle
Wangle 是 Facebook 开源的 C++ 客户端/服务器框架，用于构建异步、事件驱动的服务。Wangle 基于 Netty 和 Folly 构建，使用了 Folly 的 Asio、Futures、Executors 等组件，提供了易于使用、高性能的网络编程框架。
9.5.3 案例分析：RocksDB 中的 Folly 应用 (Case Study: Folly in RocksDB)
RocksDB 是一个典型的成功应用 Folly 的开源项目。通过分析 RocksDB 如何使用 Folly，我们可以学习到 Folly 在实际项目中的应用技巧。
① Folly ConcurrentHashMap
RocksDB 使用 Folly ConcurrentHashMap 作为其 MemTable 的底层数据结构之一。ConcurrentHashMap 提供了高效的并发访问性能，可以支持高并发的写入和读取操作，是 RocksDB 高性能的关键组件之一。
② Folly Futures 和 Executors
RocksDB 在后台 compaction 和 flush 任务中使用了 Folly Futures 和 Executors。Futures 和 Executors 提供了异步任务调度和并发执行能力，使得 RocksDB 可以高效地进行后台数据处理，同时不影响前台的读写操作。
③ Folly StringPiece 和 FBString
RocksDB 在处理 key 和 value 时，广泛使用了 Folly StringPiece 和 FBString。StringPiece 避免了不必要的字符串拷贝，提高了性能。FBString 在小字符串优化方面可能比 std::string 更高效。
④ Folly Memory Management
RocksDB 使用了 Folly 的内存管理工具，例如 folly::AlignedBuffer 和自定义的内存分配器，以提高内存分配和管理的效率。
通过 RocksDB 的案例分析，我们可以看到 Folly 在高性能存储系统中的重要作用。Folly 提供的各种组件，例如并发数据结构、异步编程工具、字符串处理工具、内存管理工具等，都为 RocksDB 的高性能和高可靠性提供了坚实的基础。
9.5.4 Folly 应用的最佳实践 (Best Practices for Folly Application)
在大型项目中应用 Folly，需要遵循一些最佳实践：
① 按需引入 Folly 组件
Folly 包含大量的组件，并非所有组件都适用于所有项目。应该根据项目的实际需求，按需引入 Folly 组件，避免过度依赖和增加不必要的编译时间。
② 充分理解 Folly 组件的设计和用法
在使用 Folly 组件之前，应该充分理解其设计原理、适用场景和使用方法。阅读 Folly 的文档和源代码，深入理解组件的特性和限制，才能更好地应用 Folly。
③ 结合 Profiling 工具进行性能分析
在应用 Folly 组件后，应该结合 Profiling 工具进行性能分析，评估 Folly 组件对性能的影响。根据性能分析结果，进行必要的调优和优化。
④ 关注 Folly 社区动态
Folly 社区活跃，不断有新的特性和改进。关注 Folly 社区的动态，及时了解 Folly 的最新发展，可以更好地利用 Folly 的新功能和优化。
⑤ 参与 Folly 社区贡献
如果在使用 Folly 过程中发现问题或有改进建议，可以积极参与 Folly 社区贡献，例如提交 bug 报告、提交 patch、参与讨论等，共同推动 Folly 的发展。
通过学习 Folly 在大型项目中的应用案例，并遵循最佳实践，你可以更好地在自己的项目中应用 Folly，构建出高性能、高可靠性、易于维护的 C++ 应用程序。
END_OF_CHAPTER
10. chapter 10： 实战案例：构建高可用分布式系统 (Practical Case Study: Building a Highly Available Distributed System)
10.1 案例背景与需求分析 (Case Background and Requirement Analysis)
在当今互联网时代，分布式系统已经成为构建大型、高可用性应用的核心架构模式。为了更好地理解 Folly 和 Thrift 在实际项目中的应用，本章将通过一个具体的实战案例，深入探讨如何使用 Folly 和 Thrift 构建一个高可用分布式系统。
案例背景：
假设我们正在构建一个在线购物平台的订单处理系统 (Order Processing System)。该系统需要处理用户提交的订单，包括订单创建、支付、库存更新、物流通知等环节。随着用户量的增长和业务的扩展，系统需要具备高可用性、高并发处理能力和良好的可扩展性。
需求分析：
为了满足在线购物平台的需求，我们的订单处理系统需要满足以下关键需求：
① 高可用性 (High Availability, HA)：系统需要 7x24 小时不间断运行，即使在部分组件发生故障时，也能保证服务的持续可用性。这意味着系统需要具备容错能力 (Fault Tolerance) 和故障转移 (Failover) 机制。
② 高并发处理 (High Concurrency)：在促销活动或高峰时段，系统需要能够处理大量的并发请求，保证用户体验流畅。这要求系统具备良好的并发控制 (Concurrency Control) 和负载均衡 (Load Balancing) 能力。
③ 可扩展性 (Scalability)：随着业务增长，系统需要能够方便地进行水平扩展，增加处理能力。这意味着系统架构需要是松耦合 (Loose Coupling) 的，易于添加新的服务节点。
④ 低延迟 (Low Latency)：用户提交订单后，系统需要快速响应，减少用户等待时间。这要求系统在各个环节都具备高性能 (High Performance) 和低延迟 (Low Latency) 的特性。
⑤ 数据一致性 (Data Consistency)：在分布式环境下，需要保证订单数据、支付数据、库存数据等在各个服务节点之间的一致性。这需要采用合适的分布式事务 (Distributed Transaction) 或最终一致性 (Eventual Consistency) 策略。
⑥ 易于维护与监控 (Easy Maintenance and Monitoring)：系统需要具备完善的监控和日志系统，方便运维人员及时发现和解决问题。同时，系统架构应该清晰易懂，易于维护和升级。
为什么选择 Folly 与 Thrift？
针对以上需求，Folly 和 Thrift 提供了强大的技术支撑：
① Folly：作为一个高性能的 C++ 库，Folly 提供了丰富的组件，可以帮助我们构建高效、可靠的后端服务。例如：
⚝ Futures 与 Promises：用于异步编程，提高系统并发处理能力。
⚝ Executors：用于任务调度和并行执行，充分利用多核 CPU 性能。
⚝ Asio：用于网络编程，构建高性能网络应用。
⚝ Containers (FBVector, F14Map)：提供高性能的数据结构，优化内存使用和访问效率。
⚝ Option 与 Expected：用于优雅的错误处理，提高代码的健壮性。
② Thrift：作为一个跨语言的服务框架，Thrift 可以帮助我们定义和生成跨语言的服务接口，实现不同服务之间的通信。例如：
⚝ IDL (Interface Definition Language)：用于定义服务接口和数据结构，方便不同团队协作开发。
⚝ 代码生成：支持多种编程语言的代码生成，包括 C++、Java、Python 等，实现跨语言的服务调用。
⚝ 多种协议与传输层：支持多种协议（Binary, Compact, JSON）和传输层（TCP, HTTP），可以根据场景选择合适的通信方式。
⚝ 服务治理：Thrift 生态系统也包含一些服务治理的组件，如负载均衡、服务发现等（虽然本书主要聚焦 Folly 和 Thrift 本身，服务治理部分会简要提及）。
通过结合 Folly 的高性能 C++ 组件和 Thrift 的跨语言服务框架，我们可以构建一个满足上述需求的高可用分布式订单处理系统。在接下来的章节中，我们将逐步设计和实现这个系统。
10.2 系统架构设计：基于 Folly 与 Thrift (System Architecture Design: Based on Folly and Thrift)
基于前一节的需求分析，我们来设计订单处理系统的架构。我们将采用微服务架构 (Microservices Architecture)，将系统拆分成多个独立的服务，每个服务负责特定的业务功能。这种架构模式可以提高系统的可扩展性、可维护性和容错性。
系统架构图：
\[ \begin{tikzpicture}[node distance = 1.5cm, auto] \node (client) [cloud] {客户端 (Client)}; \node (lb) [cloud, right of=client, xshift=1cm] {负载均衡 (Load Balancer)}; \node (gateway) [rectangle, below of=lb, yshift=-0.5cm] {API 网关 (API Gateway)}; \node (order) [rectangle, below of=gateway, yshift=-0.5cm] {订单服务 (Order Service)}; \node (payment) [rectangle, right of=order, xshift=1cm] {支付服务 (Payment Service)}; \node (inventory) [rectangle, left of=order, xshift=-1cm] {库存服务 (Inventory Service)}; \node (db) [database, below of=order, yshift=-0.5cm] {数据库 (Database)}; \node (cache) [database, right of=db, xshift=1cm] {缓存 (Cache)}; \node (mq) [cloud, right of=payment, xshift=1cm] {消息队列 (Message Queue)}; \node (log) [cloud, above of=payment, yshift=0.5cm] {日志服务 (Logging Service)}; \node (monitor) [cloud, above of=inventory, yshift=0.5cm] {监控服务 (Monitoring Service)}; \path[->] (client) edge (lb); \path[->] (lb) edge (gateway); \path[->] (gateway) edge (order); \path[->] (gateway) edge (payment); \path[->] (gateway) edge (inventory); \path[->] (order) edge (inventory); \path[->] (order) edge (payment); \path[->] (order) edge (db); \path[->] (payment) edge (db); \path[->] (inventory) edge (db); \path[->] (order) edge (cache); \path[->] (payment) edge (cache); \path[->] (inventory) edge (cache); \path[->, dashed] (order) edge (mq); \path[->, dashed] (payment) edge (mq); \path[->, dashed] (inventory) edge (mq); \path[->, dashed] (gateway) edge (log); \path[->, dashed] (order) edge (log); \path[->, dashed] (payment) edge (log); \path[->, dashed] (inventory) edge (log); \path[->, dashed] (gateway) edge (monitor); \path[->, dashed] (order) edge (monitor); \path[->, dashed] (payment) edge (monitor); \path[->, dashed] (inventory) edge (monitor); \end{tikzpicture} \]
架构组件说明：
① 客户端 (Client)：用户的浏览器或移动应用，发起订单请求。
② 负载均衡 (Load Balancer)：将客户端请求分发到不同的 API 网关实例，实现请求的负载均衡。常用的负载均衡器有 Nginx, HAProxy, LVS 等。
③ API 网关 (API Gateway)：作为系统的入口，负责请求路由、认证授权、限流熔断等功能。API 网关可以使用 Folly 构建高性能的网络服务。
④ 订单服务 (Order Service)：负责订单的创建、查询、取消等核心业务逻辑。订单服务将使用 Thrift 定义服务接口，并使用 Folly 构建高性能的 C++ 服务端。
⑤ 支付服务 (Payment Service)：负责处理支付相关的业务逻辑，如支付请求、支付回调、退款等。支付服务同样使用 Thrift 和 Folly 构建。
⑥ 库存服务 (Inventory Service)：负责管理商品库存，处理库存扣减、库存回滚等操作。库存服务也使用 Thrift 和 Folly 构建。
⑦ 数据库 (Database)：用于持久化存储订单数据、支付数据、库存数据等。可以使用关系型数据库 (如 MySQL, PostgreSQL) 或 NoSQL 数据库 (如 Redis, MongoDB)。
⑧ 缓存 (Cache)：用于缓存热点数据，提高数据访问速度，降低数据库压力。可以使用 Redis, Memcached 等缓存系统。
⑨ 消息队列 (Message Queue, MQ)：用于异步处理一些非核心业务逻辑，如订单支付成功后的通知、日志收集等。常用的消息队列有 Kafka, RabbitMQ, RocketMQ 等。
⑩ 日志服务 (Logging Service)：收集和存储系统日志，用于故障排查和性能分析。可以使用 ELK Stack (Elasticsearch, Logstash, Kibana) 或 Graylog 等日志系统。
⑪ 监控服务 (Monitoring Service)：监控系统的运行状态，包括服务性能、资源使用率等，及时发现和报警。常用的监控系统有 Prometheus, Grafana, Zabbix 等。
技术选型与 Folly/Thrift 应用：
在这个架构中，我们将重点使用 Folly 和 Thrift 构建以下核心组件：
① API 网关 (API Gateway)：可以使用 Folly 的 Asio 和 HTTP 组件构建高性能的 API 网关，处理客户端的 HTTP 请求，并将请求路由到后端的各个服务。
② 订单服务 (Order Service)、支付服务 (Payment Service)、库存服务 (Inventory Service)：这些核心业务服务将使用 Thrift 定义服务接口，并使用 Folly 构建 C++ 服务端。Folly 的 Futures, Executors, Containers 等组件将用于提高服务的性能和并发处理能力。
③ 服务间通信：服务之间（例如，订单服务调用库存服务、订单服务调用支付服务）将使用 Thrift 进行 RPC (Remote Procedure Call) 通信。Thrift 的跨语言特性也为未来可能的异构系统集成提供了便利。
数据流：
一个典型的订单创建流程如下：
- 客户端发送创建订单请求到负载均衡器。
- 负载均衡器将请求转发到某个 API 网关实例。
- API 网关接收请求，进行认证授权和参数校验，然后将请求路由到订单服务。
- 订单服务接收创建订单请求，首先调用库存服务检查库存是否充足。
- 如果库存充足，订单服务创建订单记录，并调用支付服务发起支付请求。
- 支付服务处理支付逻辑，支付成功后，通知订单服务。
- 订单服务接收支付成功通知，更新订单状态，并异步发送消息到消息队列，通知库存服务扣减库存。
- 库存服务接收扣减库存消息，执行库存扣减操作。
- 订单服务将订单创建结果返回给 API 网关，API 网关再返回给客户端。
通过以上架构设计，我们可以构建一个高可用、可扩展、高性能的分布式订单处理系统。接下来，我们将重点关注核心模块的开发，即 Thrift 服务定义与实现。
10.3 核心模块开发：Thrift 服务定义与实现 (Core Module Development: Thrift Service Definition and Implementation)
在本节中，我们将重点开发订单处理系统的核心模块：订单服务 (Order Service)。我们将使用 Thrift IDL 定义订单服务的接口和数据结构，并使用 C++ 和 Folly 实现服务端。
1. Thrift IDL 定义：
首先，我们需要定义订单服务相关的 Thrift IDL 文件 order_service.thrift。
1
namespace cpp order.service
2
3
struct Product {
4
1: i32 productID;
5
2: string name;
6
3: double price;
7
}
8
9
struct User {
10
1: i32 userID;
11
2: string userName;
12
3: string email;
13
}
14
15
struct Order {
16
1: i64 orderID;
17
2: i32 userID;
18
3: list<Product> products;
19
4: double totalPrice;
20
5: string orderStatus; // e.g., "PENDING", "PAID", "SHIPPED", "CANCELLED"
21
6: i64 createTime;
22
7: optional i64 paymentTime;
23
}
24
25
exception InsufficientStockException {
26
1: string message;
27
}
28
29
exception OrderNotFoundException {
30
1: string message;
31
}
32
33
service OrderService {
34
Order createOrder(1: i32 userID, 2: list<i32> productIDs) throws (InsufficientStockException),
35
Order getOrder(1: i64 orderID) throws (OrderNotFoundException),
36
bool cancelOrder(1: i64 orderID) throws (OrderNotFoundException),
37
}
IDL 文件说明：
⚝ namespace cpp order.service: 定义 C++ 命名空间为 order::service。
⚝ struct Product, User, Order: 定义数据结构 Product（商品）、User（用户）、Order（订单）。
⚝ exception InsufficientStockException, OrderNotFoundException: 定义异常 InsufficientStockException（库存不足异常）和 OrderNotFoundException（订单未找到异常）。
⚝ service OrderService: 定义服务接口 OrderService，包含三个方法：
⚝ createOrder: 创建订单，输入参数为 userID 和 productIDs，可能抛出 InsufficientStockException 异常。
⚝ getOrder: 获取订单信息，输入参数为 orderID，可能抛出 OrderNotFoundException 异常。
⚝ cancelOrder: 取消订单，输入参数为 orderID，可能抛出 OrderNotFoundException 异常。
2. 代码生成：
使用 Thrift 编译器生成 C++ 代码：
1
thrift --gen cpp order_service.thrift
这会生成 gen-cpp 目录，其中包含 order_service.h 和 order_service.cpp 文件，以及 order_service_types.h 和 order_service_types.cpp 文件。
3. 服务端实现 (C++)：
创建一个 C++ 文件 OrderServiceImpl.cpp 实现 OrderService 接口。
1
#include "gen-cpp/OrderService.h"
2
#include "gen-cpp/order_service_types.h"
3
#include <folly/futures/Future.h>
4
#include <folly/executors/IOThreadPoolExecutor.h>
5
#include <thrift/lib/server/TThreadedServer.h>
6
#include <thrift/transport/TServerSocket.h>
7
#include <thrift/transport/TBufferTransports.h>
8
#include <iostream>
9
#include <vector>
10
#include <unordered_map>
11
12
using namespace apache::thrift;
13
using namespace apache::thrift::server;
14
using namespace apache::thrift::transport;
15
using namespace apache::thrift::protocol;
16
using namespace order::service;
17
using namespace folly;
18
19
// 模拟数据库或缓存
20
std::unordered_map<int32_t, Product> productDB = {
21
{1, {1, "Product A", 10.0}},
22
{2, {2, "Product B", 20.0}},
23
{3, {3, "Product C", 30.0}}
24
};
25
std::unordered_map<int64_t, Order> orderDB;
26
int64_t nextOrderID = 1;
27
28
class OrderServiceImpl : virtual public OrderServiceIf {
29
public:
30
OrderServiceImpl() {}
31
32
void createOrder(Order& _return, int32_t userID, const std::vector<int32_t>& productIDs) override {
33
std::cout << "createOrder called for userID: " << userID << std::endl;
34
Order order;
35
order.orderID = nextOrderID++;
36
order.userID = userID;
37
order.createTime = time(0);
38
order.orderStatus = "PENDING";
39
double totalPrice = 0.0;
40
for (int32_t productID : productIDs) {
41
if (productDB.find(productID) == productDB.end()) {
42
throw InsufficientStockException{"Product not found: " + std::to_string(productID)}; // 简化库存检查，假设商品存在即库存充足
43
}
44
order.products.push_back(productDB[productID]);
45
totalPrice += productDB[productID].price;
46
}
47
order.totalPrice = totalPrice;
48
orderDB[order.orderID] = order;
49
_return = order;
50
}
51
52
void getOrder(Order& _return, int64_t orderID) override {
53
std::cout << "getOrder called for orderID: " << orderID << std::endl;
54
if (orderDB.find(orderID) == orderDB.end()) {
55
throw OrderNotFoundException{"Order not found: " + std::to_string(orderID)};
56
}
57
_return = orderDB[orderID];
58
}
59
60
void cancelOrder(bool& _return, int64_t orderID) override {
61
std::cout << "cancelOrder called for orderID: " << orderID << std::endl;
62
if (orderDB.find(orderID) == orderDB.end()) {
63
throw OrderNotFoundException{"Order not found: " + std::to_string(orderID)};
64
}
65
orderDB.erase(orderID);
66
_return = true;
67
}
68
};
69
70
int main() {
71
int port = 9090;
72
std::shared_ptr<OrderServiceImpl> handler(new OrderServiceImpl());
73
std::shared_ptr<TProcessor> processor(new OrderServiceProcessor(handler));
74
std::shared_ptr<TServerTransport> serverTransport(new TServerSocket(port));
75
std::shared_ptr<TTransportFactory> transportFactory(new TBufferedTransportFactory());
76
std::shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());
77
78
TThreadedServer server(processor, serverTransport, transportFactory, protocolFactory);
79
80
std::cout << "Starting the OrderService server..." << std::endl;
81
server.serve();
82
std::cout << "OrderService server stopped." << std::endl;
83
return 0;
84
}
服务端代码说明：
① #include 引入头文件: 引入 Thrift 生成的代码头文件 (OrderService.h, order_service_types.h)，以及 Folly 和 Thrift 的相关头文件。
② using namespace: 简化命名空间的使用。
③ productDB, orderDB, nextOrderID: 模拟数据库或缓存，用于存储商品信息和订单信息。实际项目中需要替换为真正的数据库或缓存系统。
④ OrderServiceImpl 类: 实现 OrderServiceIf 接口，重写 createOrder, getOrder, cancelOrder 方法，实现具体的业务逻辑。
⚝ createOrder: 创建订单，简单模拟库存检查（商品存在即认为库存充足），生成订单 ID，计算总价，保存订单信息。
⚝ getOrder: 获取订单信息，从 orderDB 中查找订单。
⚝ cancelOrder: 取消订单，从 orderDB 中删除订单。
⑤ main 函数:
⚝ 创建 OrderServiceImpl 实例作为 handler。
⚝ 创建 OrderServiceProcessor，将 handler 注册到 processor 中。
⚝ 创建 TServerSocket 监听指定端口 (9090)。
⚝ 创建 TBufferedTransportFactory 和 TBinaryProtocolFactory，选择缓冲传输和二进制协议。
⚝ 创建 TThreadedServer，使用多线程处理请求。
⚝ 调用 server.serve() 启动服务。
4. 编译服务端代码：
使用 g++ 编译服务端代码，需要链接 Thrift 和 Folly 库。编译命令可能因环境而异，以下是一个示例：
1
g++ -std=c++17 -o OrderServiceServer OrderServiceImpl.cpp gen-cpp/OrderService.cpp gen-cpp/order_service_types.cpp -lthrift -lfolly -lglog -lgflags -lz -lsnappy
注意: 编译命令需要根据实际的 Folly 和 Thrift 安装路径以及依赖库进行调整。
通过以上步骤，我们完成了订单服务的 Thrift IDL 定义和服务端 C++ 实现。在下一节中，我们将开发客户端代码，并进行集成和测试。
10.4 客户端集成与测试 (Client Integration and Testing)
本节将介绍如何开发 C++ 客户端来调用上一节实现的订单服务，并进行简单的测试。
1. 客户端代码 (C++)：
创建一个 C++ 文件 OrderServiceClient.cpp 作为客户端代码。
1
#include "gen-cpp/OrderService.h"
2
#include "gen-cpp/order_service_types.h"
3
#include <thrift/protocol/TBinaryProtocol.h>
4
#include <thrift/transport/TSocket.h>
5
#include <thrift/transport/TTransportUtils.h>
6
#include <iostream>
7
8
using namespace apache::thrift;
9
using namespace apache::thrift::protocol;
10
using namespace apache::thrift::transport;
11
using namespace order::service;
12
13
int main() {
14
std::shared_ptr<TTransport> socket(new TSocket("localhost", 9090));
15
std::shared_ptr<TTransport> transport(new TBufferedTransport(socket));
16
std::shared_ptr<TProtocol> protocol(new TBinaryProtocol(transport));
17
OrderServiceClient client(protocol);
18
19
try {
20
transport->open();
21
22
// 创建订单
23
Order createdOrder;
24
std::vector<int32_t> productIDs = {1, 2};
25
client.createOrder(createdOrder, 123, productIDs);
26
std::cout << "Created Order ID: " << createdOrder.orderID << ", Total Price: " << createdOrder.totalPrice << std::endl;
27
28
// 获取订单
29
Order fetchedOrder;
30
client.getOrder(fetchedOrder, createdOrder.orderID);
31
std::cout << "Fetched Order ID: " << fetchedOrder.orderID << ", Status: " << fetchedOrder.orderStatus << std::endl;
32
33
// 取消订单
34
bool cancelResult = client.cancelOrder(createdOrder.orderID);
35
std::cout << "Cancel Order Result: " << (cancelResult ? "true" : "false") << std::endl;
36
37
// 尝试获取已取消的订单，应该抛出异常
38
try {
39
Order deletedOrder;
40
client.getOrder(deletedOrder, createdOrder.orderID);
41
} catch (const OrderNotFoundException& e) {
42
std::cout << "Expected Exception: " << e.message << std::endl;
43
}
44
45
transport->close();
46
} catch (const TException& tx) {
47
std::cerr << "Error: " << tx.what() << std::endl;
48
}
49
return 0;
50
}
客户端代码说明：
① #include 引入头文件: 引入 Thrift 生成的代码头文件和 Thrift 客户端相关的头文件。
② using namespace: 简化命名空间的使用。
③ 创建 Transport 和 Protocol: 创建 TSocket 连接到服务端 (localhost:9090)，使用 TBufferedTransport 和 TBinaryProtocol。
④ 创建 OrderServiceClient: 使用 protocol 创建 OrderServiceClient 实例。
⑤ 调用服务方法:
⚝ createOrder: 调用 createOrder 方法创建订单，并打印订单 ID 和总价。
⚝ getOrder: 调用 getOrder 方法获取订单信息，并打印订单 ID 和状态。
⚝ cancelOrder: 调用 cancelOrder 方法取消订单，并打印取消结果。
⚝ 异常处理: 尝试获取已取消的订单，捕获 OrderNotFoundException 异常，并打印异常信息。
⑥ 关闭 Transport: 关闭 transport 连接。
2. 编译客户端代码：
使用 g++ 编译客户端代码，同样需要链接 Thrift 和 Folly 库。编译命令类似服务端：
1
g++ -std=c++17 -o OrderServiceClient OrderServiceClient.cpp gen-cpp/OrderService.cpp gen-cpp/order_service_types.cpp -lthrift -lfolly -lglog -lgflags -lz -lsnappy
3. 测试步骤：
① 启动服务端: 运行编译生成的可执行文件 OrderServiceServer。
② 运行客户端: 在另一个终端运行编译生成的可执行文件 OrderServiceClient。
如果一切正常，客户端会输出类似以下的日志：
1
Created Order ID: 1, Total Price: 30
2
Fetched Order ID: 1, Status: PENDING
3
Cancel Order Result: true
4
Expected Exception: Order not found: 1
服务端终端会输出类似以下的日志：
1
Starting the OrderService server...
2
createOrder called for userID: 123
3
getOrder called for orderID: 1
4
cancelOrder called for orderID: 1
5
OrderService server stopped.
4. 单元测试与集成测试：
上述客户端代码只是一个简单的功能测试。在实际项目中，需要编写更完善的单元测试和集成测试。
① 单元测试 (Unit Testing)：针对 OrderServiceImpl 的每个方法进行单元测试，例如使用 Google Test 或 Facebook 的 Folly Test 框架。测试用例需要覆盖各种正常情况和异常情况，保证服务逻辑的正确性。
② 集成测试 (Integration Testing)：测试客户端和服务端之间的集成，验证 Thrift RPC 通信的正确性。可以使用 Mock 服务端进行客户端的单元测试，也可以搭建真实的测试环境进行端到端集成测试。
5. 负载测试 (Load Testing)：
为了验证系统的性能和稳定性，还需要进行负载测试。可以使用工具如 Apache JMeter, LoadRunner 或 Locust 等模拟大量并发请求，测试订单服务的吞吐量、响应时间和错误率。负载测试可以帮助我们发现系统的性能瓶颈，并进行性能优化。
通过以上客户端集成和测试步骤，我们可以验证订单服务的基本功能和 Thrift RPC 通信的正确性。在实际项目中，测试是一个持续迭代的过程，需要不断完善测试用例，提高系统的质量和可靠性。
10.5 部署与运维考量 (Deployment and Operation Considerations)
在构建高可用分布式系统时，除了服务开发和测试，部署和运维也是至关重要的环节。本节将讨论订单处理系统的部署和运维考量。
1. 部署策略：
① 容器化部署 (Containerization)：使用 Docker 将订单服务、支付服务、库存服务等打包成 Docker 镜像，然后使用 Kubernetes (K8s) 或 Docker Compose 等容器编排工具进行部署。容器化部署可以提高部署效率、环境一致性和资源利用率。
② 云平台部署 (Cloud Deployment)：将系统部署到云平台 (如 AWS, Azure, GCP) 上，利用云平台的弹性伸缩、负载均衡、监控告警等服务，简化运维工作。可以使用云平台的容器服务 (如 AWS ECS, Azure Kubernetes Service, Google Kubernetes Engine) 或虚拟机服务 (如 AWS EC2, Azure Virtual Machines, Google Compute Engine)。
③ 混合云部署 (Hybrid Cloud Deployment)：对于一些有特殊安全或合规要求的场景，可以采用混合云部署，将部分服务部署在私有云或数据中心，部分服务部署在公有云。
2. 负载均衡：
在系统架构设计中，我们已经引入了负载均衡器 (Load Balancer)。在部署时，需要配置负载均衡器，将客户端请求均匀地分发到多个 API 网关实例。API 网关也需要进行内部负载均衡，将请求分发到后端的订单服务、支付服务、库存服务等实例。常用的负载均衡策略有轮询 (Round Robin)、加权轮询 (Weighted Round Robin)、最少连接 (Least Connections) 等。
3. 服务发现与注册：
在微服务架构中，服务实例的数量是动态变化的。为了实现服务之间的自动发现和调用，需要引入服务发现与注册机制。常用的服务发现与注册工具有 Consul, etcd, ZooKeeper, Eureka 等。服务启动时，将自己的地址注册到服务注册中心；服务调用时，从服务注册中心获取目标服务的地址列表。
4. 监控与告警：
完善的监控和告警系统是保障系统稳定运行的关键。需要监控以下指标：
① 服务性能指标 (Performance Metrics)：请求响应时间 (Latency)、吞吐量 (Throughput)、错误率 (Error Rate)、QPS (Queries Per Second) 等。可以使用 Prometheus, Grafana 等监控工具进行采集和展示。
② 资源使用率指标 (Resource Utilization Metrics)：CPU 使用率、内存使用率、磁盘 I/O、网络 I/O 等。可以使用 Prometheus, Grafana, Zabbix 等监控工具进行采集和展示。
③ 应用日志 (Application Logs)：收集和分析应用日志，用于故障排查和性能分析。可以使用 ELK Stack, Graylog 等日志系统。
④ 链路追踪 (Distributed Tracing)：在分布式系统中，请求链路可能跨越多个服务。链路追踪系统可以帮助我们分析请求的调用链，定位性能瓶颈和错误。常用的链路追踪工具有 Jaeger, Zipkin, SkyWalking 等。
当监控指标超过预设阈值时，需要及时发出告警，通知运维人员处理。告警方式可以包括邮件、短信、电话、Webhook 等。
5. 容错与熔断：
分布式系统容易出现各种故障，如网络抖动、服务超时、服务崩溃等。为了提高系统的容错能力，需要采取以下措施：
① 超时控制 (Timeout Control)：设置合理的请求超时时间，避免请求长时间阻塞。Thrift 客户端和服务端都支持设置超时时间。
② 重试机制 (Retry Mechanism)：对于瞬时错误，可以进行重试。但需要注意重试次数和退避策略，避免重试风暴。
③ 熔断器 (Circuit Breaker)：当某个服务出现大量错误时，熔断器会暂时切断对该服务的请求，避免雪崩效应。当服务恢复正常后，熔断器会自动恢复请求。可以使用 Folly 的 CircuitBreaker 组件或第三方熔断器库。
④ 限流 (Rate Limiting)：限制服务的请求速率，防止服务被过载。可以使用 Folly 的 RateLimiter 组件或 API 网关的限流功能。
⑤ 降级 (Degradation)：当系统资源紧张或依赖服务不可用时，可以采取降级策略，牺牲部分非核心功能，保证核心功能的可用性。
6. 安全性：
分布式系统的安全性至关重要。需要考虑以下安全措施：
① 身份认证 (Authentication)：验证客户端和服务端的身份，防止未授权访问。可以使用 Thrift 的认证机制或 OAuth 2.0, JWT 等认证协议。
② 授权 (Authorization)：控制用户对资源的访问权限。可以使用 RBAC (Role-Based Access Control) 或 ABAC (Attribute-Based Access Control) 等授权模型。
③ 数据加密 (Data Encryption)：对敏感数据进行加密存储和传输。可以使用 SSL/TLS 加密网络通信，对数据库中的敏感数据进行加密存储。
④ 安全审计 (Security Auditing)：记录用户的操作日志和安全事件，用于安全审计和风险分析。
7. 扩容与缩容：
根据业务负载的变化，需要能够动态地扩容和缩容服务实例。容器化部署和云平台部署可以方便地实现弹性伸缩。当系统负载增加时，自动增加服务实例；当系统负载降低时，自动减少服务实例。
8. 灾难恢复 (Disaster Recovery)：
为了应对极端情况，如机房故障、地震等，需要制定灾难恢复计划。包括数据备份与恢复、异地多活 (Active-Active) 部署、故障切换 (Failover) 演练等。
通过以上部署和运维考量，我们可以构建一个稳定、可靠、安全的高可用分布式订单处理系统。在实际项目中，部署和运维是一个持续优化的过程，需要根据实际情况不断调整和完善。
END_OF_CHAPTER
11. chapter 11： API参考与速查 (API Reference and Quick Lookup)
11.1 Folly常用API速查 (Folly Common API Quick Lookup)
本节旨在为开发者提供 Folly 库中常用 API 的快速参考，涵盖字符串处理、异步编程和并发执行等关键组件，助力开发者高效查阅和使用。
11.1.1 String与StringPiece API (String and StringPiece API)
StringPiece 和 FBString 是 Folly 库中用于高效字符串处理的核心组件。StringPiece 提供了对字符串的非拥有视图，避免了不必要的拷贝，而 FBString 则是 Folly 提供的定制化字符串类，针对性能进行了优化。
StringPiece 常用 API 速查:
① 构造函数 (Constructors)
⚝ StringPiece(): 默认构造函数，创建一个空的 StringPiece。
⚝ StringPiece(const char* str): 从 C 风格字符串构造 StringPiece。
⚝ StringPiece(const std::string& str): 从 std::string 构造 StringPiece。
⚝ StringPiece(const char* str, size_t len): 从字符数组和长度构造 StringPiece。
② 访问与检查 (Access and Inspection)
⚝ size() / length(): 返回 StringPiece 的长度。
⚝ empty(): 检查 StringPiece 是否为空。
⚝ data(): 返回指向 StringPiece 数据的指针。
⚝ operator[] (size_t pos): 访问指定位置的字符，不进行边界检查。
⚝ at(size_t pos): 访问指定位置的字符，进行边界检查。
⚝ front(): 返回第一个字符。
⚝ back(): 返回最后一个字符。
③ 字符串操作 (String Operations)
⚝ substr(size_t pos = 0, size_t n = npos): 返回一个新的 StringPiece，它是原 StringPiece 的子串。
⚝ remove_prefix(size_t n): 移除 StringPiece 的前 n 个字符。
⚝ remove_suffix(size_t n): 移除 StringPiece 的后 n 个字符。
⚝ starts_with(StringPiece prefix): 检查 StringPiece 是否以指定前缀开始。
⚝ ends_with(StringPiece suffix): 检查 StringPiece 是否以指定后缀结束。
⚝ contains(StringPiece needle): 检查 StringPiece 是否包含指定的子串。
⚝ find(StringPiece needle, size_t pos = 0): 从指定位置开始查找子串，返回子串起始位置，未找到返回 StringPiece::npos。
⚝ rfind(StringPiece needle, size_t pos = npos): 从指定位置开始逆向查找子串，返回子串起始位置，未找到返回 StringPiece::npos。
⚝ split(StringPiece delimiter, std::vector<StringPiece>& result): 根据分隔符分割 StringPiece，结果存储在 result 向量中。
④ 转换 (Conversion)
⚝ toString(): 转换为 std::string 对象。
⚝ toStdString(): 转换为 std::string 对象 (别名)。
⚝ toInt(), toUInt(), toLong(), toULong(), toDouble(): 将 StringPiece 转换为数值类型，失败抛出异常。
⚝ tryInt(), tryUInt(), tryLong(), tryULong(), tryDouble(): 尝试将 StringPiece 转换为数值类型，返回 folly::Optional，转换失败返回 folly::none。
FBString 常用 API 速查 (常用方法与 std::string 类似，此处列出部分 Folly 特有或常用的方法):
① 构造与赋值 (Construction and Assignment)
⚝ FBString(): 默认构造函数。
⚝ FBString(const StringPiece& sp): 从 StringPiece 构造 FBString。
⚝ operator=(const StringPiece& sp): 从 StringPiece 赋值。
② 容量与大小 (Capacity and Size)
⚝ capacity(): 返回当前分配的存储空间大小。
⚝ reserve(size_t n): 预留至少能容纳 n 个字符的空间。
⚝ shrink_to_fit(): 释放多余的容量。
③ 修改 (Modification)
⚝ append(StringPiece sp): 在字符串末尾追加 StringPiece。
⚝ assign(StringPiece sp): 替换字符串内容为 StringPiece。
⚝ insert(size_t pos, StringPiece sp): 在指定位置插入 StringPiece。
⚝ erase(size_t pos = 0, size_t n = npos): 删除指定位置开始的 n 个字符。
⚝ replace(size_t pos, size_t n, StringPiece sp): 替换指定位置开始的 n 个字符为 StringPiece。
④ 查找与比较 (Find and Compare)
⚝ find(StringPiece str, size_t pos = 0): 查找子串，返回起始位置，未找到返回 std::string::npos。
⚝ rfind(StringPiece str, size_t pos = npos): 逆向查找子串，返回起始位置，未找到返回 std::string::npos。
⚝ compare(StringPiece str): 与 StringPiece 比较大小。
⑤ Folly 特性 (Folly Specific Features)
⚝ toFBString(): 转换为 FBString 对象 (静态方法，用于从其他字符串类型转换)。
⚝ clone(): 创建字符串的深拷贝。
11.1.2 Futures与Promises API (Futures and Promises API)
Futures (期物) 和 Promises (承诺) 是 Folly 异步编程的核心，用于处理异步操作的结果。Futures 代表异步操作的最终结果，而 Promises 则用于设置 Future 的结果。
Future 常用 API 速查:
① 基本操作 (Basic Operations)
⚝ isReady(): 检查 Future 的结果是否已就绪。
⚝ wait(): 阻塞当前线程，直到 Future 的结果就绪。
⚝ value(): 获取 Future 的结果值，如果结果未就绪会抛出异常。
⚝ get(): 获取 Future 的结果值，与 value() 类似，但异常类型可能不同。
⚝ getTry(): 获取 folly::Try<T> 对象，包含结果或异常信息，不会抛出异常。
⚝ then(Func&& func): 当 Future 完成时，执行函数 func，并返回一个新的 Future，func 的返回值会被包装成 Future。
⚝ thenValue(Func&& func): 类似于 then，但只在 Future 成功完成时执行 func。
⚝ thenError(Func&& func): 类似于 then，但只在 Future 失败时执行 func。
⚝ onSuccess(Func&& func): 当 Future 成功完成时，执行函数 func，不影响 Future 链。
⚝ onError(Func&& func): 当 Future 失败时，执行函数 func，不影响 Future 链。
⚝ via(Executor* ex): 指定后续操作在哪个 Executor 上执行。
⚝ within(Duration duration): 设置 Future 的超时时间，超时会使 Future 变为失败状态。
⚝ fallbackTo(Future<T>&& fallback): 如果 Future 失败，则返回 fallback Future 的结果。
⚝ raise(exception_ptr eptr): 创建一个已失败的 Future，并设置异常。
⚝ unit(): 创建一个已成功完成的 Future，结果类型为 void。
⚝ value(T&& val): 创建一个已成功完成的 Future，并设置结果值。
⚝ exception(exception_ptr eptr): 创建一个已失败的 Future，并设置异常。
② 组合操作 (Combination Operations)
⚝ andThen(Future<U> (*func)(Try<T>&&)): 链式操作，前一个 Future 完成后，将结果传递给 func 生成新的 Future。
⚝ andThenValue(Future<U> (*func)(T&&)): 链式操作，前一个 Future 成功完成后，将结果值传递给 func 生成新的 Future。
⚝ andThenError(Future<U> (*func)(exception_ptr)): 链式操作，前一个 Future 失败后，将异常传递给 func 生成新的 Future。
⚝ collect(std::vector<Future<T>> futures): 将多个 Future 组合成一个新的 Future，当所有输入的 Futures 都成功完成时，新的 Future 成功完成，结果为包含所有结果值的 std::vector<T>。
⚝ collectAny(std::vector<Future<T>> futures): 将多个 Future 组合成一个新的 Future，当任何一个输入的 Future 完成时，新的 Future 完成，结果为第一个完成的 Future 的结果。
⚝ race(std::vector<Future<T>> futures): 与 collectAny 类似，但只返回第一个成功完成的 Future 的结果，如果第一个完成的是失败的 Future，则返回失败。
Promise 常用 API 速查:
① 基本操作 (Basic Operations)
⚝ getFuture(): 获取与 Promise 关联的 Future 对象。
⚝ setValue(T&& val): 设置 Promise 的结果值为 val，并使关联的 Future 成功完成。
⚝ setException(exception_ptr eptr): 设置 Promise 的异常，并使关联的 Future 失败。
⚝ setTry(Try<T>&& t): 设置 Promise 的结果为 folly::Try<T> 对象，可以是成功结果或异常。
⚝ setWith(Func&& func): 使用函数 func 的返回值设置 Promise 的结果，func 可以返回结果值或抛出异常。
⚝ setInterrupt(): 设置 Promise 为中断状态。
② 状态查询 (State Query)
⚝ isFulfilled(): 检查 Promise 是否已设置结果 (成功或失败)。
⚝ isCancelled(): 检查 Promise 是否已被取消。
11.1.3 Executors API (Executors API)
Executors (执行器) 是 Folly 提供的用于任务调度和并行执行的抽象，简化了多线程编程。通过 Executors，可以将任务提交到不同的执行策略中，例如线程池、单线程执行器等。
Executor 常用 API 速查 (基类 folly::Executor 为抽象类，常用其派生类):
① 提交任务 (Task Submission)
⚝ schedule(Func func): 提交一个函数 func 到 Executor 执行，返回 folly::Unit Future，表示任务提交成功。
⚝ add(Func func): 与 schedule 类似，提交一个函数 func 到 Executor 执行，无返回值。
② 派生类 (Derived Classes) - 常用实现
⚝ InlineExecutor: 在当前线程立即执行提交的任务，常用于测试或同步场景。
⚝ ThreadPoolExecutor: 使用线程池执行任务，可以配置线程池大小、队列类型等。
▮▮▮▮⚝ ThreadPoolExecutor(ThreadPoolExecutor::Options options): 构造函数，通过 Options 配置线程池。
▮▮▮▮⚝ setNumThreads(size_t n): 动态设置线程池大小。
⚝ IOThreadPoolExecutor: 专为 IO 密集型任务设计的线程池，通常与 Asio 结合使用。
▮▮▮▮⚝ IOThreadPoolExecutor(size_t numThreads): 构造函数，指定线程数。
▮▮▮▮⚝ getEventBase(): 获取与线程池关联的 EventBase 对象，用于 Asio 事件循环。
⚝ CPUThreadPoolExecutor: 专为 CPU 密集型任务设计的线程池，通常线程数与 CPU 核心数相近。
▮▮▮▮⚝ CPUThreadPoolExecutor(size_t numThreads): 构造函数，指定线程数。
⚝ VirtualExecutor: 虚拟执行器，用于在单线程环境中模拟多线程行为，方便测试和调试。
③ ExecutorService (执行器服务) - 生命周期管理
⚝ ExecutorService 是对 Executor 的封装，提供生命周期管理功能，例如启动和停止。
⚝ start(): 启动 ExecutorService。
⚝ stop(): 停止 ExecutorService，等待所有已提交任务完成。
⚝ getExecutor(): 获取 ExecutorService 管理的 Executor 对象。
11.2 Thrift IDL语法速查 (Thrift IDL Syntax Quick Lookup)
Thrift 接口定义语言 (IDL) 用于定义数据类型和服务接口，是 Thrift 跨语言通信的基础。本节提供 Thrift IDL 语法的快速参考。
① 数据类型 (Data Types)
⚝ 基本类型 (Base Types):
▮▮▮▮⚝ bool: 布尔型 (true 或 false)。
▮▮▮▮⚝ byte: 有符号字节。
▮▮▮▮⚝ i16: 16 位有符号整数。
▮▮▮▮⚝ i32: 32 位有符号整数。
▮▮▮▮⚝ i64: 64 位有符号整数。
▮▮▮▮⚝ double: 64 位浮点数。
▮▮▮▮⚝ string: 字符串 (UTF-8 编码)。
▮▮▮▮⚝ binary: 二进制数据。
⚝ 容器类型 (Container Types):
▮▮▮▮⚝ list<T>: 有序列表，元素类型为 T。
▮▮▮▮⚝ set<T>: 无序集合，元素类型为 T，元素唯一。
▮▮▮▮⚝ map<K, V>: 键值对映射，键类型为 K，值类型为 V。
⚝ 结构体 (Struct): struct StructName { ... }，定义复合数据类型，包含多个字段。
⚝ 枚举 (Enum): enum EnumName { ENUM_VALUE1, ENUM_VALUE2, ... }，定义枚举类型。
⚝ 联合体 (Union): union UnionName { ... }，定义联合体类型，类似于 C++ union，但 Thrift union 会跟踪当前设置的字段。
⚝ 异常 (Exception): exception ExceptionName { ... }，定义异常类型，用于服务方法抛出异常。
② 服务定义 (Service Definition)
⚝ service ServiceName { ... }，定义服务接口，包含多个方法。
⚝ 方法 (Function): ReturnType FunctionName(arg1: ArgType1, arg2: ArgType2, ...) throws (exception1: ExceptionType1, exception2: ExceptionType2);，定义服务方法，包括返回值类型、方法名、参数列表和可能抛出的异常。void 返回值表示无返回值。throws 子句声明方法可能抛出的异常。oneway 关键字表示单向调用，客户端不等待服务端响应。
③ 命名空间与包含 (Namespace and Include)
⚝ namespace language namespace_name: 定义命名空间，用于避免命名冲突，language 可以是 cpp, java, py, js 等。
⚝ include "path/to/other.thrift": 包含其他 Thrift 文件，用于模块化定义。
④ 注释与元数据 (Annotation and Metadata)
⚝ // 或 /* ... */: 单行和多行注释。
⚝ Annotations (注解): 使用 (key = "value", key2 = "value2") 语法为类型、字段、方法等添加元数据，用于代码生成或运行时处理。例如 (cpp.template = "std::vector")。
⑤ 类型别名与常量 (Type Alias and Constant)
⚝ typedef NewType OriginalType: 定义类型别名，简化类型名称。
⚝ const Type CONST_NAME = value: 定义常量。
11.3 Thrift C++ API速查 (Thrift C++ API Quick Lookup)
Thrift 编译器根据 IDL 文件生成 C++ 代码，本节提供常用 C++ API 的快速参考，主要关注客户端和服务端开发。
① 服务端 API (Server-side API)
⚝ 处理器 (Processor): YourServiceProcessor 类，处理客户端请求，需要继承并实现 IDL 中定义的服务接口。
▮▮▮▮⚝ YourServiceProcessor(std::shared_ptr<YourServiceInterface> handler): 构造函数，接受服务接口实现类的智能指针。
▮▮▮▮⚝ process(std::shared_ptr<TProtocol> in, std::shared_ptr<TProtocol> out, void* serverContext): 处理请求的核心方法，通常由 Thrift 框架调用，开发者无需直接调用。
⚝ 服务接口 (Service Interface): YourServiceInterface 接口类，定义了 IDL 中声明的服务方法，需要开发者实现。
▮▮▮▮⚝ virtual ReturnType FunctionName(ArgType1 arg1, ArgType2 arg2) = 0: 纯虚函数，需要子类实现。
⚝ 服务端传输 (Server Transport):
▮▮▮▮⚝ TServerSocket: TCP socket 服务端传输，监听端口，接受客户端连接。
▮▮▮▮⚝ TNonblockingServerSocket: 非阻塞 TCP socket 服务端传输。
▮▮▮▮⚝ THttpServer: HTTP 服务端传输。
⚝ 服务端协议 (Server Protocol): 与客户端协议一致，例如 TBinaryProtocolFactory, TCompactProtocolFactory, TJSONProtocolFactory。
⚝ TSimpleServer: 单线程阻塞式服务端。
⚝ TThreadedServer: 多线程阻塞式服务端，每个连接一个线程。
⚝ TThreadPoolServer: 线程池服务端，使用线程池处理连接。
⚝ TNonblockingServer: 非阻塞服务端，基于事件驱动。
② 客户端 API (Client-side API)
⚝ 客户端类 (Client Class): YourServiceClient 类，用于调用服务端方法。
▮▮▮▮⚝ YourServiceClient(std::shared_ptr<TProtocol> prot): 构造函数，接受协议对象。
▮▮▮▮⚝ YourServiceClient(std::shared_ptr<TProtocol> iprot, std::shared_ptr<TProtocol> oprot): 构造函数，接受输入和输出协议对象 (用于双向协议)。
▮▮▮▮⚝ ReturnType FunctionName(ArgType1 arg1, ArgType2 arg2): 调用服务端方法的客户端方法，与 IDL 中定义的方法签名一致。
⚝ 客户端传输 (Client Transport):
▮▮▮▮⚝ TSocket: TCP socket 客户端传输，连接服务端。
▮▮▮▮⚝ TBufferedTransport: 缓冲传输，提高性能。
▮▮▮▮⚝ TFramedTransport: 分帧传输，用于某些协议或场景。
▮▮▮▮⚝ THttpClient: HTTP 客户端传输。
⚝ 客户端协议 (Client Protocol):
▮▮▮▮⚝ TBinaryProtocol: 二进制协议。
▮▮▮▮⚝ TCompactProtocol: 压缩协议。
▮▮▮▮⚝ TJSONProtocol: JSON 协议。
▮▮▮▮⚝ TProtocolFactory: 协议工厂类，用于创建协议对象，例如 TBinaryProtocolFactoryT<TBufferedTransportFactory>.
③ 通用工具类 (Common Utility Classes)
⚝ apache::thrift::TException: Thrift 异常基类。
⚝ apache::thrift::transport::TTransportException: 传输层异常。
⚝ apache::thrift::protocol::TProtocolException: 协议层异常。
⚝ apache::thrift::stdcxx::shared_ptr (deprecated, use std::shared_ptr): 智能指针。
END_OF_CHAPTER
12. chapter 12： 未来展望：Folly与Thrift的演进 (Future Outlook: Evolution of Folly and Thrift)
12.1 C++标准发展趋势对Folly的影响 (Impact of C++ Standard Development Trends on Folly)
随着 C++ 标准的不断演进，特别是 C++11、C++14、C++17、C++20 乃至更新标准的陆续推出，现代 C++ 语言变得更加强大和高效。这些标准的新特性深刻地影响着包括 Folly 在内的现代 C++ 库的设计与发展。Folly 作为 Meta 开源的高性能 C++ 库，紧密拥抱并积极利用最新的 C++ 标准特性，以持续提升其性能、易用性和现代化水平。
① 模块化 (Modules)：C++20 引入的模块化系统旨在解决传统头文件包含机制带来的编译耗时和命名空间污染问题。Folly 可能会逐步采用 C++ 模块，以改善其构建效率和代码组织结构。模块化能够让 Folly 的组件更加独立，减少编译依赖，提升大型项目的编译速度。
② 协程 (Coroutines)：C++20 标准化了协程，为异步编程提供了更简洁、更高效的解决方案。Folly 已经广泛使用了 Futures/Promises 进行异步编程，而协程的引入为 Folly 提供了新的异步编程范式选择。未来，Folly 可能会更深入地整合 C++ 协程，例如，基于协程构建更易于使用的异步网络 API，或者优化现有异步组件的实现。
③ 概念 (Concepts)：C++20 的 Concepts 提供了强大的泛型编程约束能力，可以改善模板代码的错误诊断信息，并提升代码的可读性和安全性。Folly 可以利用 Concepts 来增强其模板组件的接口设计，提供更清晰的类型约束，并在编译时捕获更多错误，从而提高库的健壮性。
④ 范围 (Ranges)：C++20 Ranges 库提供了一种新的处理数据范围的方式，使得算法可以更加灵活和高效地应用于各种数据结构。Folly 的容器和算法可以考虑与 Ranges 库进行整合，以提供更现代、更强大的数据处理能力。例如，可以利用 Ranges 改进 Folly 的 FBVector 和 F14Map 等容器的算法接口。
⑤ 反射 (Reflection)：C++ 标准在反射方面仍在发展中，但未来的标准化反射机制将极大地增强 C++ 的元编程能力。如果 C++ 反射成熟，Folly 可以利用它来简化代码生成、序列化、以及其他需要运行时类型信息的操作。例如，Thrift 的序列化和反序列化过程可以借助反射技术进行优化。
⑥ 并行与并发 (Parallelism and Concurrency)：C++ 标准持续在并行和并发方面进行改进，例如，std::execution::parallel_policy 和并发原子操作的增强。Folly 已经提供了强大的并发工具，如 Executors 和 ConcurrentHashMap。未来，Folly 可以进一步利用 C++ 标准的并行特性，例如，使用标准并行算法来优化数据处理性能，或者利用新的原子操作来构建更高效的并发数据结构。
⑦ 标准库的增强 (Standard Library Enhancements)：C++ 标准库不断扩展和完善，提供了更多功能强大的工具和组件。Folly 需要持续关注 C++ 标准库的更新，并尽可能地利用标准库提供的功能，减少重复造轮子，并保持与 C++ 标准的同步发展。例如，如果 C++ 标准库提供了高性能的字符串处理或容器，Folly 可以考虑采用标准库组件，或者与标准库组件进行互操作。
总而言之，C++ 标准的发展趋势对 Folly 产生了深远的影响。Folly 作为一个前沿的 C++ 库，将继续积极拥抱和利用最新的 C++ 标准特性，不断改进和完善自身，以满足现代 C++ 应用开发的需求。这意味着 Folly 将会变得更加模块化、更易于异步编程、具有更强大的泛型能力、更高效的数据处理能力，并与 C++ 标准库更好地融合。
12.2 Thrift在云原生时代的机遇与挑战 (Opportunities and Challenges of Thrift in the Cloud-Native Era)
云原生 (Cloud-Native) 架构的兴起为 Thrift 带来了新的机遇，同时也提出了严峻的挑战。Thrift 作为一种成熟的跨语言 RPC (Remote Procedure Call，远程过程调用) 框架，在云原生环境中依然具有重要的价值，但需要进行适应性调整以更好地融入云原生生态。
① 机遇 (Opportunities)：
① 服务网格 (Service Mesh) 的集成：云原生架构中，服务网格如 Istio、Envoy 等逐渐成为服务间通信的主流方式。Thrift 可以与服务网格进行深度集成，利用服务网格提供的流量管理、安全、可观测性等能力。例如，可以将 Thrift 服务暴露为服务网格中的服务，通过服务网格进行路由、负载均衡和策略控制。服务网格的 sidecar 模式可以很好地与 Thrift 的客户端和服务端集成，实现透明的流量拦截和管理。
② 多语言微服务架构 (Multi-Language Microservices Architecture)：云原生提倡微服务架构，而微服务架构往往采用多语言技术栈。Thrift 的跨语言特性使其在多语言微服务环境中具有天然优势。不同的微服务可以使用最适合自身业务场景的语言进行开发，而 Thrift 负责实现服务之间的跨语言通信。这使得技术选型更加灵活，并能充分利用各种语言的生态和优势。
③ gRPC 的竞争与互补 (Competition and Complementarity with gRPC)：gRPC 是 Google 推出的云原生 RPC 框架，在云原生领域具有很高的影响力。Thrift 与 gRPC 存在竞争关系，但也存在互补性。gRPC 基于 HTTP/2 和 Protocol Buffers，在性能和效率方面有优势，尤其是在云原生环境中。Thrift 则具有更广泛的语言支持和更灵活的协议选择。在某些场景下，Thrift 的灵活性和成熟度仍然是重要的优势。未来，Thrift 可以考虑与 gRPC 进行互操作，例如，提供 Thrift 到 gRPC 的协议转换，或者支持 gRPC 的传输层。
④ Serverless 计算 (Serverless Computing)：Serverless 计算是云原生架构的重要组成部分。Thrift 可以应用于 Serverless 函数之间的通信，或者作为 Serverless 函数对外提供服务的接口。Thrift 的轻量级和高效性使其适合在 Serverless 环境中使用。例如，可以使用 Thrift 定义 Serverless 函数的接口，并使用 Thrift 的多种协议和传输层来优化性能和资源利用率。
② 挑战 (Challenges)：
① 云原生标准的适应性 (Adaptability to Cloud-Native Standards)：云原生生态系统涌现出大量的标准和规范，例如，容器化 (Containerization)、Kubernetes 编排、Prometheus 监控、OpenTelemetry 追踪等。Thrift 需要更好地适应这些云原生标准，例如，提供对 Kubernetes 的原生支持，支持 Prometheus 和 OpenTelemetry 的监控和追踪，以及与云原生配置管理和安全工具的集成。
② HTTP/2 和 QUIC 的支持 (Support for HTTP/2 and QUIC)：HTTP/2 和 QUIC 是下一代网络协议，在性能、安全性和可靠性方面具有显著优势，尤其是在云原生环境中。gRPC 默认使用 HTTP/2。Thrift 需要加强对 HTTP/2 和 QUIC 的支持，以提升其在云原生环境中的性能和竞争力。例如，可以开发基于 HTTP/2 和 QUIC 的 Thrift 传输层，或者优化现有 HTTP 传输层的性能。
③ 协议的现代化 (Protocol Modernization)：Thrift 的 Binary Protocol 和 Compact Protocol 虽然高效，但在可读性和可调试性方面不如 JSON Protocol。在云原生环境中，可观测性和易用性变得越来越重要。Thrift 需要考虑协议的现代化，例如，开发更易于理解和调试的协议，或者提供协议转换和代理机制，以便在不同的场景下选择合适的协议。
④ 社区生态的建设 (Community Ecosystem Building)：云原生生态系统非常活跃，拥有庞大的社区和丰富的工具链。Thrift 需要加强社区生态建设，吸引更多的开发者和贡献者，并与云原生社区进行更紧密的合作。例如，可以积极参与云原生基金会 (CNCF) 的活动，与其他云原生项目进行集成，并提供更完善的文档、示例和工具。
总而言之，Thrift 在云原生时代面临着机遇与挑战并存的局面。为了更好地适应云原生环境，Thrift 需要积极拥抱云原生技术和标准，加强与云原生生态系统的集成，提升自身的性能、可观测性和易用性，并持续建设和壮大社区生态。只有这样，Thrift 才能在云原生时代继续保持其生命力和竞争力，并为构建现代分布式系统发挥重要作用。
12.3 Folly与Thrift社区动态与发展方向 (Folly and Thrift Community Dynamics and Development Directions)
Folly 和 Thrift 都是由 Meta (原 Facebook) 开源的成熟项目，拥有活跃的社区和持续的发展。了解 Folly 和 Thrift 社区的动态和发展方向，有助于我们更好地把握这两个项目的未来趋势，并更好地利用它们来构建现代软件系统。
① Folly 社区动态与发展方向 (Folly Community Dynamics and Development Directions)：
① 持续拥抱 C++ 标准 (Continuous Adoption of C++ Standards)：Folly 社区始终走在 C++ 标准的前沿，积极采纳最新的 C++ 标准特性。未来，Folly 将继续关注 C++ 标准的演进，并及时将新的语言特性和库特性融入到 Folly 的开发中，以提升 Folly 的现代化水平和性能。
② 关注性能优化与工程效率 (Focus on Performance Optimization and Engineering Efficiency)：Folly 的设计目标之一是提供高性能的 C++ 基础设施。Folly 社区将持续关注性能优化，通过算法优化、代码重构、以及利用硬件特性等手段，不断提升 Folly 各个组件的性能。同时，Folly 社区也注重提升工程效率，通过改进构建系统、提供更好的工具和文档、以及简化 API 设计等方式，降低 Folly 的使用门槛，提高开发效率。
③ 模块化与组件化 (Modularization and Componentization)：为了更好地管理和维护 Folly 庞大的代码库，并降低用户的使用成本，Folly 社区可能会进一步推进模块化和组件化。将 Folly 拆分成更小的、更独立的模块，可以减少编译依赖，提高构建速度，并允许用户按需选择和使用 Folly 的组件。
④ 与第三方库的集成 (Integration with Third-Party Libraries)：Folly 社区积极与其他开源社区进行合作，将 Folly 与其他优秀的第三方库进行集成。例如，Folly 已经与 Boost、gRPC、OpenSSL 等库进行了集成。未来，Folly 可能会继续扩展其集成范围，与更多优秀的库进行合作，以提供更丰富的功能和更强大的生态系统。
⑤ 社区共建与开放治理 (Community Co-building and Open Governance)：Folly 社区鼓励社区成员积极参与项目的开发和维护。Folly 采用开放的治理模式，接受社区贡献的代码和建议，并定期发布版本更新。未来，Folly 社区可能会进一步加强社区共建，吸引更多的开发者和贡献者，共同推动 Folly 的发展。
② Thrift 社区动态与发展方向 (Thrift Community Dynamics and Development Directions)：
① 云原生方向的演进 (Evolution in the Cloud-Native Direction)：Thrift 社区正在积极探索 Thrift 在云原生环境中的应用和发展方向。例如，Thrift 社区正在加强 Thrift 与 Kubernetes、服务网格等云原生技术的集成，并考虑支持 HTTP/2 和 QUIC 等云原生协议。未来，Thrift 可能会更加深入地融入云原生生态系统，成为云原生微服务架构的重要组成部分。
② 协议与传输层的现代化 (Modernization of Protocols and Transports)：为了适应云原生环境的需求，并提升 Thrift 的性能和易用性，Thrift 社区可能会对 Thrift 的协议和传输层进行现代化改造。例如，可以开发基于 HTTP/2 和 QUIC 的 Thrift 传输层，或者设计更易于理解和调试的新协议。
③ 语言支持的扩展与维护 (Expansion and Maintenance of Language Support)：Thrift 具有广泛的语言支持，这是其重要的优势之一。Thrift 社区将继续维护和更新现有语言的 Thrift 库，并可能会根据社区需求和技术发展趋势，扩展 Thrift 的语言支持范围，例如，支持新兴的编程语言或平台。
④ 性能优化与功能增强 (Performance Optimization and Feature Enhancement)：Thrift 社区持续关注 Thrift 的性能优化，通过改进代码生成、优化运行时库、以及利用新的硬件特性等手段，不断提升 Thrift 的性能。同时，Thrift 社区也积极采纳社区的建议和需求，增强 Thrift 的功能，例如，增加新的中间件、拦截器、服务治理功能等。
⑤ 社区合作与生态建设 (Community Collaboration and Ecosystem Building)：Thrift 社区鼓励社区成员积极参与项目的开发和维护，并与其他开源社区进行合作。例如，Thrift 社区可以与 gRPC 社区进行合作，探索 Thrift 与 gRPC 的互操作性。未来，Thrift 社区可能会进一步加强社区合作，共同建设 Thrift 的生态系统，提升 Thrift 的影响力和竞争力。
总而言之，Folly 和 Thrift 社区都非常活跃，并保持着健康的发展态势。Folly 社区致力于打造高性能、现代化的 C++ 基础设施，而 Thrift 社区则积极拥抱云原生，并不断提升 Thrift 的性能、功能和易用性。关注 Folly 和 Thrift 社区的动态和发展方向，可以帮助我们更好地理解这两个项目的未来趋势，并更好地利用它们来构建下一代软件系统。
A. 常用工具与资源 (Common Tools and Resources)
为了方便读者学习和使用 Folly 与 Thrift，本附录汇总了一些常用的工具和资源，包括官方文档、社区论坛、代码仓库、以及一些实用的第三方工具。
① 官方文档 (Official Documentation)：
① Folly 官方文档：https://github.com/facebook/folly/tree/main/folly/docs
▮▮▮▮⚝ Folly 的官方文档提供了全面的库参考、使用指南和设计文档。是学习 Folly 最权威的资料来源。
② Thrift 官方文档：https://thrift.apache.org/docs/
▮▮▮▮⚝ Thrift 的官方文档详细介绍了 Thrift 的 IDL 语法、代码生成、协议、传输层以及各种语言的库的使用方法。是学习 Thrift 的必备资料。
② 代码仓库 (Code Repositories)：
① Folly GitHub 仓库：https://github.com/facebook/folly
▮▮▮▮⚝ Folly 的源代码仓库，包含了 Folly 的所有组件的实现代码、示例代码和测试代码。可以通过阅读源代码深入理解 Folly 的设计和实现。
② Thrift GitHub 仓库：https://github.com/apache/thrift
▮▮▮▮⚝ Thrift 的源代码仓库，包含了 Thrift 编译器、各种语言的运行时库、以及示例代码和测试代码。
③ 社区论坛与邮件列表 (Community Forums and Mailing Lists)：
① Folly GitHub Issues：https://github.com/facebook/folly/issues
▮▮▮▮⚝ Folly 的 GitHub Issues 页面是提问、报告 Bug 和参与讨论的重要场所。可以在这里寻求帮助，或者与其他 Folly 用户和开发者交流。
② Thrift 邮件列表：https://thrift.apache.org/mailing_lists.html
▮▮▮▮⚝ Thrift 官方提供了多个邮件列表，包括用户邮件列表和开发者邮件列表。可以通过邮件列表与其他 Thrift 用户和开发者交流，获取帮助和参与社区讨论。
③ 在线教程与博客 (Online Tutorials and Blogs)：
① Folly 教程：
▮▮▮▮⚝ 网上有很多关于 Folly 的教程和博客文章，可以帮助初学者快速入门 Folly。例如，可以搜索 "Folly tutorial" 或 "Folly C++" 等关键词。
② Thrift 教程：
▮▮▮▮⚝ 网上也有大量的 Thrift 教程和博客文章，涵盖了 Thrift 的各个方面，从 IDL 语法到代码生成，再到各种语言的使用。例如，可以搜索 "Thrift tutorial" 或 "Thrift example" 等关键词。
④ 实用工具 (Useful Tools)：
① Thrift 编译器 (thrift)：
▮▮▮▮⚝ Thrift 编译器是 Thrift 工具链的核心组件，用于将 Thrift IDL 文件编译成各种语言的代码。可以从 Thrift 官方仓库下载预编译的二进制文件，或者自行编译。
② CMake：
▮▮▮▮⚝ CMake 是一个跨平台的构建系统，Folly 和 Thrift 都使用 CMake 进行构建。需要安装 CMake 才能编译 Folly 和 Thrift。
③ g++ 或 clang++：
▮▮▮▮⚝ Folly 和 Thrift 主要使用 C++ 开发，需要安装 C++ 编译器，如 g++ 或 clang++。建议使用较新版本的编译器，以支持最新的 C++ 标准特性。
④ Python (for Thrift)：
▮▮▮▮⚝ Thrift 的代码生成工具和部分测试脚本使用 Python 编写，需要安装 Python 才能完整使用 Thrift 的工具链。
⑤ Docker：
▮▮▮▮⚝ Docker 可以用于快速搭建 Folly 和 Thrift 的开发环境，或者用于部署基于 Folly 和 Thrift 的应用。网上有很多 Docker 镜像可以参考。
⑥ 性能分析工具 (Profiling Tools)：
▮▮▮▮⚝ 为了进行性能分析和调优，可以使用各种性能分析工具，如 gprof、perf、火焰图 (Flame Graph) 等。Folly 也提供了一些性能分析工具，如 Folly Benchmark。
希望以上工具和资源能够帮助读者更好地学习和使用 Folly 与 Thrift。随着技术的不断发展，新的工具和资源也会不断涌现。建议读者保持关注 Folly 和 Thrift 社区的动态，及时获取最新的信息。
B. 术语表 (Glossary)
本术语表收录了本书中出现的一些重要术语，并提供简要的解释，以帮助读者更好地理解 Folly 与 Thrift 的相关概念。
| 术语 (中文) | 术语 (英文) | 解释 |
|---|---|---|
| 异步编程 | Asynchronous Programming | 一种并发编程模式，允许程序在等待耗时操作完成时继续执行其他任务，从而提高程序的响应性和吞吐量。 |
| 原子操作 | Atomic Operation | 不可中断的操作，要么完全执行，要么完全不执行，保证操作的完整性和线程安全。 |
| 缓冲传输 | Buffered Transport | 一种 Thrift 传输层，在内存中缓存数据，减少网络 I/O 次数，提高传输效率。 |
| 协程 | Coroutine | 一种轻量级的并发编程机制，允许函数在执行过程中暂停和恢复，实现非抢占式的并发。 |
| 代码生成 | Code Generation | 通过编译器或工具，根据某种定义（如 IDL）自动生成代码的过程，提高开发效率和代码一致性。 |
| 并发 | Concurrency | 程序同时处理多个任务的能力，可以通过多线程、多进程或异步编程等方式实现。 |
| 并行 | Parallelism | 程序同时执行多个任务的能力，通常需要多核处理器或分布式系统支持。 |
| 容器化 | Containerization | 将应用程序及其依赖项打包成容器镜像的技术，实现应用程序的隔离性和可移植性。 |
| 分布式系统 | Distributed System | 由多台计算机组成的系统，这些计算机通过网络互相通信和协作，共同完成任务。 |
| 分帧传输 | Framed Transport | 一种 Thrift 传输层，将数据分割成帧进行传输，方便数据流的控制和管理。 |
| Future/Promise | Future/Promise | 一种异步编程模型，用于表示异步操作的结果，Future 代表未来结果的占位符，Promise 用于设置 Future 的结果。 |
| IDL (接口定义语言) | Interface Definition Language | 用于描述软件组件接口的语言，Thrift IDL 用于定义服务接口和数据结构。 |
| IO 模型 | IO Model | 操作系统提供的处理输入输出的方式，如阻塞 IO、非阻塞 IO、IO 多路复用等。 |
| JSON 协议 | JSON Protocol | 一种 Thrift 协议，使用 JSON 格式进行数据序列化和反序列化，可读性好，但性能相对较低。 |
| Kubernetes | Kubernetes | 一个开源的容器编排平台，用于自动化部署、扩展和管理容器化应用程序。 |
| 负载均衡 | Load Balancing | 将请求分发到多个服务器上，以提高系统的可用性和性能。 |
| 熔断 | Circuit Breaking | 一种服务治理策略，当某个服务出现故障时，快速失败并阻止请求继续访问该服务，避免雪崩效应。 |
| 命名空间 | Namespace | 用于组织和隔离代码的机制，避免命名冲突，提高代码可维护性。 |
| 协议 | Protocol | 通信双方约定的数据交换格式和规则，Thrift 协议定义了数据的序列化方式。 |
| 远程过程调用 (RPC) | Remote Procedure Call | 允许程序调用另一台计算机上的函数或方法的技术，Thrift 是一个 RPC 框架。 |
| 限流 | Rate Limiting | 一种服务治理策略，限制单位时间内请求的速率，防止系统过载。 |
| 服务治理 | Service Governance | 对微服务进行管理和控制的一系列措施，包括负载均衡、熔断、限流、监控等。 |
| 服务网格 | Service Mesh | 一种专门用于处理服务间通信的基础设施层，提供流量管理、安全、可观测性等功能。 |
| 套接字 | Socket | 网络编程中用于进程间通信的接口，TCP 套接字用于 TCP 协议的通信。 |
| TCP (传输控制协议) | Transmission Control Protocol | 一种面向连接的、可靠的、基于字节流的传输层协议。 |
| Thrift 编译器 | Thrift Compiler | 用于将 Thrift IDL 文件编译成各种语言代码的工具。 |
| Thrift 协议 | Thrift Protocol | Thrift 框架定义的数据序列化协议，包括 Binary Protocol、Compact Protocol、JSON Protocol 等。 |
| Thrift 传输层 | Thrift Transport | Thrift 框架定义的网络传输层，负责数据的网络传输，包括 TSocket、TBufferedTransport、TFramedTransport 等。 |
| 时间轮 | Time Wheel | 一种高效的定时器实现，用于管理大量的定时任务。 |
| 传输层 | Transport Layer | 网络协议栈中的一层，负责提供端到端的可靠或不可靠的数据传输服务。 |
| 云原生 | Cloud-Native | 一种构建和运行在云环境中的应用程序的方法论，强调容器化、微服务、DevOps 和自动化。 |
| 元数据 | Metadata | 描述数据的数据，用于提供关于数据的额外信息，Thrift IDL 注释可以作为元数据使用。 |
C. 参考文献 (References)
本参考文献列表收录了本书编写过程中参考的一些重要文献和资料，供读者进一步学习和研究。
① Folly 官方仓库与文档：
① Folly GitHub Repository: https://github.com/facebook/folly
② Folly Documentation: https://github.com/facebook/folly/tree/main/folly/docs
② Thrift 官方仓库与文档：
① Thrift Apache Repository: https://github.com/apache/thrift
② Thrift Documentation: https://thrift.apache.org/docs/
③ C++ 标准与相关资料：
① cppreference.com: https://en.cppreference.com/w/
▮▮▮▮⚝ C++ 标准库的在线参考文档，包含了 C++ 标准的详细信息和示例代码。
② ISO C++ Standard: https://isocpp.org/std/the-standard
▮▮▮▮⚝ ISO C++ 标准的官方网站，可以获取最新的 C++ 标准文档。
③ Effective Modern C++: Scott Meyers, O'Reilly Media, 2014.
▮▮▮▮⚝ 一本经典的现代 C++ 编程书籍，深入讲解了 C++11 和 C++14 的新特性和最佳实践。
④ 书籍与文章：
① 《深入理解计算机系统 (深入理解CSAPP)》 (Computer Systems: A Programmer's Perspective): Randal E. Bryant, David R. O'Hallaron, 机械工业出版社.
▮▮▮▮⚝ 计算机系统领域的经典教材，深入讲解了计算机系统的底层原理，包括硬件、操作系统、网络等。
② 《UNIX网络编程 卷1: 套接字联网API》 (UNIX Network Programming, Volume 1: The Sockets Networking API): W. Richard Stevens, Bill Fenner, Andrew M. Rudoff, 机械工业出版社.
▮▮▮▮⚝ 网络编程领域的经典著作，详细讲解了 UNIX 环境下的套接字编程 API 和网络协议。
③ 《Effective C++》: Scott Meyers, Addison-Wesley Professional, 1997.
▮▮▮▮⚝ C++ 编程的经典书籍，提供了大量的 C++ 编程最佳实践和技巧。
④ 《More Effective C++》: Scott Meyers, Addison-Wesley Professional, 1995.
▮▮▮▮⚝ 《Effective C++》的续作，进一步深入探讨了 C++ 编程的高级主题。
⑤ 《高性能MySQL》 (High Performance MySQL): Baron Schwartz, Peter Zaitsev, Vadim Tkachenko, O'Reilly Media.
▮▮▮▮⚝ MySQL 性能优化方面的权威指南，虽然主题是 MySQL，但其中很多性能优化的思想和方法也适用于其他系统。
⑥ Google gRPC 官方文档: https://grpc.io/docs/
▮▮▮▮⚝ gRPC 官方文档，可以了解 gRPC 的原理、使用方法和最佳实践。
⑦ Istio 官方文档: https://istio.io/latest/docs/
▮▮▮▮⚝ Istio 官方文档，可以了解服务网格 Istio 的架构、功能和使用方法。
⑧ 云原生计算基金会 (CNCF): https://www.cncf.io/
▮▮▮▮⚝ 云原生计算基金会的官方网站，可以了解云原生领域的最新技术和趋势。
希望以上参考文献能够为读者提供更深入的学习资源，帮助读者更全面地理解 Folly 与 Thrift，以及相关的 C++ 技术和云原生技术。
END_OF_CHAPTER