023 《深入探索 folly/Synchronized.h：并发编程的基石 (In-depth Exploration of folly/Synchronized.h: The Cornerstone of Concurrent Programming)》
🌟🌟🌟本文案由Gemini 2.0 Flash Thinking Experimental 01-21创作，用来辅助学习知识。🌟🌟🌟
书籍大纲
▮▮▮▮ 1. chapter 1：并发编程基础 (Fundamentals of Concurrent Programming)
▮▮▮▮▮▮▮ 1.1 为什么需要并发？(Why Concurrency?)
▮▮▮▮▮▮▮ 1.2 并发与并行 (Concurrency vs. Parallelism)
▮▮▮▮▮▮▮ 1.3 线程、进程和协程 (Threads, Processes, and Coroutines)
▮▮▮▮▮▮▮ 1.4 竞态条件与数据竞争 (Race Conditions and Data Races)
▮▮▮▮▮▮▮▮▮▮▮ 1.4.1 临界区 (Critical Sections)
▮▮▮▮▮▮▮▮▮▮▮ 1.4.2 原子操作 (Atomic Operations)
▮▮▮▮▮▮▮▮▮▮▮ 1.4.3 内存模型与顺序一致性 (Memory Model and Sequential Consistency)
▮▮▮▮ 2. chapter 2：Folly 库与 Synchronized.h 概览 (Overview of Folly Library and Synchronized.h)
▮▮▮▮▮▮▮ 2.1 Folly 库简介 (Introduction to Folly Library)
▮▮▮▮▮▮▮ 2.2 Synchronized.h 的作用与定位 (Role and Positioning of Synchronized.h)
▮▮▮▮▮▮▮ 2.3 Synchronized.h 的设计哲学 (Design Philosophy of Synchronized.h)
▮▮▮▮▮▮▮ 2.4 为什么选择 Synchronized.h？(Why Choose Synchronized.h?)
▮▮▮▮ 3. chapter 3：Synchronized 的基础使用 (Basic Usage of Synchronized)
▮▮▮▮▮▮▮ 3.1 Synchronized 类模板详解 (Detailed Explanation of Synchronized Class Template)
▮▮▮▮▮▮▮ 3.2 互斥锁 (Mutex) 的概念与应用 (Concept and Application of Mutex)
▮▮▮▮▮▮▮ 3.3 使用 Synchronized 保护共享数据 (Protecting Shared Data with Synchronized)
▮▮▮▮▮▮▮ 3.4 RAII 与锁的自动管理 (RAII and Automatic Lock Management)
▮▮▮▮▮▮▮▮▮▮▮ 3.4.1 lock() 和 unlock() 方法 (The lock() and unlock() Methods)
▮▮▮▮▮▮▮▮▮▮▮ 3.4.2 构造函数与析构函数 (Constructors and Destructors)
▮▮▮▮▮▮▮ 3.5 代码示例：线程安全的计数器 (Code Example: Thread-Safe Counter)
▮▮▮▮ 4. chapter 4：Synchronized 的高级特性与变体 (Advanced Features and Variants of Synchronized)
▮▮▮▮▮▮▮ 4.1 共享互斥锁 (Shared Mutex) 与 ReadWriteMutex (Shared Mutex and ReadWriteMutex)
▮▮▮▮▮▮▮▮▮▮▮ 4.1.1 读写锁的概念 (Concept of Read-Write Locks)
▮▮▮▮▮▮▮▮▮▮▮ 4.1.2 ReadWriteMutex 的使用场景 (Use Cases of ReadWriteMutex)
▮▮▮▮▮▮▮ 4.2 尝试锁 (Try Lock) 与超时机制 (Try Lock and Timeout Mechanism)
▮▮▮▮▮▮▮▮▮▮▮ 4.2.1 try_lock() 方法 (The try_lock() Method)
▮▮▮▮▮▮▮▮▮▮▮ 4.2.2 超时锁定的应用 (Applications of Timeout Locking)
▮▮▮▮▮▮▮ 4.3 条件变量 (Condition Variable) 与等待/通知机制 (Wait/Notify Mechanism)
▮▮▮▮▮▮▮▮▮▮▮ 4.3.1 wait()，notify_one() 和 notify_all() 方法 (The wait(), notify_one(), and notify_all() Methods)
▮▮▮▮▮▮▮▮▮▮▮ 4.3.2 构建复杂的同步模式 (Building Complex Synchronization Patterns)
▮▮▮▮ 5. chapter 5：Synchronized 的 API 全面解析 (Comprehensive API Analysis of Synchronized)
▮▮▮▮▮▮▮ 5.1 Synchronized 类模板的详细 API (Detailed API of Synchronized Class Template)
▮▮▮▮▮▮▮ 5.2 ReadWriteMutex 类模板的详细 API (Detailed API of ReadWriteMutex Class Template)
▮▮▮▮▮▮▮ 5.3 相关辅助函数与类型 (Related Helper Functions and Types)
▮▮▮▮▮▮▮ 5.4 API 使用注意事项与最佳实践 (API Usage Precautions and Best Practices)
▮▮▮▮ 6. chapter 6：实战案例分析 (Practical Case Study Analysis)
▮▮▮▮▮▮▮ 6.1 案例一：线程安全的队列实现 (Case Study 1: Thread-Safe Queue Implementation)
▮▮▮▮▮▮▮ 6.2 案例二：使用 ReadWriteMutex 优化缓存系统 (Case Study 2: Optimizing Cache System with ReadWriteMutex)
▮▮▮▮▮▮▮ 6.3 案例三：基于条件变量的生产者-消费者模型 (Case Study 3: Producer-Consumer Model Based on Condition Variable)
▮▮▮▮▮▮▮ 6.4 案例四：复杂并发场景下的 Synchronized 应用 (Case Study 4: Synchronized Application in Complex Concurrent Scenarios)
▮▮▮▮ 7. chapter 7：性能考量与最佳实践 (Performance Considerations and Best Practices)
▮▮▮▮▮▮▮ 7.1 锁的性能开销分析 (Performance Overhead Analysis of Locks)
▮▮▮▮▮▮▮ 7.2 减少锁竞争的方法 (Methods to Reduce Lock Contention)
▮▮▮▮▮▮▮ 7.3 死锁与活锁的预防与避免 (Prevention and Avoidance of Deadlocks and Livelocks)
▮▮▮▮▮▮▮ 7.4 Synchronized 的性能优化技巧 (Performance Optimization Techniques for Synchronized)
▮▮▮▮ 8. chapter 8：Synchronized 与其他同步机制的比较 (Comparison of Synchronized with Other Synchronization Mechanisms)
▮▮▮▮▮▮▮ 8.1 与 std::mutex, std::shared_mutex 的对比 (Comparison with std::mutex, std::shared_mutex)
▮▮▮▮▮▮▮ 8.2 与 std::atomic 的选择 (Choosing between Synchronized and std::atomic)
▮▮▮▮▮▮▮ 8.3 其他 Folly 库中的并发工具 (Other Concurrency Tools in Folly Library)
▮▮▮▮ 9. chapter 9：高级主题与未来展望 (Advanced Topics and Future Outlook)
▮▮▮▮▮▮▮ 9.1 无锁编程简介 (Brief Introduction to Lock-Free Programming)
▮▮▮▮▮▮▮ 9.2 Synchronized 的内部实现机制 (Internal Implementation Mechanism of Synchronized)
▮▮▮▮▮▮▮ 9.3 C++ 并发编程的未来趋势 (Future Trends in C++ Concurrent Programming)
1. chapter 1：并发编程基础 (Fundamentals of Concurrent Programming)
1.1 为什么需要并发？(Why Concurrency?)
在当今的计算领域，并发编程 (Concurrent Programming) 已不仅仅是一种优化手段，而逐渐成为了应对日益复杂和高性能需求的核心技术 (Core Technology)。从桌面应用到大型服务器，再到移动设备和嵌入式系统，并发的身影无处不在。那么，究竟是什么驱动我们拥抱并发，又是什么让并发变得如此重要呢？
① 提升性能与效率 (Improve Performance and Efficiency)：
⚝ 充分利用多核处理器 (Full Utilization of Multi-core Processors)：现代计算机架构普遍采用多核处理器 (Multi-core Processor)。单线程程序只能在一个核心上运行，无法充分发挥硬件的并行计算能力，造成资源浪费。并发编程可以将任务分解成多个子任务，分配到不同的核心上同时执行 (Simultaneous Execution)，显著提升程序的吞吐量 (Throughput) 和执行速度 (Execution Speed)。
⚝ 提高资源利用率 (Improve Resource Utilization)：在某些场景下，例如I/O 密集型 (I/O-bound) 应用，程序的大部分时间可能花费在等待 I/O 操作 (I/O Operations) 完成上，例如等待磁盘读取或网络响应。使用并发，程序可以在等待 I/O 的同时执行其他计算任务，从而提高 CPU (Central Processing Unit) 和其他资源的利用率。
② 增强响应性 (Enhance Responsiveness)：
⚝ 改善用户体验 (Improve User Experience)：对于图形用户界面 (GUI) 应用程序和实时系统 (Real-time System) 而言，响应性 (Responsiveness) 至关重要。如果所有任务都在主线程 (Main Thread) 中串行执行，耗时操作（如文件加载、网络请求）会阻塞用户界面，导致程序卡顿，用户体验极差。通过将耗时操作放到后台线程 (Background Thread) 中并发执行，可以保持用户界面的流畅响应，提升用户体验。
⚝ 实时处理能力 (Real-time Processing Capability)：在实时控制系统 (Real-time Control System)、金融交易系统 (Financial Trading System) 等领域，系统需要及时响应外部事件并做出处理。并发编程能够实现事件驱动 (Event-driven) 的架构，及时处理并发发生的事件，保证系统的实时性 (Real-time Performance)。
③ 简化复杂系统设计 (Simplify Complex System Design)：
⚝ 模块化与解耦 (Modularity and Decoupling)：将复杂的系统分解为多个独立的、并发执行的模块，可以降低系统的复杂度 (Complexity)，提高可维护性 (Maintainability) 和可扩展性 (Scalability)。每个模块专注于处理特定的任务，模块之间通过消息传递 (Message Passing) 或共享内存 (Shared Memory) 等机制进行通信和协作，实现系统的整体功能。
⚝ 异步编程模式 (Asynchronous Programming Paradigm)：并发编程为异步编程 (Asynchronous Programming) 提供了基础。异步编程允许程序发起一个操作后立即返回，无需等待操作完成，当操作完成时通过回调函数 (Callback Function)、Promise/Future 或 async/await 等机制通知程序。这种模式可以有效地处理非阻塞 I/O (Non-blocking I/O) 和事件驱动的场景，简化代码逻辑，提高程序效率。
④ 适应分布式计算环境 (Adapt to Distributed Computing Environments)：
⚝ 分布式系统 (Distributed System)：现代大型应用通常部署在分布式系统 (Distributed System) 中，由多台计算机协同工作。并发编程的思想可以扩展到分布式环境中，实现分布式并发 (Distributed Concurrency)，充分利用集群的计算能力，处理海量数据和高并发请求。
⚝ 微服务架构 (Microservices Architecture)：微服务架构 (Microservices Architecture) 将应用拆分成多个小型、独立的服务，每个服务可以独立部署和扩展。服务之间通过网络进行通信，天然具备并发和分布式的特性。并发编程技术是构建高效、可扩展微服务系统的基石。
综上所述，并发编程已经成为现代软件开发不可或缺的一部分。无论是为了提升性能、增强响应性，还是为了简化系统设计、适应分布式环境，掌握并发编程技术都至关重要。folly/Synchronized.h 库正是为了帮助开发者更方便、更安全地进行并发编程而设计的，它提供了强大的同步原语，简化了并发代码的编写，降低了并发编程的难度。
1.2 并发与并行 (Concurrency vs. Parallelism)
并发 (Concurrency) 和 并行 (Parallelism) 是并发编程领域中两个经常被提及，但也容易混淆的概念。虽然两者都旨在提高程序的执行效率，但它们在本质上有所不同。理解并发与并行的区别，有助于我们更好地设计和实现并发程序。
① 并发 (Concurrency)：
⚝ 定义 (Definition)：并发是指程序结构 (Program Structure) 上的概念，它描述的是程序设计 (Program Design) 的一种方法，即程序被设计成由多个独立的、逻辑上 (Logically) 同时执行的执行单元 (Units of Execution) 组成。这些执行单元可以是线程、进程或协程。
⚝ 执行方式 (Execution Method)：在单核处理器 (Single-core Processor) 上，并发是通过时间片轮转 (Time-Slicing) 的方式模拟出来的。操作系统将 CPU 时间 (CPU Time) 划分为很短的时间片，轮流分配给不同的执行单元。由于时间片非常短，宏观上看，这些执行单元仿佛是同时在执行，但微观上，它们仍然是串行执行 (Serial Execution) 的，只是快速地切换执行上下文。
⚝ 关注点 (Focus)：并发关注的是程序的设计结构 (Program Design Structure) 和任务的调度 (Task Scheduling)，旨在提高程序的响应性 (Responsiveness) 和资源利用率 (Resource Utilization)。即使在单核处理器上，并发也能通过合理的任务调度，提高程序的整体效率。
⚝ 例子 (Example)：
1
// 模拟并发执行两个任务
2
void task1() {
3
for (int i = 0; i < 5; ++i) {
4
std::cout << "Task 1: " << i << std::endl;
5
std::this_thread::sleep_for(std::chrono::milliseconds(100));
6
}
7
}
8
9
void task2() {
10
for (int i = 0; i < 5; ++i) {
11
std::cout << "Task 2: " << i << std::endl;
12
std::this_thread::sleep_for(std::chrono::milliseconds(150));
13
}
14
}
15
16
int main() {
17
std::thread t1(task1);
18
std::thread t2(task2);
19
20
t1.join();
21
t2.join();
22
23
return 0;
24
}
1
在单核处理器上运行上述代码，`task1` 和 `task2` 并非真正同时执行，而是通过时间片轮转交替执行，但从程序的角度来看，我们设计了两个并发执行的任务。
② 并行 (Parallelism)：
⚝ 定义 (Definition)：并行是指程序执行 (Program Execution) 上的概念，它描述的是程序真正地 (Actually) 同时在多个处理单元 (Processing Units) 上执行。这些处理单元通常是多核处理器 (Multi-core Processor) 或分布式系统 (Distributed System) 中的多台计算机。
⚝ 执行方式 (Execution Method)：并行需要硬件的支持，即需要多个物理的 CPU 核心 (CPU Cores) 或计算节点。程序的不同部分被分配到不同的核心或节点上，物理上 (Physically) 同时执行。
⚝ 关注点 (Focus)：并行关注的是程序的执行效率 (Program Execution Efficiency) 和计算速度 (Computation Speed)，旨在充分利用硬件的并行计算能力，缩短程序的运行时间 (Running Time)。
⚝ 例子 (Example)：
1
#include <vector>
2
#include <numeric>
3
#include <execution> // 需要 C++17 或更高版本
4
5
int main() {
6
std::vector<int> data(1000000);
7
std::iota(data.begin(), data.end(), 1); // 初始化数据
8
9
long long sum = std::reduce(std::execution::par, data.begin(), data.end(), 0LL); // 并行求和
10
11
std::cout << "Sum: " << sum << std::endl;
12
13
return 0;
14
}
1
上述代码使用 C++17 提供的**并行算法 (Parallel Algorithms)** `std::reduce`，在支持并行执行的环境下，求和操作会被分配到多个核心上并行执行，从而加速计算过程。
③ 并发与并行的关系 (Relationship between Concurrency and Parallelism)：
⚝ 联系 (Connection)：并行是并发的一种特殊情况。并发程序可以利用并行来提高执行效率。一个设计良好的并发程序，如果运行在多核处理器上，就可以实现并行执行，从而获得更高的性能。
⚝ 区别 (Difference)：
▮▮▮▮⚝ 并发是程序的设计结构，并行是程序的执行方式。
▮▮▮▮⚝ 并发可以在单核处理器上模拟，并行需要多核处理器或分布式系统的硬件支持。
▮▮▮▮⚝ 并发关注程序的响应性和资源利用率，并行关注程序的执行效率和计算速度。
可以用一个生动的例子来比喻并发与并行：
假设你是一家咖啡店的咖啡师。
⚝ 并发 (Concurrency)：你一个人要同时处理多位顾客的订单。你可以在制作咖啡 A 的间隙，处理咖啡 B 的点单，然后再回来继续制作咖啡 A。你通过交替处理 (Alternating Processing) 不同任务，实现了并发。即使你只有一个咖啡机（单核处理器），你也能同时“进行”多个订单。
⚝ 并行 (Parallelism)：咖啡店来了很多顾客，为了更快地处理订单，你雇佣了多位咖啡师，每个人负责制作一部分咖啡。多位咖啡师同时制作 (Simultaneous Production) 不同的咖啡，这就是并行。你需要多个咖啡机和多位咖啡师（多核处理器）才能实现并行。
总结来说，并发是解耦 (Decoupling) 任务的设计思想，并行是加速执行 (Accelerating Execution) 的执行方式。并发是并行的必要条件，但不是充分条件。只有在多核或分布式环境下，并发程序才能真正实现并行执行，发挥最大的性能优势。理解并发与并行的区别，有助于我们根据实际需求选择合适的并发编程技术和硬件平台。
1.3 线程、进程和协程 (Threads, Processes, and Coroutines)
在并发编程中，线程 (Thread)、进程 (Process) 和 协程 (Coroutine) 是三种常见的执行单元 (Units of Execution)。它们都是实现并发的方式，但它们在资源开销、上下文切换、适用场景等方面存在显著差异。理解这三种执行单元的特点，有助于我们选择合适的并发模型。
① 进程 (Process)：
⚝ 定义 (Definition)：进程是操作系统 (Operating System) 进行资源分配 (Resource Allocation) 的基本单位。每个进程都拥有独立的内存空间 (Memory Space)、地址空间 (Address Space) 和系统资源 (System Resources)（如文件描述符、网络连接等）。进程之间相互独立，一个进程的崩溃通常不会影响其他进程。
⚝ 特点 (Characteristics)：
▮▮▮▮⚝ 资源隔离性 (Resource Isolation)：进程之间拥有独立的资源，隔离性好，安全性高。
▮▮▮▮⚝ 上下文切换开销大 (High Context Switching Overhead)：进程切换需要保存和恢复大量的进程上下文 (Process Context)，包括内存映射、寄存器状态等，开销较大。
▮▮▮▮⚝ 通信开销大 (High Communication Overhead)：进程间通信（IPC, Inter-Process Communication）需要借助操作系统提供的机制，如管道 (Pipe)、消息队列 (Message Queue)、共享内存 (Shared Memory) 等，开销相对较大。
▮▮▮▮⚝ 创建和销毁开销大 (High Creation and Destruction Overhead)：创建和销毁进程需要分配和释放大量的系统资源，开销较大。
⚝ 适用场景 (Use Cases)：
▮▮▮▮⚝ 资源隔离要求高的应用 (Applications with High Resource Isolation Requirements)：例如，Web 服务器通常会为每个客户端请求创建一个独立的进程，以保证隔离性和安全性。
▮▮▮▮⚝ CPU 密集型 (CPU-bound)、计算密集型 (Computation-intensive) 应用：进程可以充分利用多核处理器的并行计算能力，适合执行计算密集型任务。
▮▮▮▮⚝ 稳定性要求高的应用 (Applications with High Stability Requirements)：进程的隔离性使得一个进程的错误不易扩散到其他进程，提高了系统的整体稳定性。
② 线程 (Thread)：
⚝ 定义 (Definition)：线程是操作系统 (Operating System) 进行CPU 调度 (CPU Scheduling) 的基本单位，也被称为轻量级进程 (Lightweight Process)。线程存在于进程之中，一个进程可以包含多个线程。同一进程内的线程共享进程的内存空间 (Memory Space) 和系统资源 (System Resources)，但拥有独立的栈空间 (Stack Space) 和程序计数器 (Program Counter)。
⚝ 特点 (Characteristics)：
▮▮▮▮⚝ 资源共享性 (Resource Sharing)：同一进程内的线程共享进程的内存空间和资源，线程间通信方便高效。
▮▮▮▮⚝ 上下文切换开销较小 (Lower Context Switching Overhead)：线程切换只需要保存和恢复少量的线程上下文 (Thread Context)，开销比进程切换小得多。
▮▮▮▮⚝ 通信开销小 (Lower Communication Overhead)：线程间可以直接读写共享内存进行通信，无需操作系统内核介入，通信效率高。
▮▮▮▮⚝ 创建和销毁开销较小 (Lower Creation and Destruction Overhead)：创建和销毁线程比进程轻量得多，开销较小。
▮▮▮▮⚝ 同步机制复杂 (Complex Synchronization Mechanisms)：由于线程共享内存，需要复杂的同步机制 (Synchronization Mechanisms)（如互斥锁 (Mutex)、条件变量 (Condition Variable) 等）来保证数据一致性和避免竞态条件 (Race Conditions)。
⚝ 适用场景 (Use Cases)：
▮▮▮▮⚝ I/O 密集型 (I/O-bound) 应用：线程可以并发执行 I/O 操作和计算任务，提高资源利用率和响应性。
▮▮▮▮⚝ GUI 应用程序 (GUI Applications)：GUI 应用程序通常使用多线程来保持用户界面的流畅响应，将耗时操作放到后台线程执行。
▮▮▮▮⚝ 需要频繁创建和销毁执行单元的应用 (Applications Requiring Frequent Creation and Destruction of Execution Units)：线程的轻量级特性使其适合于需要频繁创建和销毁执行单元的场景，例如 Web 服务器处理客户端请求。
③ 协程 (Coroutine)：
⚝ 定义 (Definition)：协程，又称用户级线程 (User-level Thread) 或纤程 (Fiber)，是一种比线程更轻量级的执行单元 (Unit of Execution)。协程由程序员 (Programmer) 在用户空间 (User Space) 管理和调度，而不是由操作系统内核调度。一个线程可以包含多个协程。
⚝ 特点 (Characteristics)：
▮▮▮▮⚝ 极致轻量级 (Extremely Lightweight)：协程的创建、销毁和切换开销非常小，几乎可以忽略不计，因为它们完全在用户空间完成，无需内核介入。
▮▮▮▮⚝ 非抢占式调度 (Non-preemptive Scheduling)：协程的调度由程序员显式控制，一个协程主动让出 CPU (CPU) 执行权后，才会切换到其他协程。这种调度方式被称为协作式调度 (Cooperative Scheduling) 或非抢占式调度 (Non-preemptive Scheduling)。
▮▮▮▮⚝ 更高的并发度 (Higher Concurrency)：由于协程的开销极小，可以在单个线程中创建大量的协程，实现更高的并发度。
▮▮▮▮⚝ 同步机制简单 (Simpler Synchronization Mechanisms)：由于协程是协作式调度的，在同一个线程内的协程之间，通常不需要复杂的锁机制，可以使用更简单的同步方式，例如通道 (Channel) 或事件队列 (Event Queue)。
▮▮▮▮⚝ 编程模型相对复杂 (Relatively Complex Programming Model)：协程的调度需要程序员显式控制，编程模型相对线程更复杂，需要使用特定的协程库或语言特性。
⚝ 适用场景 (Use Cases)：
▮▮▮▮⚝ 高并发、I/O 密集型 (High-concurrency, I/O-bound) 应用：例如，网络服务器、游戏服务器、消息队列等，需要处理大量并发连接和 I/O 操作的场景。
▮▮▮▮⚝ 异步编程 (Asynchronous Programming)：协程非常适合用于实现异步编程，可以简化异步代码的编写，提高代码的可读性和可维护性。
▮▮▮▮⚝ 需要极致性能和低延迟的应用 (Applications Requiring Extreme Performance and Low Latency)：例如，高性能网络编程、实时游戏等，对性能和延迟要求极高的场景。
④ 总结与比较 (Summary and Comparison)：
| 特性 (Feature) | 进程 (Process) | 线程 (Thread) | 协程 (Coroutine) |
|---|---|---|---|
| 资源隔离性 (Resource Isolation) | 强 (Strong) | 弱 (Weak) | 弱 (Weak) |
| 上下文切换开销 (Context Switching Overhead) | 大 (High) | 较小 (Lower) | 极小 (Extremely Low) |
| 通信开销 (Communication Overhead) | 大 (High) | 小 (Low) | 很小 (Very Low) |
| 创建/销毁开销 (Creation/Destruction Overhead) | 大 (High) | 较小 (Lower) | 极小 (Extremely Low) |
| 调度方式 (Scheduling Method) | 操作系统抢占式 (OS Preemptive) | 操作系统抢占式 (OS Preemptive) | 用户协作式 (User Cooperative) |
| 并发度 (Concurrency) | 较低 (Lower) | 中等 (Medium) | 较高 (Higher) |
| 同步机制 (Synchronization Mechanism) | 复杂 (Complex) | 复杂 (Complex) | 相对简单 (Relatively Simple) |
| 编程模型 (Programming Model) | 相对简单 (Relatively Simple) | 相对简单 (Relatively Simple) | 相对复杂 (Relatively Complex) |
选择使用进程、线程还是协程，需要根据具体的应用场景和需求进行权衡。一般来说：
⚝ 进程 适用于资源隔离性要求高、CPU 密集型、稳定性要求高的应用。
⚝ 线程 适用于 I/O 密集型、GUI 应用、需要频繁创建和销毁执行单元的应用。
⚝ 协程 适用于高并发、I/O 密集型、异步编程、对性能和延迟要求极高的应用。
folly/Synchronized.h 主要用于线程环境下的同步，它提供了线程安全的互斥锁、读写锁和条件变量等同步原语，帮助开发者构建高效、可靠的多线程程序。虽然协程在某些场景下比线程更高效，但线程仍然是操作系统提供的标准并发模型，应用广泛，folly/Synchronized.h 在多线程编程中具有重要的作用。
1.4 竞态条件与数据竞争 (Race Conditions and Data Races)
在并发编程中，竞态条件 (Race Condition) 和 数据竞争 (Data Race) 是两种常见的并发错误，它们会导致程序出现不可预测的行为，甚至产生严重的安全漏洞。理解竞态条件和数据竞争的本质，掌握避免它们的方法，是编写正确并发程序的关键。
① 竞态条件 (Race Condition)：
⚝ 定义 (Definition)：竞态条件是指程序的输出 (Program Output) 或行为 (Behavior) 取决于多个并发操作 (Concurrent Operations) 的执行顺序 (Execution Order) 的情况。当多个线程或进程并发访问和修改共享数据时，如果它们的执行顺序不确定，就可能导致程序产生意料之外的结果。
⚝ 产生条件 (Conditions for Occurrence)：
▮▮▮▮⚝ 共享资源 (Shared Resources)：多个并发执行单元（线程、进程或协程）访问同一个共享资源（例如，共享变量、文件、数据库等）。
▮▮▮▮⚝ 非原子操作 (Non-atomic Operations)：对共享资源的操作不是原子操作 (Atomic Operation)。原子操作是指一个不可分割的操作序列，要么全部执行成功，要么全部不执行，执行过程中不会被其他操作中断。
▮▮▮▮⚝ 执行顺序不确定 (Indeterminate Execution Order)：并发执行单元的执行顺序是不确定的，受到操作系统调度、线程优先级、硬件环境等多种因素的影响。
⚝ 例子 (Example)：
1
#include <iostream>
2
#include <thread>
3
4
int counter = 0; // 共享计数器
5
6
void increment_counter() {
7
for (int i = 0; i < 100000; ++i) {
8
counter++; // 非原子操作：读取-修改-写入
9
}
10
}
11
12
int main() {
13
std::thread t1(increment_counter);
14
std::thread t2(increment_counter);
15
16
t1.join();
17
t2.join();
18
19
std::cout << "Counter value: " << counter << std::endl; // 预期结果：200000，实际结果可能小于 200000
20
21
return 0;
22
}
1
在上述代码中，`counter++` 操作实际上包含了三个步骤：
2
1. 读取 `counter` 的当前值。
3
2. 将读取的值加 1。
4
3. 将结果写回 `counter`。
5
这三个步骤不是原子操作。当多个线程并发执行 `increment_counter` 函数时，可能会发生以下情况：
▮▮▮▮⚝ 线程 1 读取 counter 的值（假设为 0）。
▮▮▮▮⚝ 线程 2 也读取 counter 的值（此时 counter 仍然为 0）。
▮▮▮▮⚝ 线程 1 将读取的值加 1，得到 1，并将 1 写回 counter。
▮▮▮▮⚝ 线程 2 也将读取的值加 1，得到 1，并将 1 写回 counter。
1
结果，`counter` 只增加了 1，而不是预期的 2。这就是竞态条件，程序的最终结果取决于线程 1 和线程 2 执行 `counter++` 操作的**相对时序 (Relative Timing)**。
② 数据竞争 (Data Race)：
⚝ 定义 (Definition)：数据竞争是一种特定类型 (Specific Type) 的竞态条件，它发生在多个线程 (Multiple Threads) 并发访问同一内存位置 (Same Memory Location)，并且至少有一个线程执行写操作 (Write Operation)，同时没有使用任何同步机制 (Without Any Synchronization Mechanism) 来保证访问的互斥性。
⚝ 产生条件 (Conditions for Occurrence)：
▮▮▮▮⚝ 共享内存位置 (Shared Memory Location)：多个线程访问同一块内存区域。
▮▮▮▮⚝ 至少一个写操作 (At Least One Write Operation)：至少有一个线程对该内存区域执行写操作。
▮▮▮▮⚝ 并发访问 (Concurrent Access)：多个线程并发地访问该内存区域。
▮▮▮▮⚝ 缺乏同步 (Lack of Synchronization)：没有使用任何同步机制（如互斥锁、原子操作等）来保护对该内存区域的并发访问。
⚝ 后果 (Consequences)：数据竞争会导致未定义行为 (Undefined Behavior)。编译器和硬件可能会对内存访问进行优化，例如指令重排 (Instruction Reordering)、缓存 (Caching) 等。在没有同步的情况下，数据竞争可能导致：
▮▮▮▮⚝ 脏数据 (Dirty Data)：一个线程读取到另一个线程正在修改的中间状态的数据。
▮▮▮▮⚝ 程序崩溃 (Program Crash)：数据竞争可能破坏程序的内存结构，导致程序崩溃。
▮▮▮▮⚝ 安全漏洞 (Security Vulnerabilities)：在某些情况下，数据竞争可能被利用来执行恶意代码。
⚝ 例子 (Example)：
1
#include <iostream>
2
#include <thread>
3
4
int shared_data = 0;
5
6
void writer_thread() {
7
shared_data = 10; // 写操作
8
}
9
10
void reader_thread() {
11
std::cout << "Shared data: " << shared_data << std::endl; // 读操作
12
}
13
14
int main() {
15
std::thread writer(writer_thread);
16
std::thread reader(reader_thread);
17
18
writer.join();
19
reader.join();
20
21
return 0;
22
}
1
在上述代码中，`writer_thread` 和 `reader_thread` 并发访问共享变量 `shared_data`，`writer_thread` 执行写操作，`reader_thread` 执行读操作，并且没有使用任何同步机制。这就构成了数据竞争。程序的输出结果是不确定的，可能输出 0，也可能输出 10，甚至可能出现其他未定义行为。
③ 竞态条件与数据竞争的区别与联系 (Difference and Relationship between Race Condition and Data Race)：
⚝ 联系 (Connection)：数据竞争是一种特殊的竞态条件。所有数据竞争都是竞态条件，但并非所有竞态条件都是数据竞争。
⚝ 区别 (Difference)：
▮▮▮▮⚝ 范围 (Scope)：竞态条件是一个更广泛的概念，它描述的是程序行为取决于并发操作执行顺序的情况，可能涉及到多个共享资源和复杂的逻辑。数据竞争则更具体，它特指多个线程并发访问同一内存位置，且至少有一个写操作，缺乏同步的情况。
▮▮▮▮⚝ 后果 (Consequences)：竞态条件的后果是程序输出或行为不确定，可能导致逻辑错误。数据竞争的后果是未定义行为，可能导致更严重的错误，例如程序崩溃、安全漏洞等。
▮▮▮▮⚝ 检测 (Detection)：数据竞争可以使用静态分析工具 (Static Analysis Tools) 或动态分析工具 (Dynamic Analysis Tools)（如ThreadSanitizer）进行检测。竞态条件的检测则更加困难，通常需要仔细的代码审查和测试。
④ 避免竞态条件和数据竞争的方法 (Methods to Avoid Race Conditions and Data Races)：
⚝ 同步机制 (Synchronization Mechanisms)：使用同步机制来保护对共享资源的并发访问，保证互斥访问 (Mutual Exclusion) 和原子性 (Atomicity)。常见的同步机制包括：
▮▮▮▮⚝ 互斥锁 (Mutex)：folly::Synchronized 库提供的 Synchronized<std::mutex> 可以用于保护临界区，保证同一时刻只有一个线程可以访问共享资源。
▮▮▮▮⚝ 读写锁 (ReadWriteMutex)：folly::Synchronized 库提供的 Synchronized<folly::ReadWriteMutex> 可以允许多个线程同时读取共享资源，但只允许一个线程写入共享资源，适用于读多写少的场景。
▮▮▮▮⚝ 原子操作 (Atomic Operations)：使用原子操作可以保证对单个变量的读-修改-写操作的原子性，避免数据竞争。C++ 标准库提供了 <atomic> 头文件，folly 库也提供了 folly/AtomicHashmap.h 等原子数据结构。
▮▮▮▮⚝ 条件变量 (Condition Variable)：folly::Synchronized 库提供的条件变量可以用于线程间的同步和通信，实现更复杂的同步模式。
⚝ 避免共享可变状态 (Avoid Shared Mutable State)：尽可能减少共享可变状态的使用。如果必须共享状态，尽量将其设计为只读 (Read-only) 或不可变 (Immutable) 的。
⚝ 线程安全的数据结构 (Thread-Safe Data Structures)：使用线程安全的数据结构，例如 folly::ConcurrentHashMap、folly::AtomicHashmap 等，这些数据结构内部已经实现了必要的同步机制，可以安全地在多线程环境中使用。
⚝ 消息传递 (Message Passing)：使用消息传递机制进行线程或进程间的通信，而不是直接共享内存。消息传递可以降低共享状态的复杂性，减少竞态条件和数据竞争的发生。
理解竞态条件和数据竞争是并发编程的基础。folly/Synchronized.h 库提供的同步原语正是为了帮助开发者有效地避免这些并发错误，编写安全、可靠的多线程程序。接下来的章节将深入探讨 folly/Synchronized.h 的使用方法和高级特性，帮助读者更好地掌握并发编程技术。
1.4.1 临界区 (Critical Sections)
临界区 (Critical Section) 是并发编程中一个至关重要的概念，它是解决竞态条件和数据竞争问题的核心手段。理解临界区的定义、作用和使用方法，是编写线程安全代码的基础。
① 定义 (Definition)：
⚝ 代码区域 (Code Region)：临界区指的是一段代码区域 (Code Region)，这段代码区域访问共享资源 (Shared Resource)，并且在并发执行环境下，需要保证互斥访问 (Mutual Exclusion)，即同一时刻只能有一个线程或进程执行临界区内的代码。
⚝ 共享资源保护 (Shared Resource Protection)：临界区的目的是保护共享资源，防止多个并发执行单元同时访问和修改共享资源，从而避免竞态条件和数据竞争的发生。
⚝ 最小化原则 (Minimization Principle)：临界区应该尽可能地小 (Small)，只包含访问共享资源的必要代码，避免长时间占用锁，影响程序的并发性能。
② 作用 (Function)：
⚝ 互斥访问 (Mutual Exclusion)：临界区保证了对共享资源的互斥访问。当一个线程进入临界区后，其他线程将被阻塞 (Blocked)，直到该线程退出临界区，才能继续执行。
⚝ 原子性 (Atomicity)：临界区内的代码被视为一个原子操作序列 (Atomic Operation Sequence)。从外部来看，临界区内的操作要么全部完成，要么全部不完成，不会被其他线程的操作中断。
⚝ 数据一致性 (Data Consistency)：通过互斥访问和原子性，临界区保证了共享数据在并发环境下的一致性 (Consistency) 和完整性 (Integrity)，避免了脏数据和数据损坏。
③ 实现方式 (Implementation Methods)：
⚝ 互斥锁 (Mutex)：互斥锁 (Mutex, Mutual Exclusion Lock) 是实现临界区最常用的同步原语。互斥锁有两种状态：加锁 (Locked) 和 解锁 (Unlocked)。
▮▮▮▮⚝ 加锁 (Lock)：当线程要进入临界区时，首先尝试获取互斥锁。如果互斥锁处于解锁状态，线程成功获取锁，并将互斥锁状态设置为加锁，然后进入临界区执行代码。如果互斥锁处于加锁状态，线程将被阻塞，直到互斥锁被释放。
▮▮▮▮⚝ 解锁 (Unlock)：当线程执行完临界区内的代码后，需要释放互斥锁，将互斥锁状态设置为解锁，以便其他等待的线程可以获取锁并进入临界区。
▮▮▮▮⚝ RAII (Resource Acquisition Is Initialization)：为了避免忘记解锁导致死锁，通常使用 RAII (Resource Acquisition Is Initialization) 机制来管理互斥锁。RAII 是一种 C++ 编程技术，它将资源的获取和释放与对象的生命周期绑定。folly::Synchronized 库就采用了 RAII 机制，通过构造函数获取锁，通过析构函数自动释放锁，简化了锁的管理，提高了代码的安全性。
⚝ 代码示例 (Code Example)：使用 folly::Synchronized<std::mutex> 实现临界区保护共享计数器：
1
#include <iostream>
2
#include <thread>
3
#include <mutex>
4
#include <folly/Synchronized.h>
5
6
int counter = 0; // 共享计数器
7
folly::Synchronized<std::mutex> mutex; // 互斥锁
8
9
void increment_counter() {
10
for (int i = 0; i < 100000; ++i) {
11
std::lock_guard<folly::Synchronized<std::mutex>> lock(mutex); // RAII 锁管理
12
counter++; // 临界区：访问共享计数器
13
}
14
}
15
16
int main() {
17
std::thread t1(increment_counter);
18
std::thread t2(increment_counter);
19
20
t1.join();
21
t2.join();
22
23
std::cout << "Counter value: " << counter << std::endl; // 预期结果：200000
24
25
return 0;
26
}
1
在上述代码中，`std::lock_guard<folly::Synchronized<std::mutex>> lock(mutex);` 语句创建了一个 `lock_guard` 对象，它在构造函数中获取了互斥锁 `mutex`，在析构函数中自动释放了互斥锁。`counter++` 操作被放在临界区内，受到互斥锁的保护，保证了对 `counter` 的互斥访问，避免了竞态条件。
④ 临界区的设计原则 (Design Principles of Critical Sections)：
⚝ 正确性 (Correctness)：临界区必须能够正确地保护共享资源，保证数据的一致性和完整性。
⚝ 最小化 (Minimization)：临界区应该尽可能地小，只包含必要的代码，减少锁的持有时间，提高程序的并发性能。
⚝ 避免嵌套锁 (Avoid Nested Locks)：尽量避免在临界区内再次获取锁，嵌套锁容易导致死锁 (Deadlock)。如果必须使用嵌套锁，需要仔细设计锁的获取顺序，避免死锁的发生。
⚝ 性能考量 (Performance Considerations)：临界区的使用会引入锁竞争 (Lock Contention) 和上下文切换 (Context Switching) 的开销，影响程序的性能。需要根据实际情况选择合适的锁类型和临界区大小，平衡正确性和性能。
临界区是并发编程中不可或缺的同步机制。folly::Synchronized 库提供的互斥锁和 RAII 机制，使得临界区的使用更加方便、安全和高效。在后续章节中，我们将深入探讨 folly::Synchronized 库的更多高级特性和应用场景。
1.4.2 原子操作 (Atomic Operations)
原子操作 (Atomic Operation) 是并发编程中一种重要的同步机制，它提供了一种比互斥锁更轻量级的同步方式。原子操作能够保证对单个变量 (Single Variable) 的操作是原子性 (Atomic) 的，即不可分割的，不会被其他线程的操作中断。
① 定义 (Definition)：
⚝ 不可分割的操作 (Indivisible Operation)：原子操作是指一个操作序列 (Operation Sequence)，从整体 (Overall) 上看，它要么全部执行成功 (All Succeed)，要么全部不执行 (All Fail)，不存在部分执行 (Partial Execution) 的中间状态。在执行过程中，原子操作不会被其他线程或进程的操作中断。
⚝ 最小的同步单元 (Smallest Unit of Synchronization)：原子操作是并发编程中最小的同步单元，它只针对单个变量进行同步，开销比互斥锁更小。
⚝ 硬件支持 (Hardware Support)：原子操作通常由硬件 (Hardware) 提供支持，例如 CPU 提供的原子指令（如 Compare-and-Swap, CAS）。
② 作用 (Function)：
⚝ 保证原子性 (Guarantee Atomicity)：原子操作保证了对单个变量的操作的原子性，避免了在多线程环境下对共享变量进行非原子操作导致的数据竞争和竞态条件。
⚝ 轻量级同步 (Lightweight Synchronization)：原子操作是一种轻量级的同步机制，相比互斥锁，它避免了线程的阻塞和上下文切换，性能更高。
⚝ 构建更复杂的同步机制 (Building More Complex Synchronization Mechanisms)：原子操作可以作为构建更复杂的同步机制的基础，例如无锁数据结构 (Lock-Free Data Structures)、自旋锁 (Spin Lock) 等。
③ 常见的原子操作类型 (Common Types of Atomic Operations)：
⚝ 原子读写 (Atomic Read and Write)：原子地读取或写入一个变量的值。例如，std::atomic<int>::load() 和 std::atomic<int>::store()。
⚝ 原子交换 (Atomic Exchange)：原子地将一个新值写入变量，并返回变量的旧值。例如，std::atomic<int>::exchange()。
⚝ 原子比较并交换 (Atomic Compare-and-Swap, CAS)：原子地比较变量的当前值与一个期望值，如果相等，则将变量的值更新为新值。CAS 操作是实现无锁编程的重要基石。例如，std::atomic<int>::compare_exchange_weak() 和 std::atomic<int>::compare_exchange_strong()。
⚝ 原子算术运算 (Atomic Arithmetic Operations)：原子地进行算术运算，例如原子加、原子减、原子与、原子或等。例如，std::atomic<int>::fetch_add()、std::atomic<int>::fetch_sub()、std::atomic<int>::fetch_and()、std::atomic<int>::fetch_or() 等。
④ C++ 中的原子操作 (Atomic Operations in C++)：
⚝ <atomic> 头文件 ( <atomic> Header File)：C++ 标准库提供了 <atomic> 头文件，用于支持原子操作。<atomic> 头文件定义了 std::atomic<T> 类模板，可以用于包装各种类型的变量，使其支持原子操作。
⚝ std::atomic<T> 类模板 ( std::atomic<T> Class Template)：std::atomic<T> 类模板提供了丰富的原子操作方法，例如 load()、store()、exchange()、compare_exchange_weak()、compare_exchange_strong()、fetch_add() 等。
⚝ 代码示例 (Code Example)：使用 std::atomic<int> 实现线程安全的计数器：
1
#include <iostream>
2
#include <thread>
3
#include <atomic>
4
5
std::atomic<int> counter(0); // 原子计数器
6
7
void increment_counter() {
8
for (int i = 0; i < 100000; ++i) {
9
counter++; // 原子自增操作
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
}
1
在上述代码中，`std::atomic<int> counter(0);` 声明了一个原子整型变量 `counter`。`counter++` 操作实际上是原子自增操作，它保证了对 `counter` 的原子更新，避免了数据竞争。
⑤ 原子操作的适用场景 (Use Cases of Atomic Operations)：
⚝ 简单同步 (Simple Synchronization)：原子操作适用于简单的同步场景，例如计数器、标志位等，只需要对单个变量进行原子操作的场景。
⚝ 性能敏感的场景 (Performance-Sensitive Scenarios)：原子操作比互斥锁更轻量级，适用于性能敏感的场景，可以减少锁竞争和上下文切换的开销。
⚝ 构建无锁数据结构 (Building Lock-Free Data Structures)：原子操作是构建无锁数据结构的基础，例如无锁队列、无锁栈等。无锁数据结构可以提供更高的并发性能，但编程模型也更加复杂。
⑥ 原子操作的局限性 (Limitations of Atomic Operations)：
⚝ 作用范围有限 (Limited Scope)：原子操作只能保证对单个变量的操作的原子性，无法保证对多个变量或复杂操作序列的原子性。对于需要保护多个变量或复杂临界区的场景，仍然需要使用互斥锁等更高级的同步机制。
⚝ ABA 问题 (ABA Problem)：在使用 CAS 操作时，可能会遇到 ABA 问题 (ABA Problem)。ABA 问题指的是，一个变量的值从 A 变为 B，又从 B 变回 A。CAS 操作在比较时，会认为变量的值没有发生变化，但实际上变量的值可能已经被其他线程修改过了。ABA 问题在某些场景下可能会导致逻辑错误。为了解决 ABA 问题，可以使用版本号 (Version Number) 或标记 (Tag) 等机制。
原子操作是一种重要的并发编程技术，它提供了一种轻量级、高效的同步方式。folly 库也提供了 folly/AtomicHashmap.h 等原子数据结构，进一步扩展了原子操作的应用范围。在实际并发编程中，可以根据具体的场景选择合适的同步机制，原子操作和互斥锁可以结合使用，以达到最佳的性能和可靠性。
1.4.3 内存模型与顺序一致性 (Memory Model and Sequential Consistency)
内存模型 (Memory Model) 和 顺序一致性 (Sequential Consistency) 是并发编程中涉及内存访问顺序 (Memory Access Order) 和可见性 (Visibility) 的重要概念。理解内存模型和顺序一致性，有助于我们编写正确、高效的并发程序，避免由于内存访问顺序问题导致的并发错误。
① 内存模型 (Memory Model)：
⚝ 硬件与编译器优化 (Hardware and Compiler Optimizations)：现代计算机体系结构和编译器为了提高性能，会对指令执行顺序 (Instruction Execution Order) 进行优化，例如乱序执行 (Out-of-order Execution)、指令重排 (Instruction Reordering)、缓存 (Caching) 等。这些优化在单线程环境下通常是透明的，不会影响程序的正确性。但在多线程环境下，如果没有合适的同步机制，这些优化可能会导致内存访问顺序 (Memory Access Order) 与程序代码顺序 (Program Code Order) 不一致，从而引发并发错误。
⚝ 内存模型的作用 (Role of Memory Model)：内存模型定义了多线程程序 (Multi-threaded Program) 中内存访问 (Memory Access) 的行为规则 (Behavior Rules)，包括：
▮▮▮▮⚝ 可见性 (Visibility)：一个线程对共享变量的修改何时对其他线程可见。
▮▮▮▮⚝ 顺序性 (Ordering)：多个线程对共享变量的访问操作之间的顺序关系。
⚝ C++ 内存模型 (C++ Memory Model)：C++ 标准定义了一套抽象的内存模型 (Abstract Memory Model)，用于规范多线程程序的内存访问行为。C++ 内存模型主要关注以下几个方面：
▮▮▮▮⚝ 原子性 (Atomicity)：原子操作的原子性保证。
▮▮▮▮⚝ 顺序性 (Ordering)：内存操作的顺序约束，例如happens-before 关系 (Happens-before Relationship)。
▮▮▮▮⚝ 可见性 (Visibility)：内存操作的可见性保证，例如flush to main memory (刷新到主内存) 和 invalidate cache (失效缓存)。
▮▮▮▮⚝ 数据竞争 (Data Race)：数据竞争的定义和未定义行为。
② 顺序一致性 (Sequential Consistency)：
⚝ 最强的内存模型 (Strongest Memory Model)：顺序一致性 (Sequential Consistency) 是一种理想化 (Idealized) 的、最强 (Strongest) 的内存模型。在顺序一致性模型下，所有线程对共享变量的内存访问操作都按照某种全局顺序 (Global Order) 执行，并且每个线程看到的内存访问顺序都与这个全局顺序一致。
⚝ 程序顺序 (Program Order)：在顺序一致性模型下，每个线程内部的内存访问操作都按照程序代码的顺序 (Program Code Order) 执行。
⚝ 全局时钟 (Global Clock)：可以想象存在一个全局时钟 (Global Clock)，所有线程的内存访问操作都按照这个全局时钟的顺序串行执行。
⚝ 简单直观 (Simple and Intuitive)：顺序一致性模型非常简单直观，程序员可以像在单线程环境下一样思考多线程程序的内存访问行为，无需考虑复杂的内存访问顺序问题。
⚝ 性能开销大 (High Performance Overhead)：为了实现顺序一致性，需要付出较大的性能开销，例如禁止编译器和硬件的各种优化，强制内存操作的顺序执行，频繁地进行缓存同步等。
③ C++ 内存顺序 (C++ Memory Order)：
⚝ std::memory_order 枚举 ( std::memory_order Enumeration)：C++11 引入了 std::memory_order 枚举，用于指定原子操作的内存顺序 (Memory Order)。std::memory_order 枚举定义了多种内存顺序选项，包括：
▮▮▮▮⚝ std::memory_order_seq_cst (Sequential Consistency)：顺序一致性。这是最强的内存顺序，保证了顺序一致性模型的所有特性。
▮▮▮▮⚝ std::memory_order_release (Release)：释放顺序。用于写操作，保证在该写操作之前的所有写操作 (All Write Operations) 都对其他线程可见。
▮▮▮▮⚝ std::memory_order_acquire (Acquire)：获取顺序。用于读操作，保证在该读操作之后的所有读写操作 (All Read and Write Operations) 都不会在该读操作之前执行。
▮▮▮▮⚝ std::memory_order_acq_rel (Acquire-Release)：获取-释放顺序。同时具备 acquire 和 release 的特性，用于读-修改-写操作。
▮▮▮▮⚝ std::memory_order_relaxed (Relaxed)：宽松顺序。最弱的内存顺序，只保证原子性，不保证任何顺序性或可见性。
▮▮▮▮⚝ std::memory_order_consume (Consume)：消费顺序。（C++17 移除，不建议使用）
⚝ 默认内存顺序 (Default Memory Order)：对于原子操作，默认的内存顺序是 std::memory_order_seq_cst，即顺序一致性。
⚝ 选择合适的内存顺序 (Choosing the Right Memory Order)：选择合适的内存顺序需要在性能 (Performance) 和正确性 (Correctness) 之间进行权衡。
▮▮▮▮⚝ std::memory_order_seq_cst：最安全，但性能最低。适用于对顺序一致性要求高的场景。
▮▮▮▮⚝ std::memory_order_relaxed：性能最高，但最容易出错。适用于对顺序性要求不高，只关注原子性的场景。
▮▮▮▮⚝ std::memory_order_release、std::memory_order_acquire、std::memory_order_acq_rel：介于两者之间，可以根据具体的同步需求选择合适的内存顺序，在保证正确性的前提下，尽可能提高性能。
④ happens-before 关系 (Happens-before Relationship)：
⚝ 定义 (Definition)：happens-before 关系 (Happens-before Relationship) 是 C++ 内存模型中定义的一种偏序关系 (Partial Order Relationship)，用于描述两个内存操作 (Two Memory Operations) 之间的顺序约束 (Ordering Constraint)。如果操作 A happens-before 操作 B，则表示操作 A 的结果对操作 B 可见，并且操作 A 的执行顺序在操作 B 之前。
⚝ 建立 happens-before 关系的方式 (Ways to Establish Happens-before Relationship)：
▮▮▮▮⚝ 同一个线程内的程序顺序 (Program Order within a Single Thread)：在同一个线程内，按照程序代码的顺序，前面的操作 happens-before 后面的操作。
▮▮▮▮⚝ 原子操作的同步顺序 (Synchronization Order of Atomic Operations)：对于使用顺序一致性内存顺序 (std::memory_order_seq_cst) 的原子操作，如果操作 A 在操作 B 之前完成，则操作 A happens-before 操作 B。
▮▮▮▮⚝ 互斥锁的同步顺序 (Synchronization Order of Mutexes)：如果线程 A 在线程 B 之前释放了互斥锁，并且线程 B 随后获取了同一个互斥锁，则线程 A 释放锁的操作 happens-before 线程 B 获取锁的操作。
▮▮▮▮⚝ 线程的 join 操作 (Thread Join Operation)：如果线程 A 启动了线程 B，并且线程 A 在线程 B 结束之后调用 join() 等待线程 B 结束，则线程 B 的所有操作 happens-before 线程 A 从 join() 返回之后的操作。
⑤ 代码示例 (Code Example)：使用原子操作和内存顺序保证线程间的同步和可见性：
1
#include <iostream>
2
#include <thread>
3
#include <atomic>
4
5
std::atomic<bool> ready(false);
6
int data = 0;
7
8
void writer_thread() {
9
data = 42;
10
ready.store(true, std::memory_order_release); // 释放操作
11
}
12
13
void reader_thread() {
14
while (!ready.load(std::memory_order_acquire)) { // 获取操作
15
// 等待 ready 变为 true
16
std::this_thread::yield(); // 让出 CPU 时间片
17
}
18
std::cout << "Data: " << data << std::endl; // 保证 data 的值对 reader_thread 可见
19
}
20
21
int main() {
22
std::thread writer(writer_thread);
23
std::thread reader(reader_thread);
24
25
writer.join();
26
reader.join();
27
28
return 0;
29
}
1
在上述代码中，`writer_thread` 先修改 `data` 的值，然后将 `ready` 设置为 `true`，并使用 `std::memory_order_release` 内存顺序进行**释放操作 (Release Operation)**。`reader_thread` 循环等待 `ready` 变为 `true`，并使用 `std::memory_order_acquire` 内存顺序进行**获取操作 (Acquire Operation)**。`release` 操作和 `acquire` 操作建立起了 **happens-before 关系 (Happens-before Relationship)**，保证了 `writer_thread` 对 `data` 的修改在 `reader_thread` 读取 `data` 之前发生，从而保证了 `reader_thread` 能够正确地读取到 `data` 的值。
理解内存模型和顺序一致性对于编写复杂的并发程序至关重要。folly/Synchronized.h 库在内部实现中也考虑了内存模型和顺序一致性的问题，为开发者提供了安全、可靠的同步原语。在后续章节中，我们将继续探讨 folly/Synchronized.h 的高级特性和最佳实践，帮助读者更好地掌握并发编程技术。
END_OF_CHAPTER
2. chapter 2：Folly 库与 Synchronized.h 概览 (Overview of Folly Library and Synchronized.h)
2.1 Folly 库简介 (Introduction to Folly Library)
Folly，全称为 "Facebook Open Source Library"，是一套由 Facebook 开源的高性能 C++ 库集合。它旨在为构建和维护大型、高性能的应用程序提供基础组件。Folly 并非一个单一的库，而是一个包含众多模块的工具箱，涵盖了从基础数据结构、算法到网络通信、并发控制等多个领域。Folly 的设计目标是提供超越标准库的功能和性能，同时保持高度的灵活性和可扩展性。
Folly 的诞生源于 Facebook 在构建其大规模分布式系统时遇到的挑战和需求。为了应对海量数据、高并发请求以及复杂的业务逻辑，Facebook 的工程师们开发了一系列高性能、可靠且易于使用的 C++ 组件。这些组件逐渐积累并最终形成了 Folly 库。
Folly 库的核心特点和主要模块包括：
① 基础工具库 (Core Utilities)：
⚝ 提供了许多基础的数据结构和算法，例如 FBString（一种高性能的字符串实现）、Vector 和 HashMap 的优化版本、以及各种实用工具函数。这些组件旨在提升常见操作的效率和可靠性。
⚝ 例如，fbstring 针对多种场景进行了优化，包括小字符串优化（SSO, Small String Optimization）和引用计数等，以减少内存分配和拷贝的开销。
② 异步编程框架 (Asynchronous Programming Framework)：
⚝ Folly 提供了强大的异步编程支持，包括 Future/Promise 机制、EventBase 事件循环、以及 IOManager 等组件。这些工具使得开发者能够更容易地编写高效的异步代码，处理高并发的 I/O 操作。
⚝ Future/Promise 模式允许以同步的方式编写异步代码，提高了代码的可读性和可维护性。EventBase 和 IOManager 则提供了底层的事件驱动机制，用于构建高性能的网络应用。
③ 并发与同步工具 (Concurrency and Synchronization Tools)：
⚝ 除了 Synchronized.h，Folly 还包含了其他丰富的并发工具，例如 Baton（一种轻量级的同步原语）、Hazptr（Hazard Pointer，一种用于无锁编程的内存回收机制）、以及各种原子操作和并发数据结构。
⚝ 这些工具为开发者提供了多种选择，以应对不同的并发场景和性能需求。Synchronized.h 在其中扮演着重要角色，它提供了一种安全、易用且高效的互斥锁封装。
④ 网络库 (Networking Library)：
⚝ Folly 包含了高性能的网络库 Socket 和 AsyncSocket，用于构建网络应用程序。这些库提供了对 TCP、UDP 等协议的支持，并针对高并发和低延迟场景进行了优化。
⚝ AsyncSocket 基于事件驱动模型，能够高效地处理大量的并发连接。
⑤ 序列化与反序列化 (Serialization and Deserialization)：
⚝ Folly 提供了 FBJson 和 Thrift 等序列化库，用于高效地处理数据序列化和反序列化。Thrift 是 Facebook 开源的跨语言服务开发框架，Folly 提供了 C++ 版本的支持。
⚝ 这些库能够帮助开发者快速地将数据转换为字节流进行传输或存储，并在需要时恢复数据结构。
⑥ 时间与定时器 (Time and Timers)：
⚝ Folly 提供了高精度的时间测量工具和定时器，例如 MicrosecondTimer 和 HHWheelTimer。这些工具对于性能分析、延迟测量以及实现定时任务非常有用。
⚝ HHWheelTimer 是一种分层时间轮定时器，能够高效地管理大量的定时任务。
Folly 库在现代 C++ 开发中扮演着重要的角色，尤其是在高性能、高并发的应用场景下。它不仅提供了丰富的功能，还注重性能和代码质量。许多大型互联网公司和开源项目都在使用 Folly 库来构建其核心系统。学习和掌握 Folly 库，对于提升 C++ 开发技能，特别是并发编程能力，具有重要的意义。
2.2 Synchronized.h 的作用与定位 (Role and Positioning of Synchronized.h)
Synchronized.h 是 Folly 库中专门用于提供互斥同步（Mutual Exclusion Synchronization） 的头文件。它的核心作用是简化和安全化 C++ 中的互斥锁（Mutex）的使用，从而帮助开发者更容易地编写线程安全的代码。
在并发编程中，共享数据（Shared Data） 的访问控制是一个核心问题。当多个线程同时访问和修改同一块内存区域时，如果没有适当的同步机制，就可能发生数据竞争（Data Race），导致程序行为不可预测甚至崩溃。互斥锁是一种最常用的同步机制，它确保在同一时刻只有一个线程能够访问被保护的共享资源，从而避免数据竞争。
Synchronized.h 的主要作用和定位可以概括为以下几点：
① 提供 RAII 风格的互斥锁封装：
⚝ Synchronized.h 提供的 Synchronized 类模板是基于 RAII (Resource Acquisition Is Initialization) 原则设计的。RAII 是一种 C++ 编程技术，它将资源的获取和释放与对象的生命周期绑定在一起。
⚝ Synchronized 对象在构造时尝试获取锁，在析构时自动释放锁。这种机制极大地简化了锁的管理，避免了手动 lock() 和 unlock() 可能导致的错误，例如忘记释放锁或在异常情况下锁未被释放。
② 简化互斥锁的使用：
⚝ Synchronized.h 隐藏了底层的锁管理细节，提供了一个更简洁、更易于使用的接口。开发者无需显式地调用 lock() 和 unlock()，只需创建一个 Synchronized 对象即可自动完成锁的获取和释放。
⚝ 这降低了并发编程的复杂性，提高了代码的可读性和可维护性。
③ 提高代码的安全性：
⚝ RAII 机制确保了即使在发生异常的情况下，锁也能够被正确释放，避免了死锁（Deadlock） 等问题。
⚝ 通过自动化的锁管理，减少了人为错误的可能性，提高了程序的健壮性。
④ 提供多种互斥锁类型支持：
⚝ Synchronized.h 不仅支持标准的互斥锁（std::mutex），还支持共享互斥锁（Shared Mutex），例如 folly::SharedMutex 和 std::shared_mutex。共享互斥锁允许多个线程同时读取共享资源，但只允许一个线程写入，这在读多写少的场景下可以提高并发性能。
⚝ Synchronized.h 还提供了对递归互斥锁（Recursive Mutex） 的支持，尽管在大多数情况下应尽量避免使用递归锁。
⑤ 与 Folly 库的其他组件协同工作：
⚝ Synchronized.h 是 Folly 库并发工具箱中的重要组成部分，它可以与其他 Folly 组件，例如 Future/Promise、EventBase 等，协同工作，构建更复杂的并发系统。
⚝ 例如，可以使用 Synchronized 保护 Future 的状态，确保异步操作的线程安全性。
在 Folly 库的并发工具体系中，Synchronized.h 定位为基础且核心的同步机制。它主要解决的是互斥访问共享资源的问题，是构建更高级并发抽象的基础。相对于其他更复杂的并发工具，例如无锁数据结构或事务内存，Synchronized.h 更侧重于提供一种简单、安全、高效的互斥锁封装，适用于大多数需要线程同步的场景。
总而言之，Synchronized.h 在 Folly 库中扮演着基石的角色，它通过 RAII 风格的封装，简化了互斥锁的使用，提高了代码的安全性，并为构建更复杂的并发系统提供了基础。对于需要进行并发编程的 C++ 开发者来说，Synchronized.h 是一个非常实用且重要的工具。
2.3 Synchronized.h 的设计哲学 (Design Philosophy of Synchronized.h)
Synchronized.h 的设计哲学主要围绕以下几个核心原则：安全、易用、高效、灵活。这些原则共同塑造了 Synchronized.h 的特性和功能，使其成为一个优秀的并发编程工具。
① 安全性 (Safety)：
⚝ RAII 保证：Synchronized.h 最核心的设计理念是基于 RAII 原则。通过将互斥锁的生命周期与 Synchronized 对象的生命周期绑定，确保了锁的自动获取和释放。无论代码执行路径如何（正常返回或抛出异常），锁都能够被正确释放，避免了资源泄漏和死锁的风险。
⚝ 减少人为错误：手动管理锁容易出错，例如忘记释放锁、重复释放锁、或者在异常处理中遗漏锁的释放。Synchronized.h 的 RAII 封装极大地减少了人为错误的可能性，提高了代码的健壮性。
⚝ 类型安全：Synchronized 是一个类模板，通过模板参数指定要保护的数据类型和底层的互斥锁类型，提供了类型安全的保障。
② 易用性 (Ease of Use)：
⚝ 简洁的 API：Synchronized.h 提供了简洁明了的 API。开发者只需要创建 Synchronized 对象，即可自动完成锁的获取和释放。无需显式调用 lock() 和 unlock()，降低了学习和使用的门槛。
⚝ 直观的代码：使用 Synchronized 可以使并发代码更加直观易懂。通过 Synchronized 对象的作用域，可以清晰地看到哪些代码段受到了互斥锁的保护。
⚝ 默认行为友好：Synchronized 默认使用 std::mutex 作为底层的互斥锁，这是一种广泛使用且性能良好的通用互斥锁。对于大多数场景，默认配置即可满足需求，无需额外的配置。
③ 高效性 (Efficiency)：
⚝ 零开销抽象：Synchronized.h 的设计目标之一是提供零开销抽象（Zero-Overhead Abstraction）。这意味着 Synchronized 的封装不应该引入显著的性能损耗。实际上，Synchronized 的性能开销主要来自于底层互斥锁的开销，而 Synchronized 本身几乎没有额外的运行时开销。
⚝ 支持多种锁类型：Synchronized.h 支持多种互斥锁类型，包括 std::mutex、folly::SharedMutex、std::shared_mutex 等。开发者可以根据具体的应用场景选择合适的锁类型，以获得最佳的性能。例如，在读多写少的场景下，可以使用共享互斥锁来提高并发性能。
⚝ 避免不必要的锁竞争：虽然 Synchronized.h 简化了锁的使用，但其设计哲学也鼓励开发者思考如何减少锁竞争。例如，通过更细粒度的锁、读写锁、或者无锁数据结构等技术，来优化并发性能。
④ 灵活性 (Flexibility)：
⚝ 可定制的互斥锁类型：Synchronized 类模板允许用户自定义底层的互斥锁类型。这使得 Synchronized 可以适应不同的应用场景和性能需求。例如，可以使用自定义的、具有特殊性能特性的互斥锁。
⚝ 多种锁定方式：Synchronized 提供了多种锁定方式，例如 lock()、try_lock()、lock_shared()、try_lock_shared() 等。这些方法提供了不同的锁定语义，满足了不同的同步需求。
⚝ 与条件变量配合使用：Synchronized 可以与条件变量（std::condition_variable 或 folly::Baton）配合使用，构建更复杂的同步模式，例如生产者-消费者模型、读者-写者模型等。
总而言之，Synchronized.h 的设计哲学是在安全的前提下，追求易用性、高效性和灵活性的平衡。它通过 RAII 封装简化了互斥锁的使用，提高了代码的安全性，同时提供了多种选项和扩展点，以满足不同场景下的并发编程需求。这种设计哲学使得 Synchronized.h 成为一个强大而实用的并发工具，被广泛应用于 Facebook 的高性能 C++ 代码中。
2.4 为什么选择 Synchronized.h？(Why Choose Synchronized.h?)
在 C++ 并发编程中，我们有多种同步机制可供选择，包括标准库提供的 std::mutex、std::lock_guard、std::unique_lock、std::shared_mutex 等，以及 Folly 库自身提供的其他并发工具。那么，在众多的选择中，为什么我们要选择 Synchronized.h 呢？Synchronized.h 的优势和适用场景是什么？
选择 Synchronized.h 的理由主要体现在以下几个方面：
① 更高级别的抽象和易用性：
⚝ RAII 封装的优势：Synchronized.h 提供的 Synchronized 类模板是对互斥锁的 RAII 封装。相比于直接使用 std::mutex 和手动调用 lock()/unlock()，Synchronized 提供了更高级别的抽象，极大地简化了锁的管理。开发者无需关注锁的获取和释放细节，只需关注受保护的代码逻辑。
⚝ 代码简洁性：使用 Synchronized 可以使并发代码更加简洁、清晰。通过 Synchronized 对象的作用域，可以直观地表达代码的互斥访问意图，提高了代码的可读性和可维护性。
② 更高的安全性：
⚝ 自动化的锁管理：RAII 机制确保了锁的自动释放，避免了因人为疏忽导致的锁泄漏和死锁。即使在异常情况下，锁也能被正确释放，提高了程序的健壮性。
⚝ 减少错误的可能性：手动管理锁容易出错，例如忘记释放锁、重复释放锁、或者在复杂的控制流中遗漏锁的释放。Synchronized.h 的自动化锁管理机制减少了这些错误的可能性。
③ 更好的性能（在某些场景下）：
⚝ 零开销抽象：Synchronized.h 本身的设计目标是提供零开销抽象。其性能开销主要来自于底层的互斥锁操作。相比于手动管理锁，Synchronized 几乎没有额外的性能损耗。
⚝ 共享锁的支持：Synchronized.h 不仅支持独占锁，还支持共享锁（ReadWriteMutex）。在读多写少的场景下，使用共享锁可以显著提高并发性能。标准库的 std::shared_mutex 也提供了类似的功能，但 Synchronized.h 提供了更方便的 RAII 封装。
④ 与 Folly 库的集成：
⚝ 一致的风格和接口：如果你已经在项目中使用 Folly 库，那么使用 Synchronized.h 可以保持代码风格的一致性。Synchronized.h 与 Folly 库的其他组件（例如 Future/Promise、Baton 等）能够更好地协同工作。
⚝ 利用 Folly 库的优势：Folly 库本身就以高性能和高质量著称。Synchronized.h 作为 Folly 库的一部分，也继承了这些优点。
⑤ 更丰富的功能和灵活性：
⚝ 多种锁类型支持：Synchronized.h 不仅支持 std::mutex，还支持 folly::SharedMutex、std::shared_mutex 等多种互斥锁类型，提供了更多的选择。
⚝ 尝试锁和超时机制：Synchronized.h 提供了 try_lock() 和超时锁定等高级功能，可以应对更复杂的并发场景。
⚝ 条件变量的支持：Synchronized.h 可以与条件变量配合使用，构建更复杂的同步模式。
何时选择 Synchronized.h？
⚝ 需要 RAII 风格的互斥锁封装时：当你希望使用 RAII 机制来管理互斥锁，简化锁的使用，并提高代码安全性时，Synchronized.h 是一个非常好的选择。
⚝ 在 Folly 库的项目中：如果你的项目已经使用了 Folly 库，那么使用 Synchronized.h 可以保持代码风格的一致性，并更好地利用 Folly 库的优势。
⚝ 需要共享锁或更高级的锁功能时：当你需要在读多写少的场景下使用共享锁，或者需要尝试锁、超时锁定等高级功能时，Synchronized.h 提供了相应的支持。
⚝ 追求代码简洁性和可维护性时：Synchronized.h 可以使并发代码更加简洁、清晰，提高代码的可读性和可维护性。
何时可能不选择 Synchronized.h？
⚝ 只需要最基本的互斥锁功能时：如果你的场景非常简单，只需要最基本的互斥锁功能，并且对代码简洁性、安全性没有特别高的要求，那么直接使用 std::mutex 和 std::lock_guard 或 std::unique_lock 也可以满足需求。
⚝ 对 Folly 库有依赖顾虑时：如果你的项目不希望引入 Folly 库的依赖，或者对 Folly 库的体积或编译时间有顾虑，那么可以选择标准库提供的同步机制。
⚝ 需要更底层的控制时：在某些非常特殊的场景下，你可能需要对锁的控制更加精细，例如需要自定义锁的实现、或者需要进行非常底层的性能优化。这时，Synchronized.h 的抽象级别可能显得过高，你可能需要直接使用底层的互斥锁 API。
总的来说，Synchronized.h 是一个强大、易用且安全的并发编程工具，它通过 RAII 封装简化了互斥锁的使用，提高了代码的安全性，并在许多场景下提供了更好的性能和灵活性。对于大多数 C++ 并发编程任务，特别是当你在 Folly 库的环境中工作时，Synchronized.h 都是一个值得优先考虑的选择。
END_OF_CHAPTER
3. chapter 3：Synchronized 的基础使用 (Basic Usage of Synchronized)
3.1 Synchronized 类模板详解 (Detailed Explanation of Synchronized Class Template)
folly::Synchronized 是 Folly 库提供的一个强大的工具，用于简化 C++ 中的并发编程，特别是针对共享数据的保护。它是一个类模板，其核心思想是资源获取即初始化（RAII, Resource Acquisition Is Initialization） 与互斥锁（Mutex） 的结合。通过 Synchronized，开发者可以更加安全、便捷地管理互斥锁，从而避免常见的并发错误，如死锁和数据竞争。
Synchronized 类模板的基本形式如下：
1
template <typename T, typename Mutex = std::mutex>
2
class Synchronized;
这里，Synchronized 接受两个模板参数：
① T：表示需要保护的数据类型。可以是任何 C++ 类型，例如 int、std::string、自定义的类或结构体，甚至是复杂的数据结构如 std::vector 或 std::map。Synchronized 将会持有类型为 T 的数据实例。
② Mutex：表示底层的互斥锁类型，默认值为 std::mutex。这意味着，在默认情况下，Synchronized 使用标准的 std::mutex 来实现互斥访问控制。当然，你也可以根据具体需求，传入其他满足互斥锁（Mutex） 要求的类型，例如 std::recursive_mutex 或 Folly 库中提供的其他自定义互斥锁类型。
核心功能：
Synchronized 的主要作用是提供对内部数据 T 的互斥访问。这意味着，在任何时刻，只有一个线程可以访问或修改 Synchronized 对象内部的数据。所有对内部数据的访问都必须通过 Synchronized 对象提供的接口进行，而这些接口会自动处理加锁（lock） 和解锁（unlock） 的操作，确保线程安全。
基本使用方式：
要使用 Synchronized，首先需要创建一个 Synchronized 类型的对象，并将需要保护的数据作为构造函数的参数传入。例如，如果我们要保护一个整数 int 类型的变量，可以这样做：
1
#include <folly/Synchronized.h>
2
#include <iostream>
3
4
int main() {
5
folly::Synchronized<int> synchronized_int(0); // 初始化为 0
6
7
// ... 在多线程环境中访问和修改 synchronized_int ...
8
9
return 0;
10
}
创建 Synchronized 对象后，我们如何访问和修改其内部的数据呢？Synchronized 提供了 wlock() 和 rlock() 两个核心方法，用于获取写锁（write lock） 和读锁（read lock）。
⚝ wlock(): 返回一个写锁守卫对象（write lock guard object），通常是 folly::Synchronized<T, Mutex>::WriteLockGuard 类型。通过这个守卫对象，你可以独占式地访问和修改 Synchronized 对象内部的数据。当守卫对象超出作用域时，写锁会自动释放。
⚝ rlock(): 返回一个读锁守卫对象（read lock guard object），通常是 folly::Synchronized<T, Mutex>::ReadLockGuard 类型。通过这个守卫对象，你可以共享式地读取 Synchronized 对象内部的数据。允许多个线程同时持有读锁，但不允许与写锁同时持有。当守卫对象超出作用域时，读锁会自动释放。（注意：rlock() 仅在 Mutex 类型支持共享锁时可用，例如当 Mutex 是 folly::ReadWriteMutex 或 std::shared_mutex 时。对于默认的 std::mutex，rlock() 的行为与 wlock() 相同，提供独占访问。）
对于基础的互斥锁 std::mutex，我们通常使用 wlock() 来获取锁并访问数据。例如，要增加上面例子中的 synchronized_int 的值，可以这样做：
1
{ // 引入作用域，以便演示 RAII
2
auto lock = synchronized_int.wlock(); // 获取写锁
3
*lock += 1; // 通过解引用守卫对象访问内部数据并修改
4
std::cout << "Current value: " << *lock << std::endl;
5
// lock 在这里超出作用域，写锁自动释放
6
}
总结：
Synchronized<T, Mutex> 类模板是 Folly 库中用于线程安全数据访问的关键工具。它通过封装互斥锁和 RAII 机制，简化了并发编程，并降低了因锁管理不当而引入错误的风险。理解其模板参数、核心方法 wlock() 和 rlock()，以及 RAII 的工作原理，是掌握 Synchronized 基础使用的关键。在后续章节中，我们将深入探讨 Synchronized 的高级特性和应用场景。
3.2 互斥锁 (Mutex) 的概念与应用 (Concept and Application of Mutex)
互斥锁（Mutex，Mutual Exclusion Lock） 是并发编程中最基础也是最重要的同步机制之一。它的核心作用是保护临界区（Critical Section），确保在任何时刻，只有一个线程可以访问被保护的代码段或共享资源。互斥锁通过锁定（lock） 和解锁（unlock） 操作来实现这一目标。
互斥锁的基本概念：
① 互斥性（Mutual Exclusion）: 这是互斥锁最核心的特性。当一个线程成功获取（锁定）互斥锁后，其他任何线程都必须等待，直到持有锁的线程释放（解锁）锁。这种排他性的访问保证了在临界区内的操作是原子性的，避免了竞态条件（Race Condition） 和数据竞争（Data Race）。
② 锁定（Lock）: 线程尝试获取互斥锁的操作。如果互斥锁当前未被其他线程持有，则线程成功获取锁，并可以进入临界区执行代码。如果互斥锁已被其他线程持有，则尝试获取锁的线程会被阻塞（block），进入等待状态，直到锁被释放。
③ 解锁（Unlock）: 持有互斥锁的线程在完成临界区代码的执行后，必须释放互斥锁。释放锁的操作会唤醒等待队列中的一个或多个线程（通常是按照等待顺序唤醒），使其有机会尝试获取锁。
互斥锁的应用场景：
互斥锁广泛应用于需要保护共享资源或临界区的并发场景，例如：
⚝ 保护共享数据: 多个线程需要读写同一个变量、数据结构或对象时，为了防止数据竞争，需要使用互斥锁保护对这些共享数据的访问。例如，线程安全的计数器、线程安全的队列等。
⚝ 控制资源访问: 当多个线程需要访问有限的资源，如文件、网络连接、打印机等，可以使用互斥锁来控制对这些资源的并发访问，避免资源冲突或错误使用。
⚝ 实现同步: 互斥锁可以作为更高级同步机制的基础，例如条件变量（Condition Variable）、信号量（Semaphore） 等。通过互斥锁和条件变量的结合，可以实现更复杂的线程同步和协作模式。
std::mutex 和 folly::Mutex:
C++ 标准库提供了 std::mutex 类，作为标准的互斥锁实现。Folly 库也提供了 folly::Mutex，它在 std::mutex 的基础上进行了一些扩展和优化，但在基本功能上与 std::mutex 类似。在 folly::Synchronized 中，默认使用的互斥锁类型就是 std::mutex。
互斥锁的使用示例 (std::mutex):
下面是一个使用 std::mutex 保护共享变量的简单示例：
1
#include <iostream>
2
#include <thread>
3
#include <mutex>
4
5
int shared_counter = 0;
6
std::mutex counter_mutex; // 定义一个互斥锁
7
8
void increment_counter() {
9
for (int i = 0; i < 100000; ++i) {
10
std::lock_guard<std::mutex> lock(counter_mutex); // RAII 风格的加锁
11
shared_counter++; // 临界区：访问共享变量
12
}
13
}
14
15
int main() {
16
std::thread t1(increment_counter);
17
std::thread t2(increment_counter);
18
19
t1.join();
20
t2.join();
21
22
std::cout << "Final counter value: " << shared_counter << std::endl; // 预期输出：200000
23
24
return 0;
25
}
在这个例子中，counter_mutex 用于保护 shared_counter 变量。std::lock_guard 是一个 RAII 风格的互斥锁包装器，它在构造时自动锁定互斥锁，在析构时自动解锁互斥锁，确保了互斥锁的正确使用，避免了忘记解锁或因异常导致锁未释放的问题。
Synchronized 与互斥锁的关系:
folly::Synchronized 的核心就是封装了互斥锁。当你创建一个 folly::Synchronized<T> 对象时，内部实际上包含了一个 std::mutex 对象（默认情况下）和一个类型为 T 的数据对象。Synchronized 提供的 wlock() 和 rlock() 方法，实际上就是对内部互斥锁的 lock() 和 unlock() 操作的封装，并结合 RAII 机制，使得互斥锁的使用更加安全和方便。
总结：
互斥锁是并发编程中用于保护临界区、实现互斥访问的关键工具。理解互斥锁的概念、应用场景以及如何正确使用互斥锁（特别是结合 RAII 风格的锁守卫对象），是编写线程安全代码的基础。folly::Synchronized 正是基于互斥锁，并提供了更高级、更易用的接口，帮助开发者更好地管理并发访问。
3.3 使用 Synchronized 保护共享数据 (Protecting Shared Data with Synchronized)
使用 folly::Synchronized 保护共享数据是其最主要的应用场景。通过 Synchronized，我们可以确保对共享数据的访问是线程安全的，避免数据竞争和不确定性行为。
保护共享数据的步骤：
① 确定需要保护的共享数据: 首先，需要识别程序中哪些数据会被多个线程同时访问和修改。这些数据就是需要使用 Synchronized 保护的共享数据。例如，全局变量、静态变量、在多个线程间传递的对象等。
② 创建 Synchronized 对象: 对于每个需要保护的共享数据，创建一个 folly::Synchronized 对象，并将共享数据作为构造函数的参数传入。例如：
1
folly::Synchronized<int> shared_int(0); // 保护一个 int 类型的共享变量
2
folly::Synchronized<std::vector<int>> shared_vector; // 保护一个 vector 类型的共享变量
③ 使用 wlock() 或 rlock() 获取锁: 在任何线程中，当需要访问或修改 Synchronized 对象内部的共享数据时，必须先调用 wlock()（写访问）或 rlock()（读访问，如果底层互斥锁支持）方法获取相应的锁。
④ 通过锁守卫对象访问数据: wlock() 和 rlock() 方法返回的是锁守卫对象，通过解引用锁守卫对象（*lock），可以访问到 Synchronized 对象内部的共享数据。对数据的操作都应该在这个解引用的对象上进行。
⑤ 锁的自动释放: 当锁守卫对象超出作用域时，锁会自动释放。这是 RAII 机制的关键，确保了锁的正确释放，即使在发生异常的情况下也能保证锁被释放，避免死锁。
代码示例：线程安全的共享计数器 (使用 Synchronized):
下面是一个使用 folly::Synchronized 实现线程安全计数器的示例：
1
#include <folly/Synchronized.h>
2
#include <iostream>
3
#include <thread>
4
#include <vector>
5
6
folly::Synchronized<int> shared_counter(0); // 使用 Synchronized 保护计数器
7
8
void increment_counter() {
9
for (int i = 0; i < 100000; ++i) {
10
auto lock = shared_counter.wlock(); // 获取写锁
11
(*lock)++; // 临界区：通过解引用锁守卫对象访问和修改计数器
12
}
13
}
14
15
int main() {
16
std::vector<std::thread> threads;
17
for (int i = 0; i < 2; ++i) {
18
threads.emplace_back(increment_counter);
19
}
20
21
for (auto& thread : threads) {
22
thread.join();
23
}
24
25
auto lock = shared_counter.rlock(); // 获取读锁，用于读取最终结果
26
std::cout << "Final counter value: " << *lock << std::endl; // 预期输出：200000
27
28
return 0;
29
}
在这个例子中，shared_counter 被声明为 folly::Synchronized<int> 类型，从而受到 Synchronized 的保护。在 increment_counter 函数中，每次访问和修改 shared_counter 的值时，都必须先通过 shared_counter.wlock() 获取写锁。这样就保证了在任何时刻，只有一个线程可以修改 shared_counter 的值，避免了数据竞争。在 main 函数的最后，我们使用 shared_counter.rlock() 获取读锁来读取最终的计数器值。
优势：
⚝ 简洁易用: 使用 Synchronized 保护共享数据，代码更加简洁明了，避免了手动管理互斥锁的繁琐和容易出错的问题。
⚝ RAII 保证: RAII 机制确保了锁的自动管理，降低了因忘记解锁或异常导致锁未释放的风险，提高了代码的健壮性。
⚝ 类型安全: Synchronized 是一个类模板，可以保护任何类型的数据，提供了类型安全的保护机制。
注意事项：
⚝ 过度保护: 不要过度使用 Synchronized 保护不必要的数据。过多的锁竞争会降低程序的并发性能。只保护真正需要在多线程环境下共享和修改的数据。
⚝ 锁的粒度: 合理选择锁的粒度。粗粒度锁（保护大范围的数据或代码）可能导致较低的并发度，细粒度锁（保护小范围的数据或代码）虽然可以提高并发度，但会增加锁管理的复杂性。根据实际情况权衡选择合适的锁粒度。
⚝ 死锁避免: 在使用多个 Synchronized 对象时，需要注意避免死锁的发生。遵循一定的锁获取顺序，或者使用超时锁等机制，可以降低死锁的风险。
总结：
folly::Synchronized 提供了一种简单、安全、高效的方式来保护共享数据。通过将共享数据包装在 Synchronized 对象中，并使用 wlock() 和 rlock() 方法获取锁进行访问，可以有效地避免数据竞争，编写出线程安全的代码。理解如何正确使用 Synchronized 保护共享数据，是进行并发编程的关键技能。
3.4 RAII 与锁的自动管理 (RAII and Automatic Lock Management)
RAII（Resource Acquisition Is Initialization，资源获取即初始化） 是一种 C++ 编程技术，它将资源的生命周期与对象的生命周期绑定在一起。在 RAII 中，资源在对象构造时被获取（初始化），在对象析构时被释放。这种机制可以确保资源在任何情况下都能被正确释放，即使在发生异常的情况下也不例外。
RAII 在锁管理中的应用:
在并发编程中，互斥锁是一种典型的需要进行资源管理的资源。如果手动管理互斥锁的加锁（lock） 和解锁（unlock） 操作，很容易出现以下问题：
⚝ 忘记解锁: 如果在临界区代码执行完毕后忘记调用 unlock()，会导致互斥锁一直被持有，造成死锁或性能问题。
⚝ 异常安全问题: 如果在临界区代码执行过程中抛出异常，并且在异常处理代码中没有正确解锁，也会导致锁未释放。
RAII 技术可以很好地解决这些问题。通过将互斥锁的加锁和解锁操作封装在一个锁守卫对象（Lock Guard Object） 中，利用锁守卫对象的构造函数和析构函数，可以实现锁的自动管理。
folly::Synchronized 中的 RAII:
folly::Synchronized 完美地应用了 RAII 技术来实现锁的自动管理。当我们调用 synchronized_object.wlock() 或 synchronized_object.rlock() 时，返回的锁守卫对象（例如 folly::Synchronized<T>::WriteLockGuard）就是 RAII 的体现。
⚝ 构造函数: 锁守卫对象的构造函数中会自动调用底层互斥锁的 lock() 方法，获取锁。
⚝ 析构函数: 锁守卫对象的析构函数中会自动调用底层互斥锁的 unlock() 方法，释放锁。
由于锁的获取和释放分别发生在锁守卫对象的构造和析构阶段，而对象的生命周期由作用域控制，因此，当锁守卫对象超出作用域时（例如，函数返回、代码块结束），其析构函数会被自动调用，从而保证了锁的自动释放。
3.4.1 lock() 和 unlock() 方法 (The lock() and unlock() Methods)
虽然 folly::Synchronized 的设计理念是提倡使用 RAII 风格的锁管理，即通过 wlock() 和 rlock() 返回的锁守卫对象进行自动锁管理，但 Synchronized 类本身也提供了 lock() 和 unlock() 方法，允许用户手动管理锁。
⚝ lock() 方法: Synchronized::lock() 方法会显式地获取内部的互斥锁。调用 lock() 方法的线程会被阻塞，直到成功获取锁。
⚝ unlock() 方法: Synchronized::unlock() 方法会显式地释放内部的互斥锁。释放锁后，等待队列中的其他线程可以尝试获取锁。
手动管理锁的示例:
1
#include <folly/Synchronized.h>
2
#include <iostream>
3
#include <thread>
4
5
folly::Synchronized<int> shared_value(0);
6
7
void modify_value() {
8
shared_value.lock(); // 手动加锁
9
try {
10
*shared_value.wlock() += 10; // 访问和修改共享数据
11
std::cout << "Value modified by thread " << std::this_thread::get_id() << std::endl;
12
} catch (...) {
13
shared_value.unlock(); // 异常处理中也要解锁
14
throw; // 重新抛出异常
15
}
16
shared_value.unlock(); // 手动解锁
17
}
18
19
int main() {
20
std::thread t1(modify_value);
21
std::thread t2(modify_value);
22
23
t1.join();
24
t2.join();
25
26
std::cout << "Final value: " << *shared_value.rlock() << std::endl;
27
28
return 0;
29
}
在这个例子中，我们直接调用 shared_value.lock() 和 shared_value.unlock() 来手动管理锁的生命周期。注意，在使用手动锁管理时，务必确保在所有可能的代码路径（包括异常处理路径）中都正确地调用 unlock()，否则容易造成死锁或资源泄漏。
不推荐手动管理锁:
虽然 Synchronized 提供了 lock() 和 unlock() 方法，但强烈建议使用 RAII 风格的 wlock() 和 rlock() 方法进行锁管理。手动管理锁容易出错，尤其是在复杂的代码逻辑和异常处理场景下。RAII 风格的锁管理更加安全、可靠，并且代码也更简洁易懂。
3.4.2 构造函数与析构函数 (Constructors and Destructors)
folly::Synchronized 的构造函数和析构函数在 RAII 机制中扮演着关键角色，但它们本身并不直接负责锁的获取和释放。锁的获取和释放是由 wlock() 和 rlock() 返回的锁守卫对象的构造函数和析构函数完成的。
Synchronized 类的构造函数:
Synchronized 类的构造函数主要负责初始化内部的数据对象和互斥锁对象。例如：
1
template <typename T, typename Mutex = std::mutex>
2
class Synchronized {
3
public:
4
// ...
5
6
// 构造函数，接受初始值
7
template <typename... Args>
8
explicit Synchronized(Args&&... args)
9
: value_(std::forward<Args>(args)...) {}
10
11
// 默认构造函数
12
Synchronized() = default;
13
14
// ...
15
private:
16
Mutex mutex_; // 内部互斥锁对象
17
T value_; // 内部数据对象
18
};
构造函数接受一个或多个参数，用于初始化内部的数据成员 value_。同时，构造函数也会初始化内部的互斥锁成员 mutex_。但构造函数本身并不执行任何加锁操作。
Synchronized 类的析构函数:
Synchronized 类的析构函数主要负责清理内部资源，例如销毁内部的数据对象和互斥锁对象。析构函数本身也不执行任何解锁操作。
1
template <typename T, typename Mutex = std::mutex>
2
class Synchronized {
3
public:
4
// ...
5
6
~Synchronized() = default; // 默认析构函数
7
8
// ...
9
private:
10
Mutex mutex_; // 内部互斥锁对象
11
T value_; // 内部数据对象
12
};
由于使用了默认析构函数，Synchronized 对象的析构过程会依次调用其成员变量 mutex_ 和 value_ 的析构函数，完成资源的清理。
锁管理的核心在锁守卫对象:
真正负责锁的获取和释放的是 wlock() 和 rlock() 方法返回的锁守卫对象，例如 WriteLockGuard 和 ReadLockGuard。这些锁守卫类通常是 Synchronized 类的内部类，它们的构造函数会调用 Synchronized 对象内部互斥锁的 lock() 方法，析构函数会调用 unlock() 方法。
总结:
folly::Synchronized 通过 RAII 技术实现了锁的自动管理。Synchronized 类的构造函数和析构函数负责初始化和清理内部资源，而锁的获取和释放则委托给 wlock() 和 rlock() 返回的锁守卫对象的构造函数和析构函数。这种设计使得锁的管理更加安全、方便，并降低了出错的风险。推荐使用 RAII 风格的 wlock() 和 rlock() 方法进行锁管理，避免手动管理锁可能带来的问题.
3.5 代码示例：线程安全的计数器 (Code Example: Thread-Safe Counter)
为了更好地理解 folly::Synchronized 的基础使用，我们来看一个完整的代码示例：线程安全的计数器。这个例子将演示如何使用 Synchronized 来保护一个共享的计数器变量，使其在多线程环境下能够正确地累加计数，避免数据竞争。
代码实现:
1
#include <folly/Synchronized.h>
2
#include <iostream>
3
#include <thread>
4
#include <vector>
5
6
class ThreadSafeCounter {
7
public:
8
ThreadSafeCounter() : counter_(0) {}
9
10
void increment() {
11
auto lock = counter_.wlock(); // 获取写锁
12
(*lock)++; // 临界区：增加计数器
13
}
14
15
int get_value() const {
16
auto lock = counter_.rlock(); // 获取读锁
17
return *lock; // 返回计数器的值
18
}
19
20
private:
21
folly::Synchronized<int> counter_; // 使用 Synchronized 保护计数器
22
};
23
24
void increment_task(ThreadSafeCounter& counter, int num_increments) {
25
for (int i = 0; i < num_increments; ++i) {
26
counter.increment();
27
}
28
}
29
30
int main() {
31
ThreadSafeCounter counter;
32
int num_threads = 4;
33
int num_increments_per_thread = 100000;
34
std::vector<std::thread> threads;
35
36
for (int i = 0; i < num_threads; ++i) {
37
threads.emplace_back(increment_task, std::ref(counter), num_increments_per_thread);
38
}
39
40
for (auto& thread : threads) {
41
thread.join();
42
}
43
44
std::cout << "Final counter value: " << counter.get_value() << std::endl;
45
std::cout << "Expected counter value: " << num_threads * num_increments_per_thread << std::endl;
46
47
return 0;
48
}
代码解析:
① ThreadSafeCounter 类: 我们定义了一个 ThreadSafeCounter 类，用于封装线程安全的计数器。
② folly::Synchronized<int> counter_: 在 ThreadSafeCounter 类中，我们使用 folly::Synchronized<int> 类型的成员变量 counter_ 来存储计数器的值。Synchronized 负责保护 counter_ 变量的并发访问。
③ increment() 方法: increment() 方法用于增加计数器的值。在方法内部，我们首先通过 counter_.wlock() 获取写锁，然后通过解引用锁守卫对象 (*lock)++ 来增加计数器的值。当 lock 对象超出作用域时，写锁会自动释放。
④ get_value() 方法: get_value() 方法用于获取计数器的当前值。由于只是读取计数器的值，我们使用 counter_.rlock() 获取读锁。然后返回解引用锁守卫对象 *lock 的值。当 lock 对象超出作用域时，读锁会自动释放。
⑤ increment_task() 函数: increment_task() 函数是线程的执行任务。它接受一个 ThreadSafeCounter 对象引用和增加次数作为参数，循环调用 counter.increment() 方法来增加计数器的值。
⑥ main() 函数: 在 main() 函数中，我们创建了一个 ThreadSafeCounter 对象 counter，并创建了多个线程（这里是 4 个）。每个线程都执行 increment_task() 函数，增加计数器 100000 次。最后，主线程等待所有子线程执行完成，并打印出最终的计数器值和期望值。
运行结果:
运行这段代码，你会看到输出的 "Final counter value" 与 "Expected counter value" 相等，都是 400000（4 线程 * 100000 次增加）。这表明，即使在多线程并发增加计数器的情况下，由于使用了 folly::Synchronized 进行保护，计数器的值仍然是正确的，没有发生数据竞争。
总结:
这个线程安全计数器的例子清晰地展示了如何使用 folly::Synchronized 来保护共享数据。通过将计数器变量包装在 Synchronized 对象中，并使用 wlock() 和 rlock() 方法进行加锁访问，我们成功地实现了线程安全的计数器。这个例子也体现了 Synchronized 的简洁性和易用性，以及 RAII 机制在锁管理中的优势。在实际的并发编程中，你可以借鉴这种模式，使用 Synchronized 来保护各种类型的共享数据，构建可靠的并发程序。
END_OF_CHAPTER
4. chapter 4：Synchronized 的高级特性与变体 (Advanced Features and Variants of Synchronized)
4.1 共享互斥锁 (Shared Mutex) 与 ReadWriteMutex (Shared Mutex and ReadWriteMutex)
在并发编程中，互斥锁（Mutex）是最常用的同步工具之一，用于保护共享资源免受并发访问的影响。然而，标准的互斥锁在任何时候只允许一个线程访问共享资源，即使是只读操作也不例外。这种排他性的锁定机制在某些场景下可能会成为性能瓶颈，尤其是在读操作远多于写操作的情况下。为了解决这个问题，folly::ReadWriteMutex，即读写锁（Read-Write Lock）应运而生。Synchronized.h 提供了对 ReadWriteMutex 的支持，允许我们更细粒度地控制对共享资源的访问。
4.1.1 读写锁的概念 (Concept of Read-Write Locks)
读写锁是一种更高级的互斥锁，它将对共享资源的访问权限分为两种模式：
① 读模式（Read Mode）或共享模式（Shared Mode）：允许多个线程同时持有读锁。这意味着多个线程可以并发地读取共享资源，而不会发生冲突。
② 写模式（Write Mode）或独占模式（Exclusive Mode）：只允许一个线程持有写锁。当一个线程持有写锁时，其他任何线程（包括读线程和写线程）都必须等待，直到写锁被释放。
读写锁的核心思想是区分读操作和写操作。由于读操作不会修改共享资源，因此多个读操作可以并发执行。而写操作会修改共享资源，为了保证数据的一致性和完整性，写操作必须是互斥的。
读写锁通常适用于以下场景：
⚝ 读多写少：当共享资源被频繁读取，但写入操作相对较少时，使用读写锁可以显著提高并发性能。允许多个线程同时读取数据，可以充分利用系统资源，减少线程等待时间。
⚝ 数据缓存：缓存系统通常具有读多写少的特点。多个线程可以同时读取缓存数据，只有在缓存失效或需要更新时才进行写操作。读写锁可以有效地保护缓存数据的一致性，并提高缓存的访问效率。
⚝ 配置管理：配置信息通常在程序启动时加载，并在运行期间被频繁读取，但修改配置的频率较低。使用读写锁可以允许多个线程并发读取配置信息，同时保证在修改配置时的数据安全。
4.1.2 ReadWriteMutex 的使用场景 (Use Cases of ReadWriteMutex)
folly::ReadWriteMutex 在 Synchronized.h 中被集成，可以方便地与 Synchronized 结合使用，为共享资源提供读写锁保护。以下是一些 ReadWriteMutex 的典型使用场景，并结合代码示例进行说明。
场景一：优化缓存系统的并发读取
假设我们有一个缓存系统，多个线程需要频繁读取缓存数据，但只有少数线程会更新缓存。使用标准的互斥锁会导致即使是读取操作也需要排队等待，降低了并发性能。使用 ReadWriteMutex 可以允许多个读线程同时访问缓存，提高读取效率。
1
#include <folly/Synchronized.h>
2
#include <folly/RWSpinLock.h>
3
#include <thread>
4
#include <iostream>
5
#include <vector>
6
7
using namespace folly;
8
9
class Cache {
10
public:
11
Cache() : data_("initial data") {}
12
13
std::string readData() {
14
// 获取读锁
15
auto guard = synchronized(rwMutex_.reader());
16
std::cout << "Thread " << std::this_thread::get_id() << " reading data: " << data_ << std::endl;
17
return data_;
18
}
19
20
void writeData(const std::string& newData) {
21
// 获取写锁
22
auto guard = synchronized(rwMutex_.writer());
23
std::cout << "Thread " << std::this_thread::get_id() << " writing data: " << newData << std::endl;
24
data_ = newData;
25
}
26
27
private:
28
RWSpinLock rwMutex_; // 读写自旋锁
29
std::string data_;
30
};
31
32
int main() {
33
Cache cache;
34
std::vector<std::thread> threads;
35
36
for (int i = 0; i < 5; ++i) {
37
threads.emplace_back([&cache]() {
38
cache.readData(); // 多个线程并发读取
39
});
40
}
41
42
threads.emplace_back([&cache]() {
43
cache.writeData("updated data"); // 单个线程写入
44
});
45
46
for (auto& thread : threads) {
47
thread.join();
48
}
49
50
return 0;
51
}
在这个例子中，Cache 类使用 folly::RWSpinLock 作为读写锁。readData() 方法使用 rwMutex_.reader() 获取读锁，允许多个线程同时读取 data_。writeData() 方法使用 rwMutex_.writer() 获取写锁，确保在写入数据时排他性访问。通过使用 ReadWriteMutex，可以提高缓存系统的并发读取性能。
场景二：保护共享配置信息的并发访问
配置信息通常在程序启动时加载，并在运行期间被多个线程频繁读取。使用 ReadWriteMutex 可以允许多个线程并发读取配置信息，同时保证在更新配置时的数据安全。
1
#include <folly/Synchronized.h>
2
#include <folly/RWSpinLock.h>
3
#include <thread>
4
#include <iostream>
5
#include <map>
6
7
using namespace folly;
8
9
class ConfigManager {
10
public:
11
ConfigManager() {
12
config_["param1"] = "value1";
13
config_["param2"] = "value2";
14
}
15
16
std::string getConfig(const std::string& key) {
17
// 获取读锁
18
auto guard = synchronized(rwMutex_.reader());
19
if (config_.count(key)) {
20
std::cout << "Thread " << std::this_thread::get_id() << " reading config: " << key << std::endl;
21
return config_[key];
22
}
23
return "";
24
}
25
26
void setConfig(const std::string& key, const std::string& value) {
27
// 获取写锁
28
auto guard = synchronized(rwMutex_.writer());
29
std::cout << "Thread " << std::this_thread::get_id() << " writing config: " << key << std::endl;
30
config_[key] = value;
31
}
32
33
private:
34
RWSpinLock rwMutex_; // 读写自旋锁
35
std::map<std::string, std::string> config_;
36
};
37
38
int main() {
39
ConfigManager configManager;
40
std::vector<std::thread> threads;
41
42
for (int i = 0; i < 5; ++i) {
43
threads.emplace_back([&configManager]() {
44
configManager.getConfig("param1"); // 多个线程并发读取配置
45
});
46
}
47
48
threads.emplace_back([&configManager]() {
49
configManager.setConfig("param2", "newValue2"); // 单个线程更新配置
50
});
51
52
for (auto& thread : threads) {
53
thread.join();
54
}
55
56
return 0;
57
}
在这个例子中，ConfigManager 类使用 folly::RWSpinLock 保护配置信息 config_。getConfig() 方法使用读锁允许多个线程并发读取配置，setConfig() 方法使用写锁确保在更新配置时的互斥访问。
选择合适的读写锁实现
folly::Synchronized 可以与不同的锁类型一起使用，包括 folly::RWSpinLock 和 std::shared_mutex。folly::RWSpinLock 是一个自旋锁，适用于锁竞争不激烈且临界区执行时间较短的场景。std::shared_mutex 是标准库提供的读写互斥锁，通常基于操作系统的互斥锁实现，适用于锁竞争可能比较激烈或临界区执行时间较长的场景。选择哪种读写锁取决于具体的应用场景和性能需求。
4.2 尝试锁 (Try Lock) 与超时机制 (Try Lock and Timeout Mechanism)
在某些并发场景中，线程可能不希望无限期地等待锁的释放。例如，线程可能需要执行一些非关键性任务，如果在等待锁的过程中耗时过长，可能会影响整体性能或用户体验。为了解决这个问题，Synchronized.h 提供了尝试锁（Try Lock）和超时机制，允许线程尝试获取锁，并在获取失败或超时后立即返回，而不是一直阻塞等待。
4.2.1 try_lock() 方法 (The try_lock() Method)
Synchronized 对象的 try_lock() 方法允许线程尝试非阻塞地获取锁。try_lock() 方法会立即返回，而不会阻塞线程。返回值表示锁是否成功获取：
① true：表示成功获取锁。线程可以进入临界区执行受保护的代码。
② false：表示获取锁失败。通常是因为锁已经被其他线程持有。线程需要根据实际情况决定后续操作，例如稍后重试或执行其他任务。
try_lock() 方法提供了一种避免死锁（Deadlock）的机制。当多个线程尝试以不同的顺序获取多个锁时，可能会发生死锁。使用 try_lock() 可以让线程在获取锁失败时立即释放已持有的锁，从而避免死锁的发生。
以下代码示例演示了 try_lock() 的基本用法：
1
#include <folly/Synchronized.h>
2
#include <thread>
3
#include <iostream>
4
5
using namespace folly;
6
7
Synchronized<Mutex> syncMutex;
8
9
void tryLockExample() {
10
if (syncMutex.try_lock()) {
11
// 成功获取锁，进入临界区
12
std::cout << "Thread " << std::this_thread::get_id() << " acquired lock." << std::endl;
13
std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 模拟临界区操作
14
syncMutex.unlock(); // 释放锁
15
std::cout << "Thread " << std::this_thread::get_id() << " released lock." << std::endl;
16
} else {
17
// 获取锁失败
18
std::cout << "Thread " << std::this_thread::get_id() << " failed to acquire lock." << std::endl;
19
}
20
}
21
22
int main() {
23
std::thread t1(tryLockExample);
24
std::thread t2(tryLockExample);
25
26
t1.join();
27
t2.join();
28
29
return 0;
30
}
在这个例子中，tryLockExample() 函数尝试使用 syncMutex.try_lock() 获取锁。如果成功获取锁，则进入临界区并执行一些操作，然后释放锁。如果获取锁失败，则输出提示信息。由于 try_lock() 是非阻塞的，线程不会一直等待锁的释放。
4.2.2 超时锁定的应用 (Applications of Timeout Locking)
除了 try_lock() 之外，Synchronized.h 还支持超时锁定（Timeout Locking），允许线程在尝试获取锁时指定一个超时时间。如果在指定的时间内未能获取到锁，则 try_lock_for() 或 try_lock_until() 方法会返回失败，线程可以继续执行其他操作。
Synchronized 并没有直接提供 try_lock_for() 或 try_lock_until() 这样的方法，但可以通过结合 std::chrono 库和底层的锁类型（例如 std::mutex 或 folly::SpinLock）来实现超时锁定。例如，对于 std::mutex，可以使用 std::mutex::try_lock_for() 和 std::mutex::try_lock_until() 方法。对于 folly::SpinLock，目前没有直接的超时锁定方法，但可以通过循环和时间判断来实现类似的功能。
以下代码示例演示了如何使用 std::mutex::try_lock_for() 实现超时锁定：
1
#include <folly/Synchronized.h>
2
#include <mutex>
3
#include <thread>
4
#include <iostream>
5
#include <chrono>
6
7
using namespace folly;
8
9
Synchronized<std::mutex> syncMutex;
10
11
void timeoutLockExample() {
12
auto timeout = std::chrono::milliseconds(50);
13
if (syncMutex.mutex().try_lock_for(timeout)) { // 使用 std::mutex::try_lock_for()
14
// 成功获取锁，进入临界区
15
std::cout << "Thread " << std::this_thread::get_id() << " acquired lock within timeout." << std::endl;
16
std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 模拟临界区操作
17
syncMutex.unlock(); // 释放锁
18
std::cout << "Thread " << std::this_thread::get_id() << " released lock." << std::endl;
19
} else {
20
// 超时未能获取锁
21
std::cout << "Thread " << std::this_thread::get_id() << " failed to acquire lock within timeout." << std::endl;
22
}
23
}
24
25
int main() {
26
std::thread t1(timeoutLockExample);
27
std::thread t2(timeoutLockExample);
28
29
t1.join();
30
t2.join();
31
32
return 0;
33
}
在这个例子中，timeoutLockExample() 函数使用 syncMutex.mutex().try_lock_for(timeout) 尝试在 50 毫秒内获取锁。如果成功获取锁，则进入临界区并执行操作。如果超时未能获取锁，则输出超时提示信息。超时锁定机制可以防止线程在等待锁时无限期阻塞，提高了程序的健壮性和响应性。
超时锁定的应用场景
⚝ 避免长时间等待：在某些场景下，线程不希望长时间等待锁的释放，例如在用户交互界面中，为了避免界面卡顿，可以使用超时锁定，如果一段时间内未能获取到锁，则放弃操作或提示用户。
⚝ 资源竞争激烈：当系统资源竞争激烈时，线程可能需要等待较长时间才能获取到锁。使用超时锁定可以限制线程的等待时间，避免因等待锁而导致系统性能下降。
⚝ 死锁检测与恢复：超时锁定可以作为死锁检测的一种辅助手段。如果线程在指定时间内未能获取到锁，可能意味着系统中存在潜在的死锁风险。结合其他死锁检测机制，可以实现死锁的自动恢复。
4.3 条件变量 (Condition Variable) 与等待/通知机制 (Wait/Notify Mechanism)
互斥锁可以保护共享资源免受并发访问的影响，但有时仅仅互斥是不够的。在某些并发场景中，线程可能需要在满足特定条件时才能继续执行，否则需要等待。例如，在生产者-消费者模型中，消费者线程需要在缓冲区非空时才能消费数据，否则需要等待生产者线程生产数据。条件变量（Condition Variable）就是为了解决这种线程同步问题而引入的。
条件变量通常与互斥锁一起使用，提供了一种线程等待特定条件成立的机制。当条件不满足时，线程可以释放互斥锁并进入等待状态。当条件满足时，其他线程可以通知等待线程，唤醒它们继续执行。Synchronized.h 提供了对条件变量的支持，允许我们构建更复杂的同步模式。
4.3.1 wait()，notify_one() 和 notify_all() 方法 (The wait(), notify_one(), and notify_all() Methods)
Synchronized 结合条件变量，主要使用以下几个关键方法来实现等待/通知机制：
① wait(Predicate pred)：使当前线程进入等待状态，直到被其他线程通知。wait() 方法必须在持有互斥锁的情况下调用。调用 wait() 时，会原子地释放互斥锁，并将线程置于等待队列中。当线程被唤醒时，wait() 会重新尝试获取互斥锁。wait(Predicate pred) 是一个带有谓词（Predicate）的重载版本，它接受一个返回布尔值的函数或函数对象 pred 作为参数。线程被唤醒后，会首先检查 pred() 的返回值。如果 pred() 返回 false，线程会继续等待；只有当 pred() 返回 true 时，线程才会真正从 wait() 方法返回。这可以避免虚假唤醒（Spurious Wakeup），即线程被唤醒但条件仍然不满足的情况。
② notify_one()：唤醒等待队列中的一个线程。如果有多个线程在等待同一个条件变量，notify_one() 只会唤醒其中一个线程，具体唤醒哪个线程取决于操作系统的调度策略。notify_one() 通常在条件满足时被调用，例如在生产者-消费者模型中，当生产者生产了一个新的数据项后，可以调用 notify_one() 唤醒一个消费者线程。
③ notify_all()：唤醒等待队列中的所有线程。与 notify_one() 不同，notify_all() 会唤醒所有等待同一个条件变量的线程。notify_all() 通常在条件发生重大变化，可能满足多个等待线程的条件时被调用。例如，在某个资源管理器中，当资源变得可用时，可以调用 notify_all() 唤醒所有等待资源的线程。
注意：wait(), notify_one(), 和 notify_all() 方法通常需要与 Synchronized 对象关联的互斥锁一起使用。Synchronized 默认使用的互斥锁类型是 folly::Mutex，也可以指定其他类型的互斥锁，例如 std::mutex。
4.3.2 构建复杂的同步模式 (Building Complex Synchronization Patterns)
条件变量和等待/通知机制可以用于构建各种复杂的同步模式，例如生产者-消费者模型、读者-写者模型、多线程任务队列等。以下以生产者-消费者模型为例，说明如何使用 Synchronized 和条件变量构建同步模式。
案例三：基于条件变量的生产者-消费者模型
生产者-消费者模型是一种经典的并发设计模式，用于解耦数据生产者和数据消费者之间的关系。生产者线程负责生产数据，并将数据放入缓冲区；消费者线程负责从缓冲区取出数据并进行处理。当缓冲区为空时，消费者线程需要等待；当缓冲区已满时，生产者线程可能需要等待。条件变量可以有效地协调生产者和消费者线程之间的同步。
1
#include <folly/Synchronized.h>
2
#include <folly/ProducerConsumerQueue.h> // 使用 folly 提供的 ProducerConsumerQueue 可以更方便地实现
3
#include <thread>
4
#include <iostream>
5
#include <vector>
6
#include <queue>
7
8
using namespace folly;
9
10
class MessageQueue {
11
public:
12
MessageQueue(int capacity) : capacity_(capacity) {}
13
14
void produce(int message) {
15
auto guard = synchronized(mutex_);
16
// 当队列满时，生产者等待
17
cv_.wait(guard, [this]() { return queue_.size() < capacity_; });
18
queue_.push(message);
19
std::cout << "Producer thread " << std::this_thread::get_id() << " produced message: " << message << ", queue size: " << queue_.size() << std::endl;
20
cv_.notify_one(); // 通知消费者线程
21
}
22
23
int consume() {
24
auto guard = synchronized(mutex_);
25
// 当队列空时，消费者等待
26
cv_.wait(guard, [this]() { return !queue_.empty(); });
27
int message = queue_.front();
28
queue_.pop();
29
std::cout << "Consumer thread " << std::this_thread::get_id() << " consumed message: " << message << ", queue size: " << queue_.size() << std::endl;
30
cv_.notify_one(); // 通知生产者线程 (可选，如果生产者也可能需要等待队列不满)
31
return message;
32
}
33
34
private:
35
Mutex mutex_;
36
ConditionVariable cv_;
37
std::queue<int> queue_;
38
int capacity_;
39
};
40
41
int main() {
42
MessageQueue messageQueue(5);
43
std::vector<std::thread> producers;
44
std::vector<std::thread> consumers;
45
46
for (int i = 0; i < 2; ++i) {
47
producers.emplace_back([&messageQueue]() {
48
for (int j = 0; j < 10; ++j) {
49
messageQueue.produce(j);
50
std::this_thread::sleep_for(std::chrono::milliseconds(50));
51
}
52
});
53
}
54
55
for (int i = 0; i < 2; ++i) {
56
consumers.emplace_back([&messageQueue]() {
57
for (int j = 0; j < 10; ++j) {
58
messageQueue.consume();
59
std::this_thread::sleep_for(std::chrono::milliseconds(80));
60
}
61
});
62
}
63
64
for (auto& producer : producers) {
65
producer.join();
66
}
67
for (auto& consumer : consumers) {
68
consumer.join();
69
}
70
71
return 0;
72
}
在这个生产者-消费者模型的例子中，MessageQueue 类使用 std::queue 作为缓冲区，folly::Mutex 和 folly::ConditionVariable 用于线程同步。produce() 方法在队列满时调用 cv_.wait() 等待，并在生产数据后调用 cv_.notify_one() 通知消费者线程。consume() 方法在队列空时调用 cv_.wait() 等待，并在消费数据后调用 cv_.notify_one() 通知生产者线程（可选，这里为了演示完整性也加上了）。通过条件变量的等待/通知机制，生产者和消费者线程可以有效地协同工作，实现数据的安全传递和处理。
总结
本章深入探讨了 Synchronized.h 的高级特性与变体，包括共享互斥锁 ReadWriteMutex、尝试锁 try_lock() 与超时机制，以及条件变量和等待/通知机制。这些高级特性扩展了 Synchronized 的应用范围，使其能够应对更复杂的并发场景，并提供更精细的同步控制。掌握这些高级特性，可以帮助开发者构建更高效、更健壮的并发程序。
END_OF_CHAPTER
5. chapter 5：Synchronized 的 API 全面解析 (Comprehensive API Analysis of Synchronized)
本章深入探讨 folly/Synchronized.h 库中核心组件的应用程序编程接口（API），旨在为读者提供详尽的参考和实践指导。我们将逐一解析 Synchronized 类模板和 ReadWriteMutex 类模板的关键 API，并介绍相关的辅助函数与类型。最后，我们将总结 API 使用的注意事项和最佳实践，帮助读者更有效地利用 Synchronized.h 构建高效、可靠的并发程序。
5.1 Synchronized 类模板的详细 API (Detailed API of Synchronized Class Template)
Synchronized 是 folly/Synchronized.h 中最核心的类模板，它将互斥锁（Mutex）与数据对象封装在一起，提供了线程安全地访问共享数据的机制。其类模板定义如下：
1
template <typename Mutexable, typename Object, typename... Args>
2
class Synchronized;
3
4
template <typename Object, typename... Args>
5
using Mutex = Synchronized<std::mutex, Object, Args...>; // 默认使用 std::mutex 的别名
其中：
⚝ Mutexable：指定底层互斥锁的类型，默认为 std::mutex。用户可以根据需要选择其他满足 Mutex 要求的类型，例如 folly::SharedMutex 或自定义的互斥锁类型。
⚝ Object：指定被保护的共享数据对象的类型。
⚝ Args...：用于在 Synchronized 对象内部构造 Object 对象的构造函数参数。
以下详细解析 Synchronized 类模板的主要 API：
构造函数 (Constructors)
① 默认构造函数 (Default Constructor)
1
Synchronized() noexcept;
⚝ 功能：创建一个 Synchronized 对象，内部使用默认构造函数构造 Mutexable 和 Object 对象。
⚝ 参数：无。
⚝ 返回值：无。
⚝ 异常：不抛出异常 (noexcept)。
⚝ 使用示例：
1
#include <folly/Synchronized.h>
2
#include <iostream>
3
4
int main() {
5
folly::Synchronized<std::mutex, int> synchronized_int; // 使用默认构造函数
6
std::cout << "Synchronized object created." << std::endl;
7
return 0;
8
}
② 带对象构造参数的构造函数 (Constructor with Object Arguments)
1
template <typename... CtorArgs>
2
explicit Synchronized(CtorArgs&&... args);
⚝ 功能：创建一个 Synchronized 对象，并使用 args... 作为参数转发给 Object 类型的构造函数，在内部构造 Object 对象。Mutexable 对象使用默认构造函数构造。
⚝ 参数：
▮▮▮▮⚝ args...：转发给 Object 构造函数的参数。
⚝ 返回值：无。
⚝ 异常：如果 Object 的构造函数抛出异常，则该构造函数也会抛出相同的异常。
⚝ 使用示例：
1
#include <folly/Synchronized.h>
2
#include <string>
3
#include <iostream>
4
5
int main() {
6
folly::Synchronized<std::mutex, std::string> synchronized_string("Hello, Synchronized!"); // 使用带参数的构造函数
7
std::cout << "Synchronized string created: " << *synchronized_string.rlock() << std::endl;
8
return 0;
9
}
③ 拷贝构造函数 (Copy Constructor)
1
Synchronized(const Synchronized&) = delete;
⚝ 功能：被删除 (deleted)。Synchronized 对象不可拷贝。
⚝ 原因：拷贝 Synchronized 对象可能会导致多个 Synchronized 对象管理同一个互斥锁和数据，从而破坏互斥锁的排他性，引发并发问题。
⚝ 使用尝试：如果尝试使用拷贝构造函数，编译器会报错。
④ 移动构造函数 (Move Constructor)
1
Synchronized(Synchronized&&) = delete;
⚝ 功能：被删除 (deleted)。Synchronized 对象不可移动。
⚝ 原因：类似于拷贝构造函数，移动 Synchronized 对象也可能引入复杂的所有权和生命周期管理问题，因此被禁用。
⚝ 使用尝试：如果尝试使用移动构造函数，编译器会报错。
析构函数 (Destructor)
1
~Synchronized();
⚝ 功能：销毁 Synchronized 对象。析构函数会负责销毁内部的 Mutexable 对象和 Object 对象。
⚝ 参数：无。
⚝ 返回值：无。
⚝ 异常：不抛出异常 (noexcept)。
⚝ 注意事项：在 Synchronized 对象析构之前，应确保所有持有该对象锁的线程都已经释放锁，否则可能导致未定义行为。通常，RAII 机制会自动处理锁的释放，无需手动干预。
lock() 和 unlock() 方法 (The lock() and unlock() Methods)
Synchronized 类本身不直接提供 lock() 和 unlock() 方法。锁的获取和释放是通过其返回的 锁卫士 (Lock Guard) 对象来实现的，这是 RAII (Resource Acquisition Is Initialization) 惯用法在并发编程中的体现。
Synchronized 提供了以下方法来获取不同类型的锁卫士：
① lock() 方法
1
auto lock() &;
2
auto lock() const& = delete;
3
auto lock() && = delete;
4
auto lock() const&& = delete;
⚝ 功能：获取排他锁（Exclusive Lock）。返回一个 可写锁卫士 (Write Lock Guard) 对象，通常是 folly::Synchronized<Mutexable, Object>::WriteLock 类型。
⚝ 返回值：一个可写锁卫士对象。当锁卫士对象被创建时，会自动调用底层互斥锁的 lock() 方法尝试获取锁。当锁卫士对象生命周期结束时（例如超出作用域），会自动调用互斥锁的 unlock() 方法释放锁。
⚝ 异常：如果底层互斥锁的 lock() 方法抛出异常，则 lock() 方法也会抛出相同的异常。例如，std::mutex::lock() 在某些情况下可能抛出 std::system_error 异常。
⚝ 使用示例：
1
#include <folly/Synchronized.h>
2
#include <iostream>
3
#include <thread>
4
5
folly::Synchronized<std::mutex, int> counter(0);
6
7
void increment_counter() {
8
for (int i = 0; i < 100000; ++i) {
9
auto locked_counter = counter.lock(); // 获取排他锁
10
*locked_counter += 1; // 线程安全地访问和修改共享计数器
11
}
12
}
13
14
int main() {
15
std::thread t1(increment_counter);
16
std::thread t2(increment_counter);
17
18
t1.join();
19
t2.join();
20
21
std::cout << "Counter value: " << *counter.rlock() << std::endl; // 最终计数器值应为 200000
22
return 0;
23
}
② rlock() 方法
1
auto rlock() &;
2
auto rlock() const&;
3
auto rlock() && = delete;
4
auto rlock() const&& = delete;
⚝ 功能：获取只读锁卫士 (Read Lock Guard) 对象，通常是 folly::Synchronized<Mutexable, Object>::ReadLock 类型。即使底层互斥锁是排他锁（如 std::mutex），rlock() 仍然返回一个只读锁卫士，强调通过此锁卫士访问的数据应被视为只读的。
⚝ 返回值：一个只读锁卫士对象。锁的获取和释放机制与 lock() 返回的可写锁卫士类似。
⚝ 异常：与 lock() 方法相同，取决于底层互斥锁的 lock() 方法。
⚝ 使用场景：当你只需要读取 Synchronized 对象内部的数据，而不需要修改它时，应该使用 rlock() 获取只读锁卫士。这有助于提高并发性能，尤其是在使用支持读写锁的 Mutexable 类型（如 folly::SharedMutex）时，允许多个线程同时读取数据。
⚝ 使用示例：在上面的计数器示例中，主线程最后使用 counter.rlock() 来读取最终的计数器值，因为此时只需要读取，不需要修改。
③ try_lock() 方法
1
auto try_lock() &;
2
auto try_lock() const& = delete;
3
auto try_lock() && = delete;
4
auto try_lock() const&& = delete;
⚝ 功能：尝试获取排他锁，非阻塞。返回一个 可写尝试锁卫士 (Write Try Lock Guard) 对象，通常是 folly::Synchronized<Mutexable, Object>::WriteTryLock 类型。
⚝ 返回值：一个可写尝试锁卫士对象。与 lock() 返回的锁卫士不同，尝试锁卫士的构造函数会调用底层互斥锁的 try_lock() 方法尝试获取锁。
▮▮▮▮⚝ 如果成功获取锁，锁卫士对象会持有锁，且可以像普通锁卫士一样使用。
▮▮▮▮⚝ 如果获取锁失败（例如，锁已被其他线程持有），锁卫士对象将不持有锁，可以通过锁卫士对象的 operator bool() 检查是否成功获取锁。
⚝ 异常：如果底层互斥锁的 try_lock() 方法抛出异常，则 try_lock() 方法也会抛出相同的异常。
⚝ 使用场景：适用于需要非阻塞地尝试获取锁的场景，例如避免死锁、实现超时机制等。
⚝ 使用示例：
1
#include <folly/Synchronized.h>
2
#include <iostream>
3
#include <thread>
4
#include <chrono>
5
6
folly::Synchronized<std::mutex, int> resource(0);
7
8
void try_access_resource() {
9
auto locked_resource = resource.try_lock(); // 尝试获取锁
10
if (locked_resource) {
11
std::cout << "Thread " << std::this_thread::get_id() << " acquired lock and accessed resource." << std::endl;
12
*locked_resource = 100; // 访问资源
13
// 锁在 locked_resource 超出作用域时自动释放
14
} else {
15
std::cout << "Thread " << std::this_thread::get_id() << " failed to acquire lock." << std::endl;
16
}
17
}
18
19
int main() {
20
std::thread t1(try_access_resource);
21
std::thread t2(try_access_resource);
22
23
t1.join();
24
t2.join();
25
26
std::cout << "Resource value: " << *resource.rlock() << std::endl;
27
return 0;
28
}
④ try_rlock() 方法
1
auto try_rlock() &;
2
auto try_rlock() const&;
3
auto try_rlock() && = delete;
4
auto try_rlock() const&& = delete;
⚝ 功能：尝试获取只读锁，非阻塞。返回一个 只读尝试锁卫士 (Read Try Lock Guard) 对象，通常是 folly::Synchronized<Mutexable, Object>::ReadTryLock 类型。
⚝ 返回值：一个只读尝试锁卫士对象。行为和 try_lock() 类似，但获取的是只读锁。
⚝ 异常：与 try_lock() 方法相同，取决于底层互斥锁的 try_lock() 方法。
⚝ 使用场景：非阻塞地尝试获取只读锁的场景。
⚝ 使用示例：类似于 try_lock() 的示例，只需将 resource.try_lock() 替换为 resource.try_rlock()，并确保在锁卫士作用域内只进行只读操作。
operator->() 和 operator*() 方法 (The operator->() and operator*() Methods)
Synchronized 类模板重载了 operator->() 和 operator*() 运算符，用于方便地访问被保护的 Object 对象。
① operator->() 方法
1
Object* operator->() &;
2
const Object* operator->() const&;
⚝ 功能：返回指向被保护的 Object 对象的指针。
▮▮▮▮⚝ 非 const 版本 (operator->() &)：返回指向 Object 对象的可修改的指针。必须在持有排他锁卫士 (Write Lock Guard 或 Write Try Lock Guard) 的情况下调用。
▮▮▮▮⚝ const 版本 (const Object* operator->() const&)：返回指向 Object 对象的 const 指针。可以在持有只读锁卫士 (Read Lock Guard 或 Read Try Lock Guard) 或排他锁卫士的情况下调用。
⚝ 返回值：指向 Object 对象的指针 (Object* 或 const Object*)。
⚝ 异常：无。
⚝ 使用示例：
1
#include <folly/Synchronized.h>
2
#include <string>
3
#include <iostream>
4
5
int main() {
6
folly::Synchronized<std::mutex, std::string> synchronized_string("Initial String");
7
8
{
9
auto locked_string = synchronized_string.lock();
10
locked_string->append(" - Modified with operator->"); // 使用 operator-> 修改字符串
11
}
12
13
{
14
auto read_locked_string = synchronized_string.rlock();
15
std::cout << "String value using operator->: " << read_locked_string->c_str() << std::endl; // 使用 operator-> 读取字符串
16
}
17
18
return 0;
19
}
② operator*() 方法
1
Object& operator*() &;
2
const Object& operator*() const&;
⚝ 功能：返回被保护的 Object 对象的引用。
▮▮▮▮⚝ 非 const 版本 (operator*() &)：返回 Object 对象的可修改的引用。必须在持有排他锁卫士 (Write Lock Guard 或 Write Try Lock Guard) 的情况下调用。
▮▮▮▮⚝ const 版本 (const Object& operator*() const&)：返回 Object 对象的 const 引用。可以在持有只读锁卫士 (Read Lock Guard 或 Read Try Lock Guard) 或排他锁卫士的情况下调用。
⚝ 返回值：Object 对象的引用 (Object& 或 const Object&)。
⚝ 异常：无。
⚝ 使用示例：
1
#include <folly/Synchronized.h>
2
#include <iostream>
3
4
int main() {
5
folly::Synchronized<std::mutex, int> synchronized_int(10);
6
7
{
8
auto locked_int = synchronized_int.lock();
9
*locked_int += 5; // 使用 operator* 修改整数值
10
}
11
12
{
13
auto read_locked_int = synchronized_int.rlock();
14
std::cout << "Integer value using operator*: " << *read_locked_int << std::endl; // 使用 operator* 读取整数值
15
}
16
17
return 0;
18
}
get_mutex() 方法 (The get_mutex() Method)
1
Mutexable& get_mutex() & noexcept;
2
const Mutexable& get_mutex() const& noexcept;
⚝ 功能：返回对 Synchronized 对象内部使用的 Mutexable 对象的引用。
▮▮▮▮⚝ 非 const 版本 (Mutexable& get_mutex() & noexcept)：返回对 Mutexable 对象的可修改的引用。
▮▮▮▮⚝ const 版本 (const Mutexable& get_mutex() const& noexcept)：返回对 Mutexable 对象的 const 引用。
⚝ 返回值：对 Mutexable 对象的引用 (Mutexable& 或 const Mutexable&)。
⚝ 异常：不抛出异常 (noexcept)。
⚝ 使用场景：在某些高级场景下，可能需要直接访问底层的互斥锁对象，例如：
▮▮▮▮⚝ 与不兼容 Synchronized 的旧代码或第三方库集成，这些代码可能需要直接操作互斥锁。
▮▮▮▮⚝ 实现更复杂的同步原语或模式，例如条件变量的等待操作通常需要直接与互斥锁交互。
⚝ 注意事项：通常情况下，应尽量避免直接操作 get_mutex() 返回的互斥锁。直接操作互斥锁容易破坏 Synchronized 提供的 RAII 机制和线程安全保证，增加出错的风险。只有在非常明确需要底层互斥锁对象，并充分理解其并发语义的情况下，才应谨慎使用 get_mutex()。
⚝ 使用示例：结合条件变量使用 get_mutex() 实现等待/通知机制（更详细的条件变量用法将在后续章节介绍）。
1
#include <folly/Synchronized.h>
2
#include <condition_variable>
3
#include <iostream>
4
#include <thread>
5
6
folly::Synchronized<std::mutex, int> data(0);
7
std::condition_variable cv;
8
bool ready = false;
9
10
void worker_thread() {
11
std::unique_lock<std::mutex> lock(data.get_mutex()); // 直接获取底层互斥锁
12
cv.wait(lock, []{ return ready; }); // 使用条件变量等待
13
std::cout << "Worker thread received notification, data = " << *data.rlock() << std::endl;
14
}
15
16
void main_thread() {
17
std::thread worker(worker_thread);
18
std::this_thread::sleep_for(std::chrono::seconds(2));
19
20
{
21
auto locked_data = data.lock();
22
*locked_data = 42;
23
ready = true;
24
}
25
cv.notify_one(); // 通知 worker 线程
26
27
worker.join();
28
}
29
30
int main() {
31
main_thread();
32
return 0;
33
}
5.2 ReadWriteMutex 类模板的详细 API (Detailed API of ReadWriteMutex Class Template)
ReadWriteMutex 是 folly/Synchronized.h 中用于实现读写锁 (Read-Write Lock) 功能的类模板。读写锁允许多个线程同时进行读操作，但只允许一个线程进行写操作，或者在没有读线程的情况下进行写操作。这在读多写少的场景下可以显著提高并发性能。其类模板定义如下：
1
template <typename Mutexable, typename Object, typename... Args>
2
class ReadWriteMutex;
3
4
template <typename Object, typename... Args>
5
using SharedMutex = ReadWriteMutex<folly::SharedMutex, Object, Args...>; // 默认使用 folly::SharedMutex 的别名
其中：
⚝ Mutexable：指定底层读写互斥锁的类型，默认为 folly::SharedMutex。通常应选择支持读写锁语义的互斥锁类型，例如 folly::SharedMutex 或 std::shared_mutex (C++17)。
⚝ Object：指定被保护的共享数据对象的类型。
⚝ Args...：用于在 ReadWriteMutex 对象内部构造 Object 对象的构造函数参数。
ReadWriteMutex 的 API 设计与 Synchronized 非常相似，主要区别在于提供了共享锁 (Shared Lock) 和 排他锁 (Exclusive Lock) 两种类型的锁，分别用于读操作和写操作。
构造函数和析构函数 (Constructors and Destructor)
ReadWriteMutex 的构造函数（默认构造函数、带对象构造参数的构造函数）和析构函数与 Synchronized 类模板的对应函数功能和使用方式完全一致，此处不再重复赘述。同样，ReadWriteMutex 的拷贝构造函数和移动构造函数也被删除。
锁操作方法 (Lock Operations Methods)
ReadWriteMutex 提供了以下方法来获取不同类型的锁卫士：
① lock_shared() 方法
1
auto lock_shared() &;
2
auto lock_shared() const&;
3
auto lock_shared() && = delete;
4
auto lock_shared() const&& = delete;
⚝ 功能：获取共享锁 (Shared Lock)，用于读操作。返回一个 共享锁卫士 (Shared Lock Guard) 对象，通常是 folly::ReadWriteMutex<Mutexable, Object>::SharedLock 类型。
⚝ 返回值：一个共享锁卫士对象。当锁卫士对象被创建时，会自动调用底层读写互斥锁的 lock_shared() 方法尝试获取共享锁。当锁卫士对象生命周期结束时，会自动释放共享锁。
⚝ 异常：如果底层读写互斥锁的 lock_shared() 方法抛出异常，则 lock_shared() 方法也会抛出相同的异常。
⚝ 使用场景：当需要读取共享数据，并且允许多个线程同时读取时，应使用 lock_shared() 获取共享锁。
⚝ 使用示例：
1
#include <folly/Synchronized.h>
2
#include <iostream>
3
#include <thread>
4
#include <vector>
5
6
folly::ReadWriteMutex<folly::SharedMutex, std::vector<int>> data_vector;
7
8
void read_data() {
9
for (int i = 0; i < 5; ++i) {
10
auto shared_locked_vector = data_vector.lock_shared(); // 获取共享锁
11
std::cout << "Reader " << std::this_thread::get_id() << " - Vector size: " << shared_locked_vector->size() << std::endl;
12
std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 模拟读操作
13
}
14
}
15
16
void write_data() {
17
for (int i = 0; i < 2; ++i) {
18
auto exclusive_locked_vector = data_vector.lock_exclusive(); // 获取排他锁
19
exclusive_locked_vector->push_back(i); // 修改 vector
20
std::cout << "Writer " << std::this_thread::get_id() << " - Added element, new size: " << exclusive_locked_vector->size() << std::endl;
21
std::this_thread::sleep_for(std::chrono::milliseconds(200)); // 模拟写操作
22
}
23
}
24
25
int main() {
26
std::thread reader1(read_data);
27
std::thread reader2(read_data);
28
std::thread writer1(write_data);
29
30
reader1.join();
31
reader2.join();
32
writer1.join();
33
34
return 0;
35
}
② lock_exclusive() 方法
1
auto lock_exclusive() &;
2
auto lock_exclusive() const& = delete;
3
auto lock_exclusive() && = delete;
4
auto lock_exclusive() const&& = delete;
⚝ 功能：获取排他锁 (Exclusive Lock)，用于写操作。返回一个 排他锁卫士 (Exclusive Lock Guard) 对象，通常是 folly::ReadWriteMutex<Mutexable, Object>::ExclusiveLock 类型。
⚝ 返回值：一个排他锁卫士对象。当锁卫士对象被创建时，会自动调用底层读写互斥锁的 lock_exclusive() 方法尝试获取排他锁。当锁卫士对象生命周期结束时，会自动释放排他锁。
⚝ 异常：如果底层读写互斥锁的 lock_exclusive() 方法抛出异常，则 lock_exclusive() 方法也会抛出相同的异常。
⚝ 使用场景：当需要修改共享数据时，必须使用 lock_exclusive() 获取排他锁，以确保在写操作期间没有其他线程（包括读线程和写线程）同时访问数据，保证数据一致性。
⚝ 使用示例：见 lock_shared() 方法的使用示例中的 write_data() 函数。
③ try_lock_shared() 方法
1
auto try_lock_shared() &;
2
auto try_lock_shared() const&;
3
auto try_lock_shared() && = delete;
4
auto try_lock_shared() const&& = delete;
⚝ 功能：尝试获取共享锁，非阻塞。返回一个 共享尝试锁卫士 (Shared Try Lock Guard) 对象，通常是 folly::ReadWriteMutex<Mutexable, Object>::SharedTryLock 类型。
⚝ 返回值：一个共享尝试锁卫士对象。行为和 Synchronized::try_lock() 类似，但尝试获取的是共享锁。
⚝ 异常：如果底层读写互斥锁的 try_lock_shared() 方法抛出异常，则 try_lock_shared() 方法也会抛出相同的异常。
⚝ 使用场景：非阻塞地尝试获取共享锁的场景。
④ try_lock_exclusive() 方法
1
auto try_lock_exclusive() &;
2
auto try_lock_exclusive() const& = delete;
3
auto try_lock_exclusive() && = delete;
4
auto try_lock_exclusive() const&& = delete;
⚝ 功能：尝试获取排他锁，非阻塞。返回一个 排他尝试锁卫士 (Exclusive Try Lock Guard) 对象，通常是 folly::ReadWriteMutex<Mutexable, Object>::ExclusiveTryLock 类型。
⚝ 返回值：一个排他尝试锁卫士对象。行为和 Synchronized::try_lock() 类似，但尝试获取的是排他锁。
⚝ 异常：如果底层读写互斥锁的 try_lock_exclusive() 方法抛出异常，则 try_lock_exclusive() 方法也会抛出相同的异常。
⚝ 使用场景：非阻塞地尝试获取排他锁的场景。
operator->() 和 operator*() 方法 (The operator->() and operator*() Methods)
ReadWriteMutex 类模板也重载了 operator->() 和 operator*() 运算符，用于方便地访问被保护的 Object 对象。其行为与 Synchronized 的对应运算符类似，但需要根据持有的锁类型（共享锁或排他锁）来区分：
⚝ 持有共享锁卫士 (Shared Lock Guard 或 Shared Try Lock Guard) 时：operator->() 和 operator*() 返回指向 const Object 的指针或 const Object 的引用，只允许进行只读操作。
⚝ 持有排他锁卫士 (Exclusive Lock Guard 或 Exclusive Try Lock Guard) 时：operator->() 和 operator*() 返回指向 Object 的指针或 Object 的引用，允许进行读写操作。
get_mutex() 方法 (The get_mutex() Method)
1
Mutexable& get_mutex() & noexcept;
2
const Mutexable& get_mutex() const& noexcept;
⚝ 功能：返回对 ReadWriteMutex 对象内部使用的 Mutexable 对象的引用。与 Synchronized::get_mutex() 功能和使用注意事项完全一致。
5.3 相关辅助函数与类型 (Related Helper Functions and Types)
folly/Synchronized.h 主要提供了 Synchronized 和 ReadWriteMutex 两个核心类模板，以及一些用于简化使用的类型别名。
① 类型别名 (Type Aliases)
⚝ folly::Mutex<Object, Args...>: Synchronized<std::mutex, Object, Args...> 的别名。用于创建基于 std::mutex 的 Synchronized 对象，提供排他锁保护。
⚝ folly::SharedMutex<Object, Args...>: ReadWriteMutex<folly::SharedMutex, Object, Args...> 的别名。用于创建基于 folly::SharedMutex 的 ReadWriteMutex 对象，提供读写锁保护。
这些类型别名简化了常用场景下的 Synchronized 和 ReadWriteMutex 的声明，提高了代码的可读性。
② 锁卫士类型 (Lock Guard Types)
⚝ Synchronized<Mutexable, Object>::WriteLock: Synchronized::lock() 返回的可写锁卫士类型。
⚝ Synchronized<Mutexable, Object>::ReadLock: Synchronized::rlock() 返回的只读锁卫士类型。
⚝ Synchronized<Mutexable, Object>::WriteTryLock: Synchronized::try_lock() 返回的可写尝试锁卫士类型。
⚝ Synchronized<Mutexable, Object>::ReadTryLock: Synchronized::try_rlock() 返回的只读尝试锁卫士类型。
⚝ ReadWriteMutex<Mutexable, Object>::SharedLock: ReadWriteMutex::lock_shared() 返回的共享锁卫士类型。
⚝ ReadWriteMutex<Mutexable, Object>::ExclusiveLock: ReadWriteMutex::lock_exclusive() 返回的排他锁卫士类型。
⚝ ReadWriteMutex<Mutexable, Object>::SharedTryLock: ReadWriteMutex::try_lock_shared() 返回的共享尝试锁卫士类型。
⚝ ReadWriteMutex<Mutexable, Object>::ExclusiveTryLock: ReadWriteMutex::try_lock_exclusive() 返回的排他尝试锁卫士类型。
这些锁卫士类型都是 RAII 风格的，其构造函数负责获取锁，析构函数负责释放锁，确保锁的自动管理。用户通常不需要直接操作这些锁卫士类型，而是通过 Synchronized 和 ReadWriteMutex 提供的 lock(), rlock(), lock_shared(), lock_exclusive() 等方法来获取和使用它们。
5.4 API 使用注意事项与最佳实践 (API Usage Precautions and Best Practices)
正确使用 Synchronized 和 ReadWriteMutex 的 API 是构建可靠并发程序的关键。以下总结一些重要的使用注意事项和最佳实践：
① 遵循 RAII 原则 (Follow RAII Principle)
⚝ Synchronized 和 ReadWriteMutex 的核心设计理念是 RAII。务必通过锁卫士对象来管理锁的生命周期，避免手动调用锁的 lock() 和 unlock() 方法。
⚝ 锁卫士对象在构造时自动获取锁，在析构时自动释放锁。利用作用域 (scope) 来控制锁的持有时间，确保锁在不再需要时及时释放，避免死锁和性能问题。
② 选择合适的锁类型 (Choose the Right Lock Type)
⚝ 排他锁 (Synchronized, ReadWriteMutex::lock_exclusive()): 用于保护需要读写的共享数据。在写操作期间，任何其他线程都无法访问数据，保证数据一致性。
⚝ 共享锁 (ReadWriteMutex::lock_shared()): 用于保护只需要读取的共享数据。允许多个线程同时读取数据，提高并发性能。
⚝ 根据实际的读写比例和并发需求，选择合适的锁类型。读多写少的场景应优先考虑 ReadWriteMutex 和共享锁，以最大化并发度。
③ 避免长时间持有锁 (Avoid Holding Locks for Too Long)
⚝ 锁的持有时间越长，其他线程等待锁的时间就越长，并发性能越差。
⚝ 尽量减小临界区 (Critical Section) 的范围，只在必要时才持有锁，并在完成共享数据访问后尽快释放锁。
⚝ 避免在持有锁的情况下执行耗时操作（例如 I/O 操作、网络请求、复杂计算等）。如果必须执行耗时操作，考虑将耗时操作移出临界区，或者使用更细粒度的锁或无锁数据结构。
④ 注意异常安全性 (Exception Safety)
⚝ Synchronized 和 ReadWriteMutex 结合 RAII 锁卫士，可以很好地处理异常情况，保证即使在临界区内抛出异常，锁也能被正确释放。
⚝ 确保临界区内的代码是异常安全的。避免在临界区内抛出未捕获的异常，或者确保即使抛出异常，程序状态也能保持一致。
⑤ 预防死锁 (Deadlock Prevention)
⚝ 避免嵌套锁 (Nested Locks)：尽量避免在一个线程中连续获取多个锁。如果必须获取多个锁，确保以相同的顺序获取锁，以避免循环等待条件导致的死锁。
⚝ 使用 try_lock() 和超时机制: 在某些复杂场景下，可以使用 try_lock() 尝试非阻塞地获取锁，并结合超时机制，避免线程无限期等待锁，从而预防死锁。
⚝ 锁的粒度 (Lock Granularity)：合理选择锁的粒度。粗粒度锁简单易用，但并发度低；细粒度锁并发度高，但实现复杂，容易出错。根据实际需求权衡锁的粒度。
⑥ 性能考量 (Performance Considerations)
⚝ 锁的开销 (Lock Overhead)：锁操作本身会带来一定的性能开销，包括锁的竞争、上下文切换等。过度使用锁或不必要的锁竞争会降低程序性能。
⚝ 减少锁竞争 (Reduce Lock Contention)：
▮▮▮▮⚝ 减小临界区范围。
▮▮▮▮⚝ 使用读写锁 (在读多写少场景下)。
▮▮▮▮⚝ 锁分段 (Lock Striping) 或 数据分区 (Data Partitioning)：将共享数据分散到多个互斥锁保护的不同区域，降低单个锁的竞争程度。
▮▮▮▮⚝ 无锁编程 (Lock-Free Programming) (高级主题)：在某些性能敏感的场景下，可以考虑使用原子操作和无锁数据结构，完全避免锁的开销。但这通常实现复杂，维护难度高。
⚝ 性能测试和调优 (Performance Testing and Tuning)：对并发程序进行充分的性能测试，识别性能瓶颈，并根据测试结果进行调优。
⑦ 谨慎使用 get_mutex() (Use get_mutex() with Caution)
⚝ 除非必要，否则不要直接操作 get_mutex() 返回的互斥锁。直接操作互斥锁容易破坏 Synchronized 和 ReadWriteMutex 提供的 RAII 机制和线程安全保证。
⚝ 只有在需要与底层互斥锁进行更底层的交互（例如条件变量的等待操作、与旧代码集成等）时，才应谨慎使用 get_mutex()，并确保充分理解其并发语义。
遵循以上注意事项和最佳实践，可以帮助开发者更有效地利用 folly/Synchronized.h 库，构建高效、可靠、易于维护的并发程序。
END_OF_CHAPTER
6. chapter 6：实战案例分析 (Practical Case Study Analysis)
6.1 案例一：线程安全的队列实现 (Case Study 1: Thread-Safe Queue Implementation)
在并发编程中，队列（Queue）是一种常见的数据结构，用于在多个线程之间传递数据。然而，标准的队列实现通常不是线程安全的，这意味着在多线程环境下同时访问和修改队列可能会导致数据竞争（Data Race）和未定义的行为。为了解决这个问题，我们需要实现线程安全的队列。folly::Synchronized 提供了一种简单而有效的方法来实现线程安全的数据结构，包括队列。
本案例将演示如何使用 folly::Synchronized 来创建一个线程安全的队列。我们将实现一个基本的 FIFO（先进先出，First-In-First-Out）队列，并确保多个线程可以安全地向队列中添加元素（入队，enqueue）和从队列中移除元素（出队，dequeue）。
需求分析
我们需要实现一个队列，它应该满足以下线程安全的要求：
① 互斥访问：多个线程不能同时修改队列的内部状态（例如，队列的头部、尾部和元素）。
② 条件同步：当队列为空时，尝试出队的线程应该被阻塞，直到队列中有新的元素加入。当队列未满时（如果队列有容量限制），尝试入队的线程应该被阻塞，直到队列有空间可用（在本例中，我们实现一个无界队列，暂不考虑队列满的情况）。
设计与实现
我们可以使用 folly::Synchronized 来保护队列的内部数据结构，并使用条件变量（Condition Variable）来实现线程间的同步。
数据结构
我们使用 std::queue 作为底层的数据存储结构。为了线程安全，我们将 std::queue 封装在 folly::Synchronized 中。
1
#include <folly/Synchronized.h>
2
#include <queue>
3
#include <mutex>
4
#include <condition_variable>
5
6
template <typename T>
7
class ThreadSafeQueue {
8
private:
9
folly::Synchronized<std::queue<T>, std::mutex> queue_; // 使用 Synchronized 保护 std::queue
10
std::condition_variable not_empty_; // 条件变量，用于通知消费者队列非空
11
12
public:
13
ThreadSafeQueue() = default;
14
15
void enqueue(T value) {
16
{
17
auto locked_queue = queue_.wlock(); // 获取写锁
18
locked_queue->push(value);
19
} // 锁在作用域结束时自动释放
20
not_empty_.notify_one(); // 通知一个等待的消费者
21
}
22
23
T dequeue() {
24
T value;
25
{
26
std::unique_lock<std::mutex> lock(queue_.mutex()); // 直接获取 Synchronized 内部的 mutex
27
not_empty_.wait(lock, [&]{ return !queue_.rlock()->empty(); }); // 等待队列非空
28
auto locked_queue = queue_.wlock(); // 获取写锁进行出队操作
29
value = locked_queue->front();
30
locked_queue->pop();
31
} // 锁在作用域结束时自动释放
32
return value;
33
}
34
35
bool empty() const {
36
return queue_.rlock()->empty(); // 获取读锁进行只读操作
37
}
38
39
size_t size() const {
40
return queue_.rlock()->size(); // 获取读锁进行只读操作
41
}
42
};
代码解释
① folly::Synchronized<std::queue<T>, std::mutex> queue_;: 我们声明了一个 folly::Synchronized 类型的成员变量 queue_。它包装了一个 std::queue<T> 对象，并使用 std::mutex 作为互斥锁。这意味着对 queue_ 的任何访问都将受到互斥锁的保护。
② std::condition_variable not_empty_;: 我们使用一个条件变量 not_empty_ 来实现当队列为空时，dequeue 操作的线程等待，直到有新的元素入队。
③ enqueue(T value):
▮▮▮▮⚝ auto locked_queue = queue_.wlock();: 使用 wlock() 方法获取 queue_ 的写锁。写锁是独占锁，确保在修改队列时没有其他线程可以同时访问。
▮▮▮▮⚝ locked_queue->push(value);: 在持有写锁的情况下，将 value 入队到 std::queue 中。
▮▮▮▮⚝ 锁在 locked_queue 变量的作用域结束时自动释放（RAII 机制）。
▮▮▮▮⚝ not_empty_.notify_one();: 入队操作完成后，调用 not_empty_.notify_one() 通知一个等待在 not_empty_ 条件变量上的线程（如果有的话），表示队列现在可能非空了。
④ dequeue():
▮▮▮▮⚝ std::unique_lock<std::mutex> lock(queue_.mutex());: 为了使用条件变量 not_empty_，我们需要显式地获取 queue_ 内部的 std::mutex。我们使用 std::unique_lock 来管理锁的生命周期。
▮▮▮▮⚝ not_empty_.wait(lock, [&]{ return !queue_.rlock()->empty(); });: 这是条件等待的关键步骤。
▮▮▮▮⚝ not_empty_.wait(lock, ...) 会原子地释放 lock，并将当前线程置于等待状态，直到 not_empty_.notify_one() 或 not_empty_.notify_all() 被调用，或者发生虚假唤醒（spurious wakeup）。
▮▮▮▮⚝ [&]{ return !queue_.rlock()->empty(); } 是一个谓词（predicate），只有当谓词返回 true 时，wait 才会返回，并且在返回前会重新获取锁 lock。在这里，谓词检查队列是否为空。如果队列为空，wait 会继续等待；如果队列非空，wait 返回，线程可以继续执行出队操作。
▮▮▮▮⚝ queue_.rlock()->empty(): 在谓词中，我们使用 rlock() 获取读锁来检查队列是否为空。读锁是共享锁，允许多个线程同时读取队列状态，但阻止任何线程修改队列。
▮▮▮▮⚝ auto locked_queue = queue_.wlock();: 当 wait 返回（表示队列非空），我们再次获取写锁，以安全地执行出队操作。
▮▮▮▮⚝ value = locked_queue->front();: 获取队首元素。
▮▮▮▮⚝ locked_queue->pop();: 移除队首元素。
▮▮▮▮⚝ 锁在 locked_queue 变量的作用域结束时自动释放。
▮▮▮▮⚝ return value;: 返回出队的元素。
⑤ empty() const 和 size() const:
▮▮▮▮⚝ 这两个方法都是只读操作，因此我们使用 rlock() 获取读锁。读锁允许多个线程同时调用 empty() 或 size()，而不会发生数据竞争。
使用示例
1
#include <iostream>
2
#include <thread>
3
#include <vector>
4
5
int main() {
6
ThreadSafeQueue<int> queue;
7
8
// 生产者线程
9
std::thread producer([&]() {
10
for (int i = 0; i < 10; ++i) {
11
queue.enqueue(i);
12
std::cout << "Produced: " << i << std::endl;
13
std::this_thread::sleep_for(std::chrono::milliseconds(100));
14
}
15
});
16
17
// 消费者线程
18
std::thread consumer([&]() {
19
for (int i = 0; i < 10; ++i) {
20
int value = queue.dequeue();
21
std::cout << "Consumed: " << value << std::endl;
22
std::this_thread::sleep_for(std::chrono::milliseconds(150));
23
}
24
});
25
26
producer.join();
27
consumer.join();
28
29
return 0;
30
}
总结
通过使用 folly::Synchronized 和条件变量，我们成功地实现了一个线程安全的队列。folly::Synchronized 简化了锁的管理，RAII 机制确保了锁的自动释放，避免了忘记解锁导致的死锁问题。条件变量 not_empty_ 实现了线程间的有效同步，避免了消费者线程在队列为空时忙等待（busy-waiting），提高了程序的效率。这个案例展示了 folly::Synchronized 在构建线程安全数据结构方面的实用性和便利性。
6.2 案例二：使用 ReadWriteMutex 优化缓存系统 (Case Study 2: Optimizing Cache System with ReadWriteMutex)
缓存（Cache）是计算机系统中常用的一种提高数据访问速度的技术。在多线程环境中，缓存的并发访问控制至关重要。如果多个线程同时读写缓存，可能会导致数据不一致或性能瓶颈。folly::ReadWriteMutex (读写互斥锁) 提供了一种优化缓存系统并发访问的有效方法。
缓存系统的读写特性
缓存系统通常具有以下读写特性：
① 读多写少：缓存的主要目的是加速读取操作，因此读取操作通常远多于写入操作。
② 并发读取：多个线程可以同时读取缓存数据，而不会互相干扰。
③ 独占写入：当一个线程正在写入缓存数据时，其他线程（包括读线程和写线程）应该被阻塞，以保证数据的一致性。
ReadWriteMutex 的优势
传统的互斥锁（如 std::mutex 或 folly::Synchronized 默认使用的互斥锁）是排他锁，即无论是读操作还是写操作，都需要获取独占锁。这在读多写少的场景下会造成不必要的性能损失，因为即使是并发的读取操作也需要排队获取锁。
folly::ReadWriteMutex 提供了读锁和写锁两种模式：
① 读锁（共享锁）：允许多个线程同时持有读锁。适用于读取操作。
② 写锁（独占锁）：只允许一个线程持有写锁。适用于写入操作。当一个线程持有写锁时，其他线程（包括读线程和写线程）都将被阻塞。
通过使用 ReadWriteMutex，我们可以允许多个线程同时读取缓存，只有在写入缓存时才需要独占访问，从而提高缓存系统的并发性能。
案例实现：基于 ReadWriteMutex 的缓存
我们实现一个简单的缓存类 ThreadSafeCache，使用 std::map 作为底层数据存储，并使用 folly::ReadWriteMutex 来保护缓存数据的并发访问。
1
#include <folly/ReadWriteMutex.h>
2
#include <map>
3
#include <string>
4
#include <mutex>
5
6
class ThreadSafeCache {
7
private:
8
std::map<std::string, std::string> cache_; // 底层缓存数据存储
9
folly::ReadWriteMutex rw_mutex_; // 读写互斥锁
10
11
public:
12
ThreadSafeCache() = default;
13
14
std::string get(const std::string& key) {
15
folly::ReadMutex lock(rw_mutex_); // 获取读锁
16
auto it = cache_.find(key);
17
if (it != cache_.end()) {
18
return it->second;
19
}
20
return ""; // Key not found
21
}
22
23
void put(const std::string& key, const std::string& value) {
24
folly::WriteMutex lock(rw_mutex_); // 获取写锁
25
cache_[key] = value;
26
}
27
28
void remove(const std::string& key) {
29
folly::WriteMutex lock(rw_mutex_); // 获取写锁
30
cache_.erase(key);
31
}
32
33
size_t size() const {
34
folly::ReadMutex lock(rw_mutex_); // 获取读锁
35
return cache_.size();
36
}
37
};
代码解释
① folly::ReadWriteMutex rw_mutex_;: 声明一个 folly::ReadWriteMutex 类型的成员变量 rw_mutex_，用于保护缓存数据的并发访问。
② get(const std::string& key):
▮▮▮▮⚝ folly::ReadMutex lock(rw_mutex_);: 在读取缓存数据时，我们使用 folly::ReadMutex 获取读锁。folly::ReadMutex 是 folly::ReadWriteMutex 的读锁 RAII 包装器。
▮▮▮▮⚝ 在持有读锁的情况下，我们可以安全地读取 cache_ 中的数据。由于是读锁，多个线程可以同时执行 get 操作。
③ put(const std::string& key, const std::string& value) 和 remove(const std::string& key):
▮▮▮▮⚝ folly::WriteMutex lock(rw_mutex_);: 在写入或删除缓存数据时，我们使用 folly::WriteMutex 获取写锁。folly::WriteMutex 是 folly::ReadWriteMutex 的写锁 RAII 包装器。
▮▮▮▮⚝ 在持有写锁的情况下，我们可以安全地修改 cache_ 中的数据。由于是写锁，当一个线程执行 put 或 remove 操作时，其他线程（包括读线程和写线程）将被阻塞，保证了数据的一致性。
④ size() const:
▮▮▮▮⚝ 在获取缓存大小等只读操作时，我们同样使用 folly::ReadMutex 获取读锁，允许多个线程并发读取缓存状态。
使用示例
1
#include <iostream>
2
#include <thread>
3
#include <vector>
4
5
int main() {
6
ThreadSafeCache cache;
7
8
// 多个读线程
9
std::vector<std::thread> readers;
10
for (int i = 0; i < 5; ++i) {
11
readers.emplace_back([&]() {
12
for (int j = 0; j < 10; ++j) {
13
std::string value = cache.get("key1");
14
std::cout << "Reader " << std::this_thread::get_id() << " get('key1'): " << value << std::endl;
15
std::this_thread::sleep_for(std::chrono::milliseconds(50));
16
}
17
});
18
}
19
20
// 写线程
21
std::thread writer([&]() {
22
for (int i = 0; i < 5; ++i) {
23
cache.put("key1", "value" + std::to_string(i));
24
std::cout << "Writer " << std::this_thread::get_id() << " put('key1', 'value" << i << "')" << std::endl;
25
std::this_thread::sleep_for(std::chrono::milliseconds(200));
26
}
27
});
28
29
for (auto& reader_thread : readers) {
30
reader_thread.join();
31
}
32
writer.join();
33
34
return 0;
35
}
性能优势
相比于使用传统的互斥锁，ReadWriteMutex 在读多写少的缓存场景下可以显著提高并发性能。多个读线程可以同时访问缓存，提高了读取操作的吞吐量。只有在写操作时才会阻塞其他线程，但由于写操作相对较少，整体性能仍然优于使用排他锁的方案。
总结
本案例展示了如何使用 folly::ReadWriteMutex 来优化缓存系统的并发访问。通过区分读操作和写操作，并使用读锁和写锁分别进行保护，我们可以在读多写少的场景下充分利用并发性，提高缓存系统的性能。ReadWriteMutex 是优化此类场景的有效工具，可以应用于各种需要高效并发读取和偶尔写入的数据结构和系统。
6.3 案例三：基于条件变量的生产者-消费者模型 (Case Study 3: Producer-Consumer Model Based on Condition Variable)
生产者-消费者模型（Producer-Consumer Model）是并发编程中一种经典的设计模式。它描述了两个或多个线程（生产者和消费者）共享一个缓冲区（通常是队列）的场景。生产者线程向缓冲区中生产数据，消费者线程从缓冲区中消费数据。为了保证数据的一致性和线程安全，需要使用同步机制来协调生产者和消费者之间的操作。
条件变量（Condition Variable）是实现生产者-消费者模型的关键同步工具。它可以让线程在特定条件不满足时进入等待状态，并在条件满足时被唤醒。结合 folly::Synchronized，我们可以方便地实现一个高效且线程安全的生产者-消费者模型。
生产者-消费者模型的需求
在一个典型的生产者-消费者模型中，我们需要解决以下同步问题：
① 互斥访问缓冲区：生产者和消费者需要互斥地访问共享缓冲区，以避免数据竞争。
② 缓冲区为空时的消费者等待：当缓冲区为空时，消费者线程应该等待，直到生产者向缓冲区中添加了新的数据。
③ 缓冲区已满时的生产者等待（可选，对于有界缓冲区）：如果缓冲区有容量限制，当缓冲区已满时，生产者线程应该等待，直到消费者从缓冲区中取走数据，释放空间。在本案例中，我们仍然使用无界队列，主要关注缓冲区为空时的消费者等待。
使用条件变量实现生产者-消费者模型
我们可以使用 folly::Synchronized 保护共享缓冲区（队列），并使用条件变量来实现消费者在缓冲区为空时的等待和生产者的唤醒。
1
#include <folly/Synchronized.h>
2
#include <queue>
3
#include <mutex>
4
#include <condition_variable>
5
#include <iostream>
6
#include <thread>
7
8
template <typename T>
9
class ProducerConsumerQueue {
10
private:
11
folly::Synchronized<std::queue<T>, std::mutex> queue_; // 线程安全队列
12
std::condition_variable not_empty_; // 条件变量，通知消费者队列非空
13
14
public:
15
ProducerConsumerQueue() = default;
16
17
void produce(T item) {
18
{
19
auto locked_queue = queue_.wlock(); // 获取写锁
20
locked_queue->push(item);
21
} // 锁自动释放
22
not_empty_.notify_one(); // 通知一个消费者
23
std::cout << "Produced: " << item << std::endl;
24
}
25
26
T consume() {
27
T item;
28
{
29
std::unique_lock<std::mutex> lock(queue_.mutex()); // 获取内部 mutex
30
not_empty_.wait(lock, [&]{ return !queue_.rlock()->empty(); }); // 等待队列非空
31
auto locked_queue = queue_.wlock(); // 获取写锁进行出队
32
item = locked_queue->front();
33
locked_queue->pop();
34
} // 锁自动释放
35
std::cout << "Consumed: " << item << std::endl;
36
return item;
37
}
38
};
39
40
int main() {
41
ProducerConsumerQueue<int> queue;
42
43
// 生产者线程
44
std::thread producer([&]() {
45
for (int i = 0; i < 10; ++i) {
46
queue.produce(i);
47
std::this_thread::sleep_for(std::chrono::milliseconds(100));
48
}
49
});
50
51
// 消费者线程
52
std::thread consumer([&]() {
53
for (int i = 0; i < 10; ++i) {
54
queue.consume();
55
std::this_thread::sleep_for(std::chrono::milliseconds(150));
56
}
57
});
58
59
producer.join();
60
consumer.join();
61
62
return 0;
63
}
代码解释
这个例子实际上与案例一中的线程安全队列实现非常相似，因为生产者-消费者模型的核心就是线程安全的队列。我们重用了案例一中的 ThreadSafeQueue 的基本结构，并将其更名为 ProducerConsumerQueue，同时将 enqueue 和 dequeue 方法分别更名为 produce 和 consume，以更清晰地表达生产者和消费者的语义。
① ProducerConsumerQueue<T> 类: 封装了线程安全队列的实现。
② produce(T item) 方法:
▮▮▮▮⚝ 生产者线程调用 produce 方法将数据 item 放入队列。
▮▮▮▮⚝ 使用 queue_.wlock() 获取写锁，保护队列的互斥访问。
▮▮▮▮⚝ not_empty_.notify_one() 通知等待在 not_empty_ 条件变量上的消费者线程。
③ consume() 方法:
▮▮▮▮⚝ 消费者线程调用 consume 方法从队列中取出数据。
▮▮▮▮⚝ std::unique_lock<std::mutex> lock(queue_.mutex());: 显式获取 queue_ 内部的互斥锁，以便与条件变量 not_empty_ 配合使用。
▮▮▮▮⚝ not_empty_.wait(lock, [&]{ return !queue_.rlock()->empty(); });: 消费者线程在队列为空时，调用 not_empty_.wait() 进入等待状态。当生产者调用 notify_one() 时，消费者线程被唤醒，并检查队列是否非空。
▮▮▮▮⚝ queue_.wlock() 获取写锁，安全地从队列中取出数据。
条件变量的作用
条件变量 not_empty_ 在生产者-消费者模型中起到了关键的同步作用：
① 避免忙等待：当队列为空时，消费者线程不会忙循环检查队列是否为空，而是进入等待状态，释放 CPU 资源。
② 高效唤醒：当生产者向队列中添加数据后，通过 notify_one() 唤醒一个等待的消费者线程，使消费者能够及时处理新生产的数据。
总结
本案例展示了如何使用 folly::Synchronized 和条件变量来实现生产者-消费者模型。条件变量有效地解决了消费者在缓冲区为空时的等待和唤醒问题，避免了忙等待，提高了程序的效率。生产者-消费者模型是一种非常重要的并发设计模式，广泛应用于各种需要异步数据处理的场景，例如消息队列、任务调度系统等。folly::Synchronized 和条件变量为实现这种模式提供了简洁而强大的工具。
6.4 案例四：复杂并发场景下的 Synchronized 应用 (Case Study 4: Synchronized Application in Complex Concurrent Scenarios)
在实际的软件开发中，我们经常会遇到比简单的队列或缓存更复杂的并发场景。例如，一个多线程服务器需要处理来自多个客户端的并发请求，一个并行数据处理流水线需要协调多个处理阶段的并发执行。在这些复杂场景下，folly::Synchronized 仍然可以作为构建线程安全组件和管理并发访问的基石。
本案例将探讨一个更复杂的并发场景：多线程文档索引构建。假设我们需要构建一个文档索引，将多个文档的内容解析并索引到内存中的数据结构中。为了提高索引构建的速度，我们采用多线程并行处理文档。
场景描述：多线程文档索引构建
① 文档来源：假设我们有一批文档需要索引，文档可以来自文件系统、网络或其他数据源。
② 索引结构：我们使用一个倒排索引（Inverted Index）作为索引结构。倒排索引将词语（Term）映射到包含该词语的文档列表。例如，对于词语 "apple"，索引可能指向包含 "apple" 的文档 1、文档 3 和文档 5。
③ 并发处理：我们创建多个线程，每个线程负责处理一部分文档。
④ 共享索引：所有线程需要将解析和索引的结果更新到同一个共享的倒排索引数据结构中。
并发挑战
在多线程构建索引的过程中，我们需要解决以下并发挑战：
① 索引结构的线程安全：倒排索引是一个共享的数据结构，多个线程需要同时对其进行修改（添加新的词语和文档映射）。我们需要保证索引结构的线程安全，避免数据竞争。
② 高效并发更新：索引构建是一个写密集型操作，我们需要尽量提高并发更新索引的效率，减少锁的竞争。
使用 folly::Synchronized 保护倒排索引
我们可以使用 folly::Synchronized 来保护倒排索引数据结构的并发访问。倒排索引可以使用 std::map 或 folly::ConcurrentHashMap 等数据结构实现。为了简化示例，我们使用 std::map<std::string, std::vector<int>> 来表示倒排索引，其中 key 是词语，value 是包含该词语的文档 ID 列表。
1
#include <folly/Synchronized.h>
2
#include <map>
3
#include <vector>
4
#include <string>
5
#include <mutex>
6
#include <iostream>
7
#include <thread>
8
#include <sstream>
9
10
class InvertedIndex {
11
private:
12
folly::Synchronized<std::map<std::string, std::vector<int>>, std::mutex> index_; // 线程安全的倒排索引
13
14
public:
15
InvertedIndex() = default;
16
17
void addDocument(int docId, const std::string& content) {
18
std::stringstream ss(content);
19
std::string word;
20
while (ss >> word) {
21
// 简单分词，实际应用中需要更复杂的分词和预处理
22
addTerm(word, docId);
23
}
24
}
25
26
void addTerm(const std::string& term, int docId) {
27
auto locked_index = index_.wlock(); // 获取写锁
28
locked_index->operator[](term).push_back(docId); // 添加词语和文档 ID 的映射
29
}
30
31
std::vector<int> search(const std::string& term) {
32
auto locked_index = index_.rlock(); // 获取读锁
33
auto it = locked_index->find(term);
34
if (it != locked_index->end()) {
35
return it->second;
36
}
37
return {}; // Term not found
38
}
39
40
void printIndex() {
41
auto locked_index = index_.rlock(); // 获取读锁
42
for (const auto& pair : *locked_index) {
43
std::cout << pair.first << ": ";
44
for (int docId : pair.second) {
45
std::cout << docId << " ";
46
}
47
std::cout << std::endl;
48
}
49
}
50
};
代码解释
① folly::Synchronized<std::map<std::string, std::vector<int>>, std::mutex> index_;: 我们使用 folly::Synchronized 包装 std::map 来创建线程安全的倒排索引 index_。
② addDocument(int docId, const std::string& content):
▮▮▮▮⚝ 该方法用于处理一个文档的内容，并将其中的词语添加到索引中。
▮▮▮▮⚝ 它首先简单地将文档内容分词（实际应用中需要更复杂的分词方法）。
▮▮▮▮⚝ 然后，对于每个词语，调用 addTerm 方法添加到索引中。
③ addTerm(const std::string& term, int docId):
▮▮▮▮⚝ auto locked_index = index_.wlock();: 在修改索引（添加新的词语和文档映射）时，我们使用 wlock() 获取写锁，保证独占访问。
▮▮▮▮⚝ locked_index->operator[](term).push_back(docId);: 在持有写锁的情况下，安全地更新倒排索引。如果词语 term 已经存在于索引中，则将 docId 添加到对应的文档 ID 列表中；如果词语不存在，则创建一个新的词语条目，并将 docId 添加到列表中。
④ search(const std::string& term):
▮▮▮▮⚝ auto locked_index = index_.rlock();: 在查询索引（搜索词语）时，我们使用 rlock() 获取读锁，允许多个线程同时进行搜索操作。
▮▮▮▮⚝ 在持有读锁的情况下，安全地读取倒排索引，并返回包含指定词语的文档 ID 列表。
⑤ printIndex():
▮▮▮▮⚝ 用于打印索引内容，同样使用 rlock() 获取读锁。
多线程索引构建示例
1
#include <vector>
2
3
int main() {
4
InvertedIndex index;
5
std::vector<std::string> documents = {
6
"apple banana orange",
7
"banana grape kiwi",
8
"orange lemon apple"
9
};
10
11
std::vector<std::thread> threads;
12
int num_threads = 3;
13
int docs_per_thread = documents.size() / num_threads;
14
15
for (int i = 0; i < num_threads; ++i) {
16
threads.emplace_back([&, i]() {
17
int start_doc_id = i * docs_per_thread;
18
int end_doc_id = (i == num_threads - 1) ? documents.size() : (i + 1) * docs_per_thread;
19
for (int doc_id = start_doc_id; doc_id < end_doc_id; ++doc_id) {
20
index.addDocument(doc_id, documents[doc_id]);
21
std::cout << "Thread " << std::this_thread::get_id() << " indexed document " << doc_id << std::endl;
22
}
23
});
24
}
25
26
for (auto& thread : threads) {
27
thread.join();
28
}
29
30
std::cout << "\nFinal Inverted Index:\n";
31
index.printIndex();
32
33
std::cout << "\nSearch for 'banana':\n";
34
std::vector<int> banana_docs = index.search("banana");
35
for (int docId : banana_docs) {
36
std::cout << docId << " ";
37
}
38
std::cout << std::endl;
39
40
return 0;
41
}
总结
本案例展示了 folly::Synchronized 在更复杂的并发场景下的应用，即多线程文档索引构建。通过使用 folly::Synchronized 保护共享的倒排索引数据结构，我们实现了线程安全的并发索引构建。虽然这个例子仍然相对简化，但它展示了 folly::Synchronized 可以作为构建复杂并发系统的基础组件。在实际应用中，我们可以根据具体场景选择合适的锁粒度和并发策略，例如使用更细粒度的锁（如针对每个词语的锁）或使用无锁数据结构（如 folly::ConcurrentHashMap）来进一步提高并发性能。然而，folly::Synchronized 提供了一种简单易用的线程安全保护机制，适用于各种复杂并发场景，是构建可靠并发应用的重要工具。
END_OF_CHAPTER
7. chapter 7：性能考量与最佳实践 (Performance Considerations and Best Practices)
7.1 锁的性能开销分析 (Performance Overhead Analysis of Locks)
在并发编程中，锁（Lock）是保证线程安全的重要工具。然而，锁的使用并非没有代价。不恰当的使用锁不仅不能提升性能，反而会成为性能瓶颈。本节将深入分析锁的性能开销，帮助读者理解锁的代价，从而在实际应用中做出更合理的选择。
7.1.1 锁的类型及其性能影响 (Types of Locks and Their Performance Impact)
不同的锁类型在实现机制和性能特性上存在差异，选择合适的锁类型对性能至关重要。常见的锁类型包括：
① 互斥锁（Mutex）: 互斥锁是最常用的锁类型，保证在同一时刻只有一个线程可以访问被保护的资源。folly::Synchronized<std::mutex> 默认使用的就是互斥锁。互斥锁的性能开销主要来自于线程的阻塞和唤醒，以及可能的上下文切换。在竞争激烈的情况下，线程频繁地争夺锁，会导致大量的线程阻塞和唤醒，从而降低性能。
② 读写锁（ReadWriteMutex）: 读写锁允许多个线程同时读取共享资源，但只允许一个线程写入共享资源。folly::Synchronized<folly::ReadWriteMutex> 提供了读写锁的支持。读写锁适用于读多写少的场景，可以显著提高并发性能。但是，如果写操作频繁，或者读操作的临界区过长，读写锁的性能优势可能会降低，甚至不如互斥锁。
③ 自旋锁（Spinlock）: 自旋锁是一种忙等待锁，当线程尝试获取锁时，如果锁已被占用，线程会不断循环检查锁是否释放，而不是进入阻塞状态。自旋锁避免了线程阻塞和唤醒的开销，但在锁竞争激烈的情况下，会消耗大量的 CPU 资源。自旋锁适用于临界区非常短，且锁竞争不激烈的场景。folly::MicroSpinLock 是 Folly 库提供的自旋锁实现。
④ 其他类型的锁: 除了上述常见的锁类型，还有例如悲观锁（Pessimistic Lock）和乐观锁（Optimistic Lock）等概念。悲观锁认为并发冲突总是会发生，因此在访问共享资源前先加锁。互斥锁和读写锁都属于悲观锁。乐观锁则认为并发冲突很少发生，因此在不加锁的情况下完成操作，然后在提交更新时检查是否发生冲突。乐观锁通常通过原子操作来实现，例如 std::atomic。
不同锁类型的性能特点总结如下：
| 锁类型 | 适用场景 | 优点 | 缺点 |
|---|---|---|---|
| 互斥锁（Mutex） | 通用场景，保护共享资源，保证互斥访问 | 实现简单，适用性广 | 竞争激烈时性能下降，上下文切换开销 |
| 读写锁（ReadWriteMutex） | 读多写少场景，提高并发读取性能 | 允许多个线程同时读取，提高并发度 | 写操作或读临界区过长时性能下降，实现相对复杂 |
| 自旋锁（Spinlock） | 临界区非常短，锁竞争不激烈场景 | 避免线程阻塞和唤醒开销 | 竞争激烈时消耗大量 CPU 资源，可能导致饥饿 |
| 乐观锁（Optimistic Lock） | 并发冲突较少场景，追求极致性能 | 无锁，避免锁的开销 | 实现复杂，需要处理冲突回滚，适用场景有限 |
选择锁类型时，需要根据具体的应用场景和性能需求进行权衡。通常情况下，互斥锁是默认且稳妥的选择。对于读多写少的场景，可以考虑使用读写锁。对于临界区非常短且锁竞争不激烈的场景，可以考虑使用自旋锁。对于追求极致性能且并发冲突较少的场景，可以考虑使用乐观锁或无锁数据结构。
7.1.2 上下文切换开销 (Context Switching Overhead)
当线程因为等待锁而被阻塞时，操作系统会将该线程挂起，并切换到另一个就绪线程执行。这个过程称为上下文切换（Context Switching）。上下文切换涉及到保存和恢复线程的上下文（包括寄存器、堆栈、程序计数器等），以及更新调度器的数据结构，这些操作都会带来性能开销。
① 上下文切换的发生: 当线程尝试获取已被其他线程持有的互斥锁或读写锁（写锁）时，会发生阻塞，从而可能导致上下文切换。自旋锁在等待锁释放的过程中不会发生上下文切换，但会持续占用 CPU 资源。
② 上下文切换的开销: 上下文切换的开销主要包括：
▮▮▮▮⚝ 保存和恢复上下文: 操作系统需要保存当前线程的执行状态，并加载下一个线程的执行状态。这个过程涉及到大量的寄存器和内存操作。
▮▮▮▮⚝ 缓存失效: 线程切换会导致 CPU 缓存失效，因为新线程访问的数据可能不在缓存中，需要重新从内存加载，降低了缓存命中率。
▮▮▮▮⚝ 调度器开销: 操作系统调度器需要维护线程的就绪队列、等待队列等数据结构，并进行调度决策，这些操作也会消耗一定的 CPU 资源。
上下文切换的开销在高性能并发程序中是一个不可忽视的因素。频繁的上下文切换会显著降低程序的整体性能。因此，减少锁的竞争，避免线程频繁阻塞，是降低上下文切换开销，提升并发性能的重要手段。
7.1.3 缓存失效 (Cache Invalidation)
在多核处理器系统中，每个 CPU 核心都有自己的高速缓存（Cache）。当多个线程在不同的核心上运行时，如果它们访问相同的共享数据，就可能发生缓存失效（Cache Invalidation）。
① 缓存一致性协议: 为了保证多个 CPU 核心缓存中数据的一致性，处理器通常采用缓存一致性协议（Cache Coherency Protocol），例如 MESI 协议。当一个核心修改了共享数据时，其他核心缓存中该数据的副本会被标记为无效（Invalid），需要重新从内存或其他核心的缓存中加载最新的数据。
② 锁与缓存失效: 锁的使用会加剧缓存失效的问题。当一个线程持有锁并修改了共享数据后，释放锁时，会触发缓存一致性协议，导致其他等待锁的线程所在核心的缓存失效。当这些线程获取锁并访问共享数据时，需要重新从内存加载数据，增加了内存访问延迟，降低了性能。
③ 伪共享（False Sharing）: 伪共享是缓存失效的一种特殊情况。当多个线程访问不相关的共享变量，但这些变量恰好位于同一个缓存行（Cache Line）时，由于缓存一致性协议的作用，一个线程修改其中一个变量会导致整个缓存行失效，从而影响到访问同一个缓存行中其他变量的线程。伪共享会导致不必要的缓存失效，降低性能。
为了减少缓存失效带来的性能影响，需要注意以下几点：
⚝ 减少共享数据的修改: 尽量减少对共享数据的修改操作，尤其是在临界区内。
⚝ 数据局部性: 尽量让线程访问的数据在同一个缓存行内，提高缓存命中率。
⚝ 避免伪共享: 合理安排数据布局，避免不相关的共享变量位于同一个缓存行。可以使用填充（Padding）等技术来避免伪共享。
7.1.4 锁的争用开销 (Lock Contention Overhead)
锁争用（Lock Contention）是指多个线程同时尝试获取同一个锁，导致线程阻塞或忙等待的现象。锁争用是锁性能开销的主要来源。
① 串行化执行: 当多个线程竞争同一个锁时，只有一个线程能够成功获取锁并进入临界区，其他线程必须等待。这使得原本可以并行执行的代码段变成了串行执行，降低了并发度，损失了性能。
② 线程阻塞与唤醒: 在高锁争用的情况下，线程会频繁地被阻塞和唤醒，上下文切换开销增加，进一步降低性能。
③ 公平锁与非公平锁: 锁的公平性也会影响锁争用开销。公平锁（Fair Lock）按照线程请求锁的顺序来分配锁，先请求的线程先获得锁。非公平锁（Non-fair Lock）则不保证请求顺序，后请求的线程可能先获得锁。公平锁可以避免线程饥饿问题，但会增加额外的调度开销，性能通常比非公平锁差。folly::Synchronized 默认使用的 std::mutex 通常是非公平锁。
④ 锁的粒度: 锁的粒度（Granularity）是指锁保护的资源范围。粗粒度锁（Coarse-grained Lock）保护的资源范围较大，例如，用一个锁保护整个数据结构。细粒度锁（Fine-grained Lock）保护的资源范围较小，例如，用多个锁分别保护数据结构的不同部分。粗粒度锁实现简单，但并发度低，容易造成锁争用。细粒度锁可以提高并发度，但实现复杂，容易引入死锁等问题。
为了降低锁争用开销，需要采取以下措施：
⚝ 减少锁的持有时间: 尽量缩短临界区的执行时间，减少线程持有锁的时间。
⚝ 减小锁的粒度: 使用细粒度锁，减小锁的保护范围，提高并发度。
⚝ 使用读写锁: 在读多写少的场景下，使用读写锁允许多个线程同时读取，降低锁争用。
⚝ 避免锁的过度使用: 在某些情况下，可以使用无锁数据结构或原子操作来代替锁，避免锁的开销。
7.2 减少锁竞争的方法 (Methods to Reduce Lock Contention)
锁竞争是并发程序性能下降的主要原因之一。减少锁竞争是提升并发性能的关键。本节将介绍几种常用的减少锁竞争的方法。
7.2.1 减小临界区 (Minimize Critical Sections)
减小临界区是最直接有效的减少锁竞争的方法。临界区是指需要加锁保护的代码段。临界区越小，线程持有锁的时间就越短，其他线程等待锁的时间也就越短，锁竞争自然就降低了。
① 只保护必要的代码: 仔细分析临界区代码，只保留真正需要同步互斥的代码，将不必要的操作移出临界区。例如，如果临界区内包含耗时的计算或 I/O 操作，可以考虑将这些操作移到临界区之外。
② 延迟加锁，尽早释放锁: 在进入临界区之前，尽量完成一些准备工作，例如，计算索引、获取参数等。在退出临界区之后，再进行一些后续处理，例如，更新统计信息、发送通知等。这样可以尽可能地缩短临界区的执行时间。
③ 代码示例: 假设有一个线程安全的计数器，原始实现如下：
1
#include <folly/Synchronized.h>
2
#include <mutex>
3
4
class Counter {
5
private:
6
folly::Synchronized<std::mutex> mutex_;
7
int count_ = 0;
8
9
public:
10
void increment() {
11
std::lock_guard<folly::Synchronized<std::mutex>> lock(mutex_); // 临界区开始
12
count_++; // 临界区核心操作
13
// 模拟一些耗时操作，例如日志记录
14
for (int i = 0; i < 1000; ++i) {
15
// ...
16
}
17
} // 临界区结束
18
19
int getCount() const {
20
std::lock_guard<folly::Synchronized<std::mutex>> lock(mutex_);
21
return count_;
22
}
23
};
优化后的代码，将耗时操作移出临界区：
1
#include <folly/Synchronized.h>
2
#include <mutex>
3
4
class Counter {
5
private:
6
folly::Synchronized<std::mutex> mutex_;
7
int count_ = 0;
8
9
public:
10
void increment() {
11
{
12
std::lock_guard<folly::Synchronized<std::mutex>> lock(mutex_); // 临界区开始
13
count_++; // 临界区核心操作
14
} // 临界区结束
15
// 模拟一些耗时操作，例如日志记录，移出临界区
16
for (int i = 0; i < 1000; ++i) {
17
// ...
18
}
19
}
20
21
int getCount() const {
22
std::lock_guard<folly::Synchronized<std::mutex>> lock(mutex_);
23
return count_;
24
}
25
};
通过将耗时操作移出临界区，减小了临界区的执行时间，降低了锁竞争，提高了并发性能。
7.2.2 细粒度锁 (Fine-Grained Locking)
细粒度锁是指将锁的保护范围缩小，用多个锁来保护不同的资源，从而提高并发度。与粗粒度锁（Coarse-grained Locking）相比，细粒度锁可以允许多个线程同时访问不同的资源，减少锁竞争。
① 数据结构拆分: 对于复杂的数据结构，例如哈希表、链表等，可以将数据结构拆分成多个独立的区域，每个区域使用一个独立的锁来保护。例如，对于哈希表，可以对每个桶（Bucket）使用一个独立的锁，允许多个线程同时访问不同的桶。
② 锁分段（Lock Striping）: 锁分段是一种常用的细粒度锁技术。将数据分成若干段，每段分配一个独立的锁。线程访问数据时，根据数据所属的段来选择对应的锁。锁分段可以有效地提高并发度，尤其是在数据访问分布均匀的情况下。
③ 代码示例: 假设有一个线程安全的哈希表，使用粗粒度锁的实现如下：
1
#include <folly/Synchronized.h>
2
#include <mutex>
3
#include <unordered_map>
4
5
class CoarseGrainedHashTable {
6
private:
7
folly::Synchronized<std::mutex> mutex_;
8
std::unordered_map<int, int> data_;
9
10
public:
11
void insert(int key, int value) {
12
std::lock_guard<folly::Synchronized<std::mutex>> lock(mutex_);
13
data_[key] = value;
14
}
15
16
int get(int key) const {
17
std::lock_guard<folly::Synchronized<std::mutex>> lock(mutex_);
18
auto it = data_.find(key);
19
return it == data_.end() ? -1 : it->second;
20
}
21
};
使用细粒度锁（锁分段）的实现如下：
1
#include <folly/Synchronized.h>
2
#include <mutex>
3
#include <unordered_map>
4
#include <vector>
5
6
class FineGrainedHashTable {
7
private:
8
static const int kNumBuckets = 16; // 分段数量
9
std::vector<folly::Synchronized<std::mutex>> bucketMutexes_;
10
std::vector<std::unordered_map<int, int>> buckets_;
11
12
int getBucketIndex(int key) const {
13
return std::abs(key) % kNumBuckets; // 简单的哈希函数
14
}
15
16
public:
17
FineGrainedHashTable() : bucketMutexes_(kNumBuckets), buckets_(kNumBuckets) {}
18
19
void insert(int key, int value) {
20
int bucketIndex = getBucketIndex(key);
21
std::lock_guard<folly::Synchronized<std::mutex>> lock(bucketMutexes_[bucketIndex]);
22
buckets_[bucketIndex][key] = value;
23
}
24
25
int get(int key) const {
26
int bucketIndex = getBucketIndex(key);
27
std::lock_guard<folly::Synchronized<std::mutex>> lock(bucketMutexes_[bucketIndex]);
28
auto it = buckets_[bucketIndex].find(key);
29
return it == buckets_[bucketIndex].end() ? -1 : it->second;
30
}
31
};
细粒度锁哈希表将哈希表分成多个桶，每个桶使用一个独立的锁。当多个线程访问不同的桶时，可以并发执行，提高了并发性能。但是，细粒度锁也增加了锁管理的复杂性，需要仔细设计锁的粒度，避免过度细分导致锁开销过大。
7.2.3 读写锁的应用 (Application of Read-Write Locks)
在读多写少的场景下，使用读写锁 folly::ReadWriteMutex 可以显著提高并发性能。读写锁允许多个线程同时读取共享资源，但只允许一个线程写入共享资源。
① 适用场景: 读写锁适用于以下场景：
▮▮▮▮⚝ 读操作远多于写操作: 例如，缓存系统、配置中心、字典服务等。
▮▮▮▮⚝ 读操作之间没有互斥需求: 多个线程可以同时读取共享数据。
▮▮▮▮⚝ 写操作需要独占访问: 写操作需要保证数据的一致性，需要独占访问共享数据。
② 性能优势: 在读多写少的场景下，使用读写锁的性能优势主要体现在：
▮▮▮▮⚝ 提高并发读取能力: 允许多个线程同时读取，提高了并发度。
▮▮▮▮⚝ 降低锁竞争: 读操作之间不会相互阻塞，减少了锁竞争。
③ 代码示例: 假设有一个缓存系统，使用互斥锁和读写锁的实现对比：
互斥锁实现：
1
#include <folly/Synchronized.h>
2
#include <mutex>
3
#include <unordered_map>
4
5
class MutexCache {
6
private:
7
folly::Synchronized<std::mutex> mutex_;
8
std::unordered_map<int, int> cache_;
9
10
public:
11
int get(int key) {
12
std::lock_guard<folly::Synchronized<std::mutex>> lock(mutex_); // 读操作加互斥锁
13
auto it = cache_.find(key);
14
return it == cache_.end() ? -1 : it->second;
15
}
16
17
void put(int key, int value) {
18
std::lock_guard<folly::Synchronized<std::mutex>> lock(mutex_); // 写操作加互斥锁
19
cache_[key] = value;
20
}
21
};
读写锁实现：
1
#include <folly/Synchronized.h>
2
#include <shared_mutex>
3
#include <unordered_map>
4
5
class ReadWriteCache {
6
private:
7
folly::Synchronized<folly::ReadWriteMutex> rwMutex_;
8
std::unordered_map<int, int> cache_;
9
10
public:
11
int get(int key) {
12
// 读操作加共享锁
13
std::shared_lock<folly::Synchronized<folly::ReadWriteMutex>> lock(rwMutex_);
14
auto it = cache_.find(key);
15
return it == cache_.end() ? -1 : it->second;
16
}
17
18
void put(int key, int value) {
19
// 写操作加独占锁
20
std::unique_lock<folly::Synchronized<folly::ReadWriteMutex>> lock(rwMutex_);
21
cache_[key] = value;
22
}
23
};
在读多写少的场景下，ReadWriteCache 的性能通常优于 MutexCache，因为 ReadWriteCache 允许多个线程同时读取缓存，提高了并发读取能力。但是，如果写操作非常频繁，或者读操作的临界区过长，读写锁的性能优势可能会降低，甚至不如互斥锁。因此，需要根据具体的应用场景进行性能测试和评估。
7.2.4 无锁数据结构 (Lock-Free Data Structures)
无锁数据结构（Lock-Free Data Structures）是指在并发访问共享数据时，不使用锁，而是使用原子操作等技术来保证线程安全的数据结构。无锁数据结构可以避免锁的开销，提高并发性能，尤其是在高并发、低延迟的场景下。
① 原子操作: 原子操作是指不可中断的操作，要么全部执行成功，要么全部不执行。C++ 标准库提供了 std::atomic 模板类，用于支持原子操作。Folly 库也提供了更丰富的原子操作工具，例如 folly/AtomicHashMap.h，folly/AtomicQueue.h 等。
② CAS 操作（Compare-and-Swap）: CAS 操作是一种常用的原子操作，用于实现无锁数据结构。CAS 操作包含三个参数：内存地址 V，旧的预期值 A，新的值 B。CAS 操作会原子地比较内存地址 V 的值是否等于 A，如果等于，则将 V 的值更新为 B，并返回 true；否则，返回 false。
③ 无锁数据结构的优势:
▮▮▮▮⚝ 避免锁的开销: 无锁数据结构不需要加锁和解锁，避免了锁的性能开销，例如上下文切换、缓存失效等。
▮▮▮▮⚝ 提高并发性能: 允许多个线程同时并发访问数据结构，提高了并发性能。
▮▮▮▮⚝ 避免死锁和活锁: 无锁数据结构不会发生死锁和活锁问题。
④ 无锁数据结构的挑战:
▮▮▮▮⚝ 实现复杂: 无锁数据结构的实现通常比较复杂，需要仔细考虑各种并发场景，保证线程安全和正确性。
▮▮▮▮⚝ ABA 问题: CAS 操作可能存在 ABA 问题。如果一个值从 A 变为 B，又从 B 变回 A，CAS 操作可能会误认为值没有发生变化。需要使用版本号或标记位等技术来解决 ABA 问题。
▮▮▮▮⚝ 适用场景有限: 无锁数据结构并非适用于所有场景。对于复杂的并发控制逻辑，使用锁可能更简单可靠。
⑤ Folly 库的无锁数据结构: Folly 库提供了多种无锁数据结构的实现，例如：
▮▮▮▮⚝ folly::AtomicHashMap: 无锁哈希表。
▮▮▮▮⚝ folly::AtomicQueue: 无锁队列。
▮▮▮▮⚝ folly::ConcurrentSkipList: 无锁跳跃表。
在选择使用无锁数据结构时，需要权衡其优势和挑战，根据具体的应用场景和性能需求进行选择。通常情况下，对于简单的并发数据结构，例如计数器、队列等，可以考虑使用无锁数据结构。对于复杂的数据结构和并发控制逻辑，使用锁可能更稳妥。
7.3 死锁与活锁的预防与避免 (Prevention and Avoidance of Deadlocks and Livelocks)
死锁（Deadlock）和活锁（Livelock）是并发编程中常见的活性故障。死锁是指两个或多个线程互相等待对方释放资源，导致所有线程都无法继续执行的状态。活锁是指多个线程为了避免死锁，不断地重试操作，但始终无法成功执行的状态。本节将介绍死锁和活锁的成因、预防和避免方法。
7.3.1 死锁的成因与四个必要条件 (Causes of Deadlocks and Four Necessary Conditions)
死锁的发生通常需要满足以下四个必要条件，这四个条件也被称为 Coffman 条件：
① 互斥条件（Mutual Exclusion）: 至少有一个资源必须处于独占模式，即一次只有一个线程可以使用该资源。例如，互斥锁和写锁都满足互斥条件。
② 持有并等待条件（Hold and Wait）: 一个线程在持有一个资源的同时，又请求另一个被其他线程占用的资源。
③ 不可剥夺条件（No Preemption）: 线程已获得的资源在未使用完之前，不能被强制剥夺，只能由持有线程主动释放。
④ 循环等待条件（Circular Wait）: 存在一个线程等待资源的环路链，例如，线程 A 等待线程 B 持有的资源，线程 B 等待线程 C 持有的资源，...，线程 Z 等待线程 A 持有的资源，形成一个环形等待链。
只有当这四个条件同时满足时，才会发生死锁。破坏其中任何一个条件，就可以预防死锁的发生。
7.3.2 死锁预防策略 (Deadlock Prevention Strategies)
死锁预防是指通过破坏死锁发生的必要条件来预防死锁。常用的死锁预防策略包括：
① 破坏互斥条件: 尽量减少资源的互斥使用。例如，使用无锁数据结构、读写锁（允许多个线程同时读取）等。但互斥条件在很多情况下是必要的，无法完全避免。
② 破坏持有并等待条件: 有两种常用的方法：
▮▮▮▮⚝ 一次性申请所有资源: 线程在开始执行前，一次性申请所有需要的资源。如果任何一个资源无法获取，则释放所有已获取的资源，并稍后重试。这种方法简单有效，但资源利用率较低，可能导致线程饥饿。
▮▮▮▮⚝ 按需申请资源，但持有资源期间不申请新资源: 线程在持有资源期间，不允许再申请新的资源。如果需要新的资源，必须先释放已持有的资源。这种方法可以提高资源利用率，但实现较为复杂。
③ 破坏不可剥夺条件: 当一个线程请求资源失败时，可以剥夺其他线程已持有的资源。这种方法实现复杂，可能导致数据不一致，通常不常用。
④ 破坏循环等待条件: 资源排序（Resource Ordering）是一种常用的破坏循环等待条件的方法。将所有资源进行编号排序，线程在申请资源时，必须按照资源编号的递增顺序申请。例如，如果线程需要同时申请锁 A 和锁 B，且锁 A 的编号小于锁 B 的编号，则线程必须先申请锁 A，再申请锁 B。资源排序可以打破循环等待链，预防死锁的发生。
代码示例：资源排序预防死锁
假设有两个锁 mutex1 和 mutex2，为了避免死锁，我们规定申请锁的顺序必须是先 mutex1 后 mutex2。
1
#include <folly/Synchronized.h>
2
#include <mutex>
3
#include <thread>
4
5
folly::Synchronized<std::mutex> mutex1;
6
folly::Synchronized<std::mutex> mutex2;
7
8
void thread1_func() {
9
std::lock_guard<folly::Synchronized<std::mutex>> lock1(mutex1); // 先申请 mutex1
10
std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 模拟持有 mutex1 期间的操作
11
std::lock_guard<folly::Synchronized<std::mutex>> lock2(mutex2); // 再申请 mutex2
12
// ... 临界区操作
13
}
14
15
void thread2_func() {
16
std::lock_guard<folly::Synchronized<std::mutex>> lock1(mutex1); // 先申请 mutex1，顺序一致
17
std::this_thread::sleep_for(std::chrono::milliseconds(100));
18
std::lock_guard<folly::Synchronized<std::mutex>> lock2(mutex2); // 再申请 mutex2，顺序一致
19
// ... 临界区操作
20
}
21
22
int main() {
23
std::thread t1(thread1_func);
24
std::thread t2(thread2_func);
25
t1.join();
26
t2.join();
27
return 0;
28
}
通过统一的资源申请顺序，可以有效地预防死锁的发生。资源排序是一种简单有效的死锁预防策略，在实际并发编程中广泛应用。
7.3.3 死锁避免策略 (Deadlock Avoidance Strategies)
死锁避免是指在资源分配过程中，通过动态地检测系统状态，避免系统进入死锁状态。常用的死锁避免策略包括：
① 银行家算法（Banker's Algorithm）: 银行家算法是一种经典的死锁避免算法。它将系统中的资源和线程看作银行的资金和客户，通过模拟资源分配过程，判断资源分配是否会导致死锁。如果资源分配会导致死锁，则拒绝分配；否则，允许分配。银行家算法需要预先知道每个线程需要的最大资源量，资源利用率较高，但实现复杂，开销较大，实际应用较少。
② 资源分配图（Resource Allocation Graph）: 资源分配图是一种图形化的死锁检测和避免工具。它用节点表示线程和资源，用边表示线程请求资源和资源分配情况。通过分析资源分配图，可以检测是否存在环路等待，从而判断是否会发生死锁。资源分配图可以用于死锁检测和避免，但开销较大，适用于资源数量和线程数量较少的系统。
死锁避免策略通常比死锁预防策略更复杂，开销更大，实际应用较少。在大多数情况下，死锁预防策略（例如资源排序）已经足够有效。
7.3.4 活锁的成因与避免 (Causes of Livelocks and Avoidance)
活锁是指多个线程为了避免死锁，不断地重试操作，但由于某些条件始终无法满足，导致所有线程都无法继续执行的状态。活锁与死锁类似，都是活性故障，但活锁中的线程并没有被阻塞，而是在不断地“忙碌”地重试。
① 活锁的成因: 活锁通常发生在以下场景：
▮▮▮▮⚝ 冲突检测与退避: 多个线程同时检测到冲突，并尝试退避（例如，随机等待一段时间后重试）。如果退避策略不当，可能导致所有线程始终无法成功执行。
▮▮▮▮⚝ 礼让式锁（Polite Lock）: 某些锁实现采用礼让策略，当线程请求锁失败时，主动释放 CPU 时间片，让其他线程执行。如果多个线程同时礼让，可能导致活锁。
② 活锁的例子: 经典的“哲学家进餐问题”在某些情况下可能出现活锁。如果哲学家在拿起左手边的叉子后，发现右手边的叉子被占用，就放下左手边的叉子，等待一段时间后重试。如果所有哲学家都同时拿起左手边的叉子，然后发现右手边的叉子被占用，都放下左手边的叉子，并同时重试，就可能陷入活锁状态，所有哲学家都无法吃到面条。
③ 活锁的避免: 避免活锁的方法通常包括：
▮▮▮▮⚝ 随机退避（Randomized Backoff）: 当线程重试操作时，等待一个随机的时间间隔。随机退避可以错开线程的重试时间，降低冲突概率，避免活锁。
▮▮▮▮⚝ 优先级机制: 为线程设置优先级，让高优先级线程优先执行。可以避免低优先级线程始终无法获得资源，导致活锁。
▮▮▮▮⚝ 固定退避时间: 与随机退避类似，但使用固定的退避时间。需要根据具体场景选择合适的固定退避时间。
代码示例：随机退避避免活锁
假设有两个线程需要竞争访问共享资源，使用随机退避策略避免活锁。
1
#include <folly/Synchronized.h>
2
#include <mutex>
3
#include <thread>
4
#include <random>
5
6
folly::Synchronized<std::mutex> resourceMutex;
7
std::random_device rd;
8
std::mt19937 gen(rd());
9
std::uniform_int_distribution<> distrib(10, 100); // 随机等待时间范围
10
11
void thread_func(int threadId) {
12
for (int i = 0; i < 5; ++i) {
13
while (true) {
14
if (resourceMutex.try_lock()) { // 尝试获取锁
15
std::cout << "Thread " << threadId << " acquired lock, iteration " << i << std::endl;
16
std::this_thread::sleep_for(std::chrono::milliseconds(50)); // 模拟临界区操作
17
resourceMutex.unlock();
18
break; // 成功获取锁，退出重试循环
19
} else {
20
int backoffTime = distrib(gen); // 生成随机退避时间
21
std::cout << "Thread " << threadId << " failed to acquire lock, backing off for " << backoffTime << "ms" << std::endl;
22
std::this_thread::sleep_for(std::chrono::milliseconds(backoffTime)); // 随机等待
23
}
24
}
25
}
26
}
27
28
int main() {
29
std::thread t1(thread_func, 1);
30
std::thread t2(thread_func, 2);
31
t1.join();
32
t2.join();
33
return 0;
34
}
通过随机退避策略，可以有效地降低活锁发生的概率，提高程序的健壮性。
7.4 Synchronized 的性能优化技巧 (Performance Optimization Techniques for Synchronized)
folly::Synchronized 提供了便捷的线程同步机制。合理使用 Synchronized 可以提高并发程序的性能。本节将介绍一些 Synchronized 的性能优化技巧。
7.4.1 选择合适的锁类型 (Choosing the Right Lock Type)
folly::Synchronized 可以与不同的锁类型结合使用，例如 std::mutex 和 folly::ReadWriteMutex。选择合适的锁类型对性能至关重要。
① 默认互斥锁 (std::mutex): folly::Synchronized<std::mutex> 是默认的锁类型，适用于通用场景。如果对性能没有特殊要求，或者不确定哪种锁类型更合适，可以使用默认的互斥锁。
② 读写锁 (folly::ReadWriteMutex): folly::Synchronized<folly::ReadWriteMutex> 适用于读多写少的场景。在读多写少的场景下，使用读写锁可以显著提高并发读取性能。
③ 自旋锁 (folly::MicroSpinLock): folly::Synchronized<folly::MicroSpinLock> 适用于临界区非常短，且锁竞争不激烈的场景。自旋锁可以避免线程阻塞和唤醒的开销，但需要谨慎使用，避免在高竞争场景下消耗过多 CPU 资源。
④ 根据场景选择: 根据具体的应用场景和性能需求，选择合适的锁类型。例如，对于缓存系统，可以使用 folly::Synchronized<folly::ReadWriteMutex>；对于简单的计数器，可以使用 folly::Synchronized<std::mutex>；对于非常短的临界区，可以考虑使用 folly::Synchronized<folly::MicroSpinLock>。
7.4.2 合理使用 try_lock() 和超时机制 (Proper Use of try_lock() and Timeout Mechanism)
folly::Synchronized 提供了 try_lock() 方法和超时机制，可以用于避免死锁和活锁，提高程序的健壮性。
① try_lock() 避免死锁: try_lock() 方法尝试非阻塞地获取锁。如果锁已被占用，try_lock() 会立即返回 false，而不会阻塞线程。可以使用 try_lock() 来检测是否可能发生死锁，并采取相应的措施，例如，释放已持有的锁，稍后重试。
② 超时机制避免活锁: folly::Synchronized 的 lock_shared_for() 和 lock_unique_for() 方法提供了超时机制。可以设置一个超时时间，如果在超时时间内无法获取锁，则放弃等待，避免长时间等待导致活锁。
③ 代码示例：使用 try_lock() 和超时机制
1
#include <folly/Synchronized.h>
2
#include <mutex>
3
#include <thread>
4
#include <chrono>
5
6
folly::Synchronized<std::mutex> mutex1;
7
folly::Synchronized<std::mutex> mutex2;
8
9
void thread1_func() {
10
if (mutex1.try_lock_for(std::chrono::milliseconds(100))) { // 带超时时间的 try_lock
11
std::cout << "Thread 1 acquired mutex1" << std::endl;
12
std::this_thread::sleep_for(std::chrono::milliseconds(50));
13
if (mutex2.try_lock_for(std::chrono::milliseconds(100))) {
14
std::cout << "Thread 1 acquired mutex2" << std::endl;
15
// ... 临界区操作
16
mutex2.unlock();
17
} else {
18
std::cout << "Thread 1 failed to acquire mutex2, releasing mutex1" << std::endl;
19
mutex1.unlock(); // 获取 mutex2 失败，释放 mutex1，避免死锁
20
}
21
mutex1.unlock();
22
} else {
23
std::cout << "Thread 1 failed to acquire mutex1" << std::endl;
24
}
25
}
26
27
void thread2_func() {
28
if (mutex2.try_lock_for(std::chrono::milliseconds(100))) {
29
std::cout << "Thread 2 acquired mutex2" << std::endl;
30
std::this_thread::sleep_for(std::chrono::milliseconds(50));
31
if (mutex1.try_lock_for(std::chrono::milliseconds(100))) {
32
std::cout << "Thread 2 acquired mutex1" << std::endl;
33
// ... 临界区操作
34
mutex1.unlock();
35
} else {
36
std::cout << "Thread 2 failed to acquire mutex1, releasing mutex2" << std::endl;
37
mutex2.unlock(); // 获取 mutex1 失败，释放 mutex2，避免死锁
38
}
39
mutex2.unlock();
40
} else {
41
std::cout << "Thread 2 failed to acquire mutex2" << std::endl;
42
}
43
}
44
45
int main() {
46
std::thread t1(thread1_func);
47
std::thread t2(thread2_func);
48
t1.join();
49
t2.join();
50
return 0;
51
}
合理使用 try_lock() 和超时机制可以提高程序的健壮性，避免死锁和活锁，但也会增加代码的复杂性。需要根据具体的应用场景进行权衡。
7.4.3 条件变量的优化使用 (Optimized Use of Condition Variables)
folly::Synchronized 结合条件变量 std::condition_variable 可以实现复杂的同步模式，例如生产者-消费者模型。优化条件变量的使用可以提高程序的性能和效率。
① 避免虚假唤醒（Spurious Wakeups）: 条件变量的 wait() 操作可能会发生虚假唤醒，即在没有 notify_one() 或 notify_all() 的情况下被唤醒。为了避免虚假唤醒带来的问题，需要在 wait() 的循环条件中再次检查等待条件是否满足。
② 使用 notify_one() 优先于 notify_all(): 如果只需要唤醒一个等待线程，优先使用 notify_one()，而不是 notify_all()。notify_all() 会唤醒所有等待线程，可能导致不必要的线程竞争和上下文切换。
③ 代码示例：优化条件变量的使用
1
#include <folly/Synchronized.h>
2
#include <mutex>
3
#include <condition_variable>
4
#include <queue>
5
6
class MessageQueue {
7
private:
8
folly::Synchronized<std::mutex> mutex_;
9
std::condition_variable cv_;
10
std::queue<int> messages_;
11
12
public:
13
void enqueue(int message) {
14
{
15
std::lock_guard<folly::Synchronized<std::mutex>> lock(mutex_);
16
messages_.push(message);
17
}
18
cv_.notify_one(); // 使用 notify_one()，只唤醒一个消费者
19
}
20
21
int dequeue() {
22
std::unique_lock<folly::Synchronized<std::mutex>> lock(mutex_);
23
cv_.wait(lock, [this] { return !messages_.empty(); }); // 循环条件检查，避免虚假唤醒
24
int message = messages_.front();
25
messages_.pop();
26
return message;
27
}
28
};
在条件变量的 wait() 操作中使用循环条件检查，可以避免虚假唤醒带来的问题。使用 notify_one() 优先于 notify_all()，可以减少不必要的线程唤醒和竞争。
7.4.4 结合其他 Folly 库工具 (Combining with Other Folly Library Tools)
Folly 库提供了丰富的并发工具，例如原子操作、无锁数据结构、协程等。结合其他 Folly 库工具可以进一步优化 Synchronized 的性能。
① 原子操作代替简单锁: 对于简单的同步需求，例如计数器、标志位等，可以使用 folly::Atomic 或 std::atomic 等原子操作代替 Synchronized<std::mutex>，避免锁的开销。
② 无锁数据结构代替锁保护的数据结构: 对于高并发、低延迟的场景，可以考虑使用 Folly 库提供的无锁数据结构，例如 folly::AtomicHashMap、folly::AtomicQueue 等，代替使用 Synchronized 保护的传统数据结构。
③ 协程与异步编程: Folly 库的协程 folly::coro 和异步编程框架 folly::Future 可以用于构建高性能的并发程序。结合 Synchronized 和协程/异步编程，可以实现更灵活、更高效的并发控制。
④ 性能测试与调优: 在进行性能优化时，务必进行充分的性能测试和调优。使用性能分析工具（例如 gprof、perf 等）来定位性能瓶颈，并根据测试结果选择合适的优化策略。
总结: folly::Synchronized 是一个强大的线程同步工具。通过选择合适的锁类型、合理使用 try_lock() 和超时机制、优化条件变量的使用，以及结合其他 Folly 库工具，可以充分发挥 Synchronized 的性能优势，构建高性能、高可靠的并发程序。
END_OF_CHAPTER
8. chapter 8：Synchronized 与其他同步机制的比较 (Comparison of Synchronized with Other Synchronization Mechanisms)
8.1 与 std::mutex, std::shared_mutex 的对比 (Comparison with std::mutex, std::shared_mutex)
folly::Synchronized 是 Folly 库提供的同步原语，它在 C++ 标准库的 std::mutex 和 std::shared_mutex 的基础上进行了封装和扩展，旨在提供更安全、更易用且功能更强大的互斥锁机制。本节将深入对比 Synchronized 与 std::mutex、std::shared_mutex，帮助读者理解它们之间的异同，并根据实际场景做出合适的选择。
① 核心概念对比 (Core Concept Comparison)
⚝ std::mutex (互斥锁)：std::mutex 是 C++ 标准库提供的基本互斥锁，用于保护共享数据免受并发访问的影响。它提供独占访问，即同一时刻只允许一个线程持有锁并访问临界区。std::mutex 的主要操作包括 lock()（加锁）、unlock()（解锁）、try_lock()（尝试加锁）等。
⚝ std::shared_mutex (共享互斥锁)：std::shared_mutex 也是 C++ 标准库的一部分，提供了读写锁的功能。它允许多个线程同时持有读锁，但只允许一个线程持有写锁，或者没有线程持有任何锁。std::shared_mutex 适用于读操作远多于写操作的场景，可以提高并发性能。其主要操作包括 lock_shared()（获取共享锁/读锁）、unlock_shared()（释放共享锁/读锁）、lock()（获取独占锁/写锁）、unlock()（释放独占锁/写锁）等。
⚝ folly::Synchronized (同步器)：folly::Synchronized 是 Folly 库提供的模板类，它基于 RAII (Resource Acquisition Is Initialization) 原则，将互斥锁（默认使用 std::mutex，也可以指定其他互斥锁类型，如 std::shared_mutex）封装在内部，并通过模板参数 class GuardPolicy 来控制锁的行为。Synchronized 的核心优势在于其自动化的锁管理和更丰富的 API 接口。
② 功能特性对比 (Feature Comparison)
| 特性 (Feature) | std::mutex | std::shared_mutex | folly::Synchronized |
|---|---|---|---|
| 锁类型 (Lock Type) | 独占锁 (Exclusive Lock) | 读写锁 (Read-Write Lock) | 可配置 (Configurable) |
| RAII 支持 (RAII Support) | 手动管理 (Manual) | 手动管理 (Manual) | 自动管理 (Automatic) |
| 异常安全性 (Exception Safety) | 需手动处理 (Manual) | 需手动处理 (Manual) | 内置支持 (Built-in) |
| API 丰富度 (API Richness) | 基础 (Basic) | 基础 (Basic) | 丰富 (Rich) |
| 可扩展性 (Extensibility) | 有限 (Limited) | 有限 (Limited) | 高 (High) |
| 性能 (Performance) | 基础 (Basic) | 读多写少场景更优 (Better for read-heavy) | 可优化 (Optimizable) |
③ 使用方式对比 (Usage Comparison)
⚝ std::mutex 和 std::shared_mutex 的手动管理
1
使用 `std::mutex` 和 `std::shared_mutex` 时，需要手动调用 `lock()` 和 `unlock()` 来管理锁的生命周期。这容易出错，尤其是在存在异常抛出的情况下，可能导致锁未被正确释放，从而引发死锁或其他并发问题。
1
#include <mutex>
2
#include <iostream>
3
4
std::mutex mtx;
5
int shared_data = 0;
6
7
void increment() {
8
mtx.lock(); // 手动加锁
9
try {
10
shared_data++;
11
// ... 临界区代码 ...
12
} catch (...) {
13
mtx.unlock(); // 异常情况下也需要手动解锁，容易遗漏
14
throw;
15
}
16
mtx.unlock(); // 手动解锁
17
}
⚝ folly::Synchronized 的自动管理
1
`folly::Synchronized` 通过 RAII 机制，在构造函数中获取锁，在析构函数中自动释放锁，极大地简化了锁的管理，并提高了代码的异常安全性。
1
#include <folly/Synchronized.h>
2
#include <iostream>
3
4
folly::Synchronized<int> synchronized_data = 0;
5
6
void increment_synchronized() {
7
auto locked_data = synchronized_data.wlock(); // 自动加写锁，返回 Guard 对象
8
*locked_data += 1;
9
// Guard 对象 locked_data 在离开作用域时自动解锁
10
}
1
在上述 `folly::Synchronized` 的示例中，`synchronized_data.wlock()` 返回一个 `Guard` 对象 `locked_data`，它在构造时获取写锁，在离开作用域（函数 `increment_synchronized` 结束）时，其析构函数会自动释放锁。即使在临界区代码中抛出异常，锁也能得到保证释放，避免了死锁的风险。
④ API 接口对比 (API Interface Comparison)
⚝ std::mutex 和 std::shared_mutex 的基本 API
1
`std::mutex` 和 `std::shared_mutex` 提供了基本的 `lock()`、`unlock()`、`try_lock()` 等方法，API 相对简单。
⚝ folly::Synchronized 的丰富 API
1
`folly::Synchronized` 提供了更丰富的 API，包括：
▮▮▮▮⚝ rlock(): 获取读锁 (read lock)，适用于共享互斥锁。
▮▮▮▮⚝ wlock(): 获取写锁 (write lock)，适用于任何互斥锁。
▮▮▮▮⚝ lock(): 根据 GuardPolicy 获取锁，默认行为通常是获取写锁。
▮▮▮▮⚝ try_rlock()、try_wlock()、try_lock(): 尝试获取锁，非阻塞。
▮▮▮▮⚝ withRLock()、withWLock()、withLock(): 以 lambda 表达式方式执行临界区代码，进一步简化使用。
▮▮▮▮⚝ 可自定义 GuardPolicy，灵活控制锁的行为。
1
`folly::Synchronized` 的 `withLock()` 系列方法，结合 lambda 表达式，可以使代码更加简洁和易读：
1
folly::Synchronized<int> synchronized_value = 10;
2
3
void modify_value() {
4
synchronized_value.withWLock([](int& value) {
5
value *= 2;
6
std::cout << "Value modified inside lambda: " << value << std::endl;
7
}); // lambda 结束后自动释放锁
8
}
⑤ 性能考量 (Performance Considerations)
⚝ 基本性能：std::mutex 和 std::shared_mutex 作为标准库组件，其性能经过充分优化，通常能满足大多数场景的需求。
⚝ folly::Synchronized 的开销：folly::Synchronized 在 std::mutex 或 std::shared_mutex 之上增加了一层封装，引入了少量的额外开销。然而，这种开销通常可以忽略不计，尤其是在临界区代码执行时间较长的情况下。Synchronized 带来的代码简洁性和安全性提升通常远大于这点性能损失。
⚝ 读写锁的优势：在读多写少的场景下，使用 std::shared_mutex 或配置 folly::Synchronized 使用 ReadWriteMutex 可以显著提高并发性能，允许多个线程同时读取共享数据，减少锁竞争。
⑥ 选择建议 (Selection Recommendations)
⚝ 简单互斥需求：如果只需要基本的互斥锁功能，且对代码简洁性要求不高，std::mutex 可以满足需求。
⚝ 读多写少场景：如果应用场景是读操作远多于写操作，为了提高并发性能，应优先考虑 std::shared_mutex 或配置 folly::Synchronized 使用 ReadWriteMutex。
⚝ 强调安全性和易用性：如果更关注代码的异常安全性、简洁性和易用性，希望避免手动管理锁的繁琐和潜在错误，folly::Synchronized 是更佳选择。它通过 RAII 机制和丰富的 API，大大简化了并发编程，降低了出错的概率。
⚝ Folly 库生态：如果项目已经使用了 Folly 库，或者计划使用 Folly 库的其他组件，那么使用 folly::Synchronized 可以保持代码风格的一致性，并充分利用 Folly 库提供的便利性。
⑦ 总结 (Summary)
folly::Synchronized 并非要完全替代 std::mutex 和 std::shared_mutex，而是作为一种更高级、更易用的同步工具，在它们的基础上提供了更强大的功能和更好的用户体验。在选择同步机制时，需要根据具体的应用场景、性能需求、代码复杂度和团队的开发习惯等因素综合考虑，选择最合适的工具。通常情况下，folly::Synchronized 由于其 RAII 特性、丰富的 API 和良好的异常安全性，是一个值得优先考虑的选项，尤其是在现代 C++ 并发编程中，强调代码的安全性、可维护性和开发效率的背景下，Synchronized 的优势更加明显。
8.2 与 std::atomic 的选择 (Choosing between Synchronized and std::atomic)
std::atomic (原子操作) 是 C++ 标准库提供的用于实现原子操作的工具，它允许在没有互斥锁的情况下对单个变量进行线程安全的操作。folly::Synchronized 和 std::atomic 都是用于并发编程的重要工具，但它们解决的问题和适用场景有所不同。本节将对比 Synchronized 和 std::atomic，帮助读者理解它们各自的特点，并指导如何在实际开发中做出选择。
① 核心概念对比 (Core Concept Comparison)
⚝ std::atomic (原子操作)：std::atomic 提供了一种机制，保证对某个变量的操作是原子性的，即不可中断的。原子操作通常用于简单的、对单个变量的读写、修改等操作，例如原子计数器、原子标志位等。原子操作避免了使用互斥锁的开销，可以提高性能，尤其是在高并发、低竞争的场景下。
⚝ folly::Synchronized (同步器)：folly::Synchronized 基于互斥锁，用于保护临界区，即一段需要原子执行的代码块。临界区可以包含多个操作，甚至复杂的逻辑。Synchronized 适用于需要保护多个变量或需要执行一系列操作的场景，提供了更通用的同步机制。
② 功能特性对比 (Feature Comparison)
| 特性 (Feature) | std::atomic | folly::Synchronized |
|---|---|---|
| 操作粒度 (Operation Granularity) | 单个变量 (Single variable) | 临界区 (Critical section)，可以包含多个操作和变量 |
| 同步机制 (Synchronization Mechanism) | 原子操作指令 (Atomic instructions) | 互斥锁 (Mutex-based) |
| 性能开销 (Performance Overhead) | 低 (Low)，通常无锁 (Lock-free in many cases) | 中等 (Medium)，锁竞争时开销较高 (Higher with contention) |
| 适用场景 (Use Cases) | 简单原子操作，如计数器、标志位 (Simple atomic operations) | 保护复杂临界区，需要原子执行多个操作 (Complex critical sections) |
| 代码复杂度 (Code Complexity) | 较低 (Lower)，API 相对简单 (Simpler API) | 较高 (Higher)，API 更丰富，但使用更复杂 (Richer API, more complex usage) |
| 灵活性 (Flexibility) | 有限 (Limited)，仅限于原子操作 (Limited to atomic operations) | 高 (High)，可用于各种复杂的同步场景 (Versatile for complex synchronization) |
③ 使用场景对比 (Use Case Comparison)
⚝ 原子操作的适用场景 (std::atomic)
▮▮▮▮⚝ 原子计数器 (Atomic Counter)：例如，统计事件发生的次数，可以使用 std::atomic<int> 或 std::atomic<long long> 来实现线程安全的计数器。
1
#include <atomic>
2
#include <iostream>
3
#include <thread>
4
#include <vector>
5
6
std::atomic<int> counter = 0;
7
8
void increment_counter() {
9
for (int i = 0; i < 10000; ++i) {
10
counter++; // 原子自增操作
11
}
12
}
13
14
int main() {
15
std::vector<std::thread> threads;
16
for (int i = 0; i < 4; ++i) {
17
threads.emplace_back(increment_counter);
18
}
19
for (auto& thread : threads) {
20
thread.join();
21
}
22
std::cout << "Counter value: " << counter << std::endl; // 输出结果接近 40000
23
return 0;
24
}
▮▮▮▮⚝ 原子标志位 (Atomic Flag)：例如，控制线程的启动和停止，可以使用 std::atomic<bool> 作为原子标志位。
1
#include <atomic>
2
#include <iostream>
3
#include <thread>
4
#include <chrono>
5
6
std::atomic<bool> running = true;
7
8
void worker_thread() {
9
while (running) {
10
// ... 执行一些工作 ...
11
std::cout << "Worker thread is running..." << std::endl;
12
std::this_thread::sleep_for(std::chrono::milliseconds(100));
13
}
14
std::cout << "Worker thread stopped." << std::endl;
15
}
16
17
int main() {
18
std::thread worker(worker_thread);
19
std::this_thread::sleep_for(std::chrono::seconds(2));
20
running = false; // 原子写操作，通知 worker 线程停止
21
worker.join();
22
return 0;
23
}
⚝ Synchronized 的适用场景
▮▮▮▮⚝ 保护多个共享变量：当需要原子地更新多个相关的共享变量时，std::atomic 无法直接实现，需要使用互斥锁，例如 folly::Synchronized。
1
#include <folly/Synchronized.h>
2
#include <iostream>
3
4
struct Point {
5
int x;
6
int y;
7
};
8
9
folly::Synchronized<Point> synchronized_point = {0, 0};
10
11
void move_point(int dx, int dy) {
12
synchronized_point.wlock()->x += dx;
13
synchronized_point.wlock()->y += dy; // 错误示例！多次 wlock() 可能导致问题
14
}
15
16
void move_point_correct(int dx, int dy) {
17
auto locked_point = synchronized_point.wlock(); // 获取一次锁
18
locked_point->x += dx;
19
locked_point->y += dy; // 在锁的保护下同时修改 x 和 y
20
}
21
22
int main() {
23
move_point_correct(5, 10);
24
std::cout << "Point: (" << synchronized_point.rlock()->x << ", " << synchronized_point.rlock()->y << ")" << std::endl;
25
return 0;
26
}
▮▮▮▮⚝ 复杂的临界区操作：当临界区代码包含复杂的逻辑，例如条件判断、循环、函数调用等，使用 std::atomic 实现原子操作会非常困难甚至不可能，这时必须使用互斥锁，如 folly::Synchronized。
1
#include <folly/Synchronized.h>
2
#include <iostream>
3
#include <vector>
4
#include <algorithm>
5
6
folly::Synchronized<std::vector<int>> synchronized_list;
7
8
void process_list(int value) {
9
synchronized_list.withWLock([&](std::vector<int>& list) {
10
list.push_back(value);
11
std::sort(list.begin(), list.end()); // 临界区包含排序操作
12
std::cout << "List after processing: ";
13
for (int item : list) {
14
std::cout << item << " ";
15
}
16
std::cout << std::endl;
17
});
18
}
19
20
int main() {
21
process_list(5);
22
process_list(2);
23
process_list(8);
24
return 0;
25
}
④ 性能对比 (Performance Comparison)
⚝ 原子操作的性能优势：std::atomic 通常使用 CPU 的原子指令实现，开销非常低，尤其是在没有竞争的情况下，性能远高于互斥锁。原子操作通常是无锁的 (lock-free) 或低锁的 (wait-free)。
⚝ Synchronized 的性能开销：folly::Synchronized 基于互斥锁，当多个线程竞争同一个锁时，会发生线程阻塞和上下文切换，性能开销较高。锁的竞争越激烈，性能下降越明显。
⚝ 选择原则：
▮▮▮▮⚝ 优先使用原子操作：如果只需要对单个变量进行简单的原子操作（读、写、自增、自减、比较交换等），并且性能是关键因素，应优先考虑 std::atomic。
▮▮▮▮⚝ 必要时使用互斥锁：当需要保护多个变量或执行复杂的临界区代码时，std::atomic 无法满足需求，必须使用互斥锁，如 folly::Synchronized。
▮▮▮▮⚝ 混合使用：在某些复杂场景下，可以结合使用 std::atomic 和 folly::Synchronized。例如，可以使用原子变量作为快速路径的标志位，只有在特定条件下才进入 Synchronized 保护的临界区，以优化性能。
⑤ 代码复杂度对比 (Code Complexity Comparison)
⚝ std::atomic 的代码简洁性：std::atomic 的 API 相对简单，直接对原子变量进行操作，代码通常更简洁易懂。
⚝ Synchronized 的代码结构化：folly::Synchronized 通过 RAII 机制和 Guard 对象，将临界区代码结构化，提高了代码的可读性和可维护性。使用 withLock() 等方法，可以进一步简化代码，但整体而言，使用 Synchronized 的代码结构相对更复杂一些。
⑥ 选择建议 (Selection Recommendations)
⚝ 简单原子操作：对于简单的原子计数、标志位等场景，首选 std::atomic，以获得最佳性能和代码简洁性。
⚝ 复杂临界区：对于需要保护多个变量或执行复杂逻辑的临界区，必须使用 folly::Synchronized 或其他互斥锁机制。
⚝ 性能敏感型应用：在性能至关重要的应用中，应仔细评估是否可以使用 std::atomic 替代互斥锁。如果可以，应尽可能使用原子操作，以减少锁竞争和开销。
⚝ 代码可维护性：在代码可维护性要求较高的项目中，folly::Synchronized 的 RAII 机制和结构化代码可以提高代码的可靠性和可维护性，降低出错的风险。
⑦ 总结 (Summary)
std::atomic 和 folly::Synchronized 是并发编程中不同层面的同步工具。std::atomic 专注于提供高性能的原子操作，适用于简单的、对单个变量的操作；folly::Synchronized 则提供更通用的互斥锁机制，适用于保护复杂的临界区。在实际开发中，应根据具体的同步需求、性能要求和代码复杂度等因素，选择最合适的工具。在很多情况下，std::atomic 和 folly::Synchronized 可以协同工作，共同构建高效、可靠的并发程序。理解它们的差异和适用场景，有助于编写出更优的并发代码。
8.3 其他 Folly 库中的并发工具 (Other Concurrency Tools in Folly Library)
除了 folly::Synchronized，Folly 库还提供了丰富的其他并发工具，旨在帮助开发者更高效、更安全地构建并发程序。这些工具涵盖了多种并发编程模式和需求，本节将简要介绍一些常用的 Folly 并发工具，并说明它们的应用场景。
① folly::Baton (接力棒)
⚝ 功能：folly::Baton 是一种轻量级的同步原语，用于线程间的同步和通信。它类似于条件变量，但更加轻量级和易用。Baton 主要用于实现线程间的等待和通知机制，例如，一个线程等待另一个线程完成某个任务。
⚝ 应用场景：
▮▮▮▮⚝ 线程同步：协调多个线程的执行顺序，例如，主线程等待工作线程完成初始化后再继续执行。
▮▮▮▮⚝ 事件通知：一个线程等待某个事件发生，另一个线程在事件发生时通知等待线程。
▮▮▮▮⚝ 生产者-消费者模型：可以用于实现简单的生产者-消费者模型，生产者线程生产数据后通知消费者线程消费。
⚝ 示例：
1
#include <folly/Baton.h>
2
#include <iostream>
3
#include <thread>
4
5
folly::Baton<> baton;
6
bool task_completed = false;
7
8
void worker_thread() {
9
std::cout << "Worker thread started, doing some work..." << std::endl;
10
std::this_thread::sleep_for(std::chrono::seconds(2));
11
task_completed = true;
12
baton.post(); // 通知主线程任务已完成
13
std::cout << "Worker thread finished and posted baton." << std::endl;
14
}
15
16
int main() {
17
std::thread worker(worker_thread);
18
std::cout << "Main thread waiting for worker thread..." << std::endl;
19
baton.wait(); // 等待 worker 线程 post baton
20
std::cout << "Main thread received baton, task completed: " << task_completed << std::endl;
21
worker.join();
22
return 0;
23
}
② folly::EventCount (事件计数器)
⚝ 功能：folly::EventCount 是一种用于线程同步的计数器，它允许线程等待某个事件发生一定次数。EventCount 可以被多个线程递增，一个或多个线程可以等待计数器达到某个值。
⚝ 应用场景：
▮▮▮▮⚝ 多线程同步：等待多个线程完成某个阶段的任务后再继续执行。
▮▮▮▮⚝ 资源管理：限制并发访问资源的线程数量，例如，控制同时下载文件的线程数。
▮▮▮▮⚝ 测试同步逻辑：在单元测试中，验证多个线程是否按预期同步执行。
⚝ 示例：
1
#include <folly/EventCount.h>
2
#include <iostream>
3
#include <thread>
4
#include <vector>
5
6
folly::EventCount event_count;
7
const int num_threads = 4;
8
int completed_threads = 0;
9
10
void worker_thread(int thread_id) {
11
std::cout << "Thread " << thread_id << " started, doing some work..." << std::endl;
12
std::this_thread::sleep_for(std::chrono::seconds(1));
13
completed_threads++;
14
event_count.increment(); // 线程完成任务，递增事件计数器
15
std::cout << "Thread " << thread_id << " finished and incremented event count." << std::endl;
16
}
17
18
int main() {
19
std::vector<std::thread> threads;
20
for (int i = 0; i < num_threads; ++i) {
21
threads.emplace_back(worker_thread, i);
22
}
23
std::cout << "Main thread waiting for " << num_threads << " threads to complete..." << std::endl;
24
event_count.wait_for_value(num_threads); // 等待事件计数器达到 num_threads
25
std::cout << "All " << num_threads << " threads completed. Completed thread count: " << completed_threads << std::endl;
26
for (auto& thread : threads) {
27
thread.join();
28
}
29
return 0;
30
}
③ folly::Latch (闭锁)
⚝ 功能：folly::Latch 是一种倒计数闭锁，用于同步多个线程的开始或结束。Latch 初始化时设置一个计数器，多个线程可以递减计数器，当计数器减到零时，所有等待在 Latch 上的线程将被释放。
⚝ 应用场景：
▮▮▮▮⚝ 多线程启动同步：确保所有工作线程都准备就绪后再同时开始执行任务。
▮▮▮▮⚝ 多线程结束同步：等待所有工作线程都完成任务后再继续执行后续操作。
▮▮▮▮⚝ 并发测试：在并发测试中，控制多个线程同时开始执行测试代码。
⚝ 示例：
1
#include <folly/Latch.h>
2
#include <iostream>
3
#include <thread>
4
#include <vector>
5
6
folly::Latch latch(4); // 初始化 latch 计数器为 4
7
const int num_threads = 4;
8
9
void worker_thread(int thread_id) {
10
std::cout << "Thread " << thread_id << " is ready, waiting for latch..." << std::endl;
11
latch.count_down(); // 线程准备就绪，递减 latch 计数器
12
latch.wait(); // 等待 latch 计数器归零
13
std::cout << "Thread " << thread_id << " started working..." << std::endl;
14
std::this_thread::sleep_for(std::chrono::seconds(1));
15
std::cout << "Thread " << thread_id << " finished working." << std::endl;
16
}
17
18
int main() {
19
std::vector<std::thread> threads;
20
for (int i = 0; i < num_threads; ++i) {
21
threads.emplace_back(worker_thread, i);
22
}
23
std::cout << "Main thread waiting for all worker threads to be ready..." << std::endl;
24
latch.wait(); // 等待 latch 计数器归零，所有 worker 线程准备就绪
25
std::cout << "All worker threads are ready, starting work..." << std::endl;
26
for (auto& thread : threads) {
27
thread.join();
28
}
29
return 0;
30
}
④ folly::SharedMutex (共享互斥锁)
⚝ 功能：folly::SharedMutex 是 Folly 库提供的读写锁实现，与 std::shared_mutex 功能类似，但可能在某些方面有所优化或扩展。它允许多个线程同时持有读锁，但只允许一个线程持有写锁。
⚝ 应用场景：
▮▮▮▮⚝ 读多写少的数据结构：例如，缓存系统、配置管理系统等，读操作远多于写操作的场景。
▮▮▮▮⚝ 提高并发性能：在读操作频繁的场景下，使用读写锁可以显著提高并发性能，允许多个读者同时访问共享数据。
⚝ 使用方式：folly::SharedMutex 的使用方式与 std::shared_mutex 类似，可以通过 lock_shared() 获取读锁，unlock_shared() 释放读锁，lock() 获取写锁，unlock() 释放写锁。folly::Synchronized 可以配置使用 folly::SharedMutex 作为底层的互斥锁类型，以实现读写锁的功能。
⑤ folly::RWSpinLock (读写自旋锁)
⚝ 功能：folly::RWSpinLock 是一种读写自旋锁，与 folly::SharedMutex 类似，但使用自旋等待而不是线程阻塞来实现同步。自旋锁适用于临界区执行时间非常短，且锁竞争不激烈的场景。
⚝ 应用场景：
▮▮▮▮⚝ 超短临界区：当临界区代码执行时间非常短，线程阻塞和上下文切换的开销不可接受时，可以考虑使用自旋锁。
▮▮▮▮⚝ 低竞争环境：自旋锁在锁竞争激烈时会消耗大量 CPU 资源，因此只适用于低竞争的环境。
⚝ 注意事项：自旋锁应谨慎使用，过度使用自旋锁可能导致 CPU 资源浪费，甚至系统性能下降。通常情况下，应优先考虑使用基于阻塞的互斥锁，如 folly::SharedMutex 或 std::shared_mutex。
⑥ folly::MicroSpinLock (微自旋锁)
⚝ 功能：folly::MicroSpinLock 是一种非常轻量级的自旋锁，针对极短的临界区进行了优化。它比 folly::RWSpinLock 更加轻量级，但功能也更简单。
⚝ 应用场景：
▮▮▮▮⚝ 极短临界区：适用于纳秒级的临界区保护，例如，简单的计数器自增操作。
▮▮▮▮⚝ 极致性能要求：在对性能有极致要求的场景下，可以考虑使用 folly::MicroSpinLock，但需要非常谨慎地评估其适用性。
⚝ 注意事项：folly::MicroSpinLock 的使用限制更多，适用场景更窄，通常只在非常特殊的性能优化场景下才考虑使用。
⑦ 总结 (Summary)
Folly 库提供了丰富的并发工具，除了 folly::Synchronized，还包括 folly::Baton、folly::EventCount、folly::Latch、folly::SharedMutex、folly::RWSpinLock、folly::MicroSpinLock 等。这些工具各有特点，适用于不同的并发编程场景。开发者应根据具体的同步需求、性能要求和代码复杂度等因素，选择合适的工具。理解和掌握这些 Folly 并发工具，可以帮助开发者构建更高效、更可靠的并发程序，充分利用多核处理器的性能优势。在实际项目中，可以根据具体情况灵活组合使用这些工具，以满足各种复杂的并发需求。
END_OF_CHAPTER
9. chapter 9：高级主题与未来展望 (Advanced Topics and Future Outlook)
9.1 无锁编程简介 (Brief Introduction to Lock-Free Programming)
无锁编程（Lock-Free Programming）是一种并发编程范式，旨在避免传统锁机制带来的性能瓶颈和复杂性。在多线程环境中，锁虽然能够有效地保护共享数据，防止数据竞争（Data Race），但也引入了诸如死锁（Deadlock）、活锁（Livelock）、优先级反转（Priority Inversion）以及上下文切换开销等问题。无锁编程尝试在不使用锁的情况下，实现线程安全的数据共享和同步。
核心概念：原子操作（Atomic Operations）
无锁编程的核心基石是原子操作。原子操作是指在执行过程中不会被线程调度器中断的操作。这意味着一个原子操作要么完全执行成功，要么完全不执行，不存在中间状态。C++11 标准库提供了 <atomic> 头文件，支持多种原子类型和原子操作，例如：
⚝ 原子整型（Atomic Integers）: std::atomic<int>，std::atomic<long long> 等。
⚝ 原子布尔型（Atomic Booleans）: std::atomic<bool>。
⚝ 原子指针（Atomic Pointers）: std::atomic<T*>。
常见的原子操作包括：
⚝ 加载（Load）: 原子地读取一个值。
⚝ 存储（Store）: 原子地写入一个值。
⚝ 交换（Exchange）: 原子地用新值替换旧值，并返回旧值。
⚝ 比较并交换（Compare-and-Swap, CAS）: 原子地比较当前值与预期值，如果相等，则用新值替换当前值。CAS 是构建更复杂无锁算法的基础。
⚝ Fetch-and-Add: 原子地将指定值加到当前值，并返回原始值。
无锁编程的优势与挑战
优势：
① 避免锁的开销: 无锁编程避免了锁的获取和释放操作，减少了上下文切换的开销，尤其在高并发场景下，性能提升可能非常显著。
② 降低死锁和活锁风险: 由于不使用锁，因此从根本上消除了死锁和活锁的可能性。
③ 更高的系统吞吐量: 在某些特定场景下，无锁算法可以实现更高的吞吐量和更低的延迟。
挑战：
① 复杂性: 无锁算法的设计和实现通常比基于锁的算法更复杂，需要深入理解内存模型、原子操作以及并发控制原理。
② 调试难度: 无锁程序的调试更加困难，因为数据竞争可能以微妙的方式出现，且难以复现。
③ ABA 问题: 在使用 CAS 操作时，可能会遇到 ABA 问题。例如，一个值从 A 变为 B，又变回 A。CAS 操作可能会误认为值没有发生变化，从而导致错误。
④ 饥饿问题: 虽然无锁编程避免了死锁和活锁，但仍然可能存在某些线程一直无法成功执行操作的饥饿问题。
无锁数据结构示例：无锁栈（Lock-Free Stack）
下面是一个简单的无锁栈的示例代码，使用了原子操作 compare_exchange_weak 来实现入栈（push）和出栈（pop）操作。
1
#include <atomic>
2
#include <memory>
3
4
template <typename T>
5
class LockFreeStack {
6
private:
7
struct Node {
8
T data;
9
Node* next;
10
Node(const T& data) : data(data), next(nullptr) {}
11
};
12
13
std::atomic<Node*> head;
14
15
public:
16
LockFreeStack() : head(nullptr) {}
17
18
void push(const T& data) {
19
Node* newNode = new Node(data);
20
Node* oldHead = head.load(std::memory_order_relaxed); // relaxed ordering for initial load
21
do {
22
newNode->next = oldHead;
23
} while (!head.compare_exchange_weak(oldHead, newNode, std::memory_order_release, std::memory_order_relaxed)); // release ordering on success
24
}
25
26
std::shared_ptr<T> pop() {
27
Node* oldHead = head.load(std::memory_order_acquire); // acquire ordering for initial load
28
Node* nextNode;
29
do {
30
if (oldHead == nullptr) {
31
return nullptr; // Stack is empty
32
}
33
nextNode = oldHead->next;
34
} while (!head.compare_exchange_weak(oldHead, nextNode, std::memory_order_release, std::memory_order_relaxed)); // release ordering on success
35
36
std::shared_ptr<T> dataPtr = std::make_shared<T>(oldHead->data);
37
delete oldHead; // Important: free the node after successful pop
38
return dataPtr;
39
}
40
};
代码解释：
⚝ head: 使用 std::atomic<Node*> 原子指针来指向栈顶节点。
⚝ push():
▮▮▮▮⚝ 创建一个新节点 newNode。
▮▮▮▮⚝ 循环尝试使用 compare_exchange_weak 原子操作更新 head 指针。
▮▮▮▮⚝ compare_exchange_weak 的作用是：如果当前 head 的值等于 oldHead，则将 head 更新为 newNode，并返回 true；否则，将 oldHead 更新为 head 的当前值，并返回 false。循环会一直进行，直到 CAS 操作成功。
▮▮▮▮⚝ 内存顺序（Memory Ordering）：std::memory_order_release 保证在成功 push 操作之前的所有写操作对其他线程可见。std::memory_order_relaxed 用于非关键的加载操作，以提高性能。
⚝ pop():
▮▮▮▮⚝ 循环尝试使用 compare_exchange_weak 原子操作更新 head 指针。
▮▮▮▮⚝ 如果栈为空 (oldHead == nullptr)，则返回 nullptr。
▮▮▮▮⚝ 否则，获取栈顶节点的 next 指针 nextNode。
▮▮▮▮⚝ 使用 compare_exchange_weak 将 head 更新为 nextNode，实现出栈操作。
▮▮▮▮⚝ 内存顺序：std::memory_order_acquire 保证在成功 pop 操作之后，可以观察到其他线程在 push 操作之前的所有写操作。std::memory_order_relaxed 用于非关键的加载操作。
▮▮▮▮⚝ 返回弹出的数据，并释放弹出的节点内存。
无锁编程与 Synchronized.h
Synchronized.h 提供的同步机制是基于锁的，与无锁编程是不同的范畴。Synchronized.h 旨在简化基于锁的并发编程，提供更安全、更易用的接口。然而，理解无锁编程的概念和原理，可以帮助开发者更全面地认识并发编程的不同方法，并在某些性能敏感的场景下，考虑是否可以采用无锁算法来优化程序。通常情况下，Synchronized.h 提供的锁机制已经能够满足大多数并发编程需求，并且在易用性和安全性方面具有优势。无锁编程则更适用于对性能有极致要求的特定场景，并且需要更专业的知识和技能。
9.2 Synchronized 的内部实现机制 (Internal Implementation Mechanism of Synchronized)
folly::Synchronized 并非凭空创造的同步原语，它的实现是建立在操作系统提供的底层同步机制之上的，并在此基础上进行了封装和增强，以提供更安全、更易用的接口。理解 Synchronized 的内部实现机制，有助于我们更好地理解其性能特性和适用场景，并能更有效地使用它。
核心组成：互斥锁（Mutex）与条件变量（Condition Variable）
Synchronized 的核心是互斥锁（Mutex）和条件变量（Condition Variable）。在 folly 库中，Synchronized 默认使用 std::mutex 作为底层的互斥锁实现，也可以选择使用 pthread_mutex_t 等其他互斥锁类型。ReadWriteMutex 则通常基于 pthread_rwlock_t 或类似的读写锁实现。条件变量通常使用 std::condition_variable 或 pthread_cond_t 实现。
RAII 与自动锁管理
Synchronized 最重要的设计理念之一是 RAII（Resource Acquisition Is Initialization，资源获取即初始化）。它通过构造函数获取锁，析构函数释放锁，确保锁的自动管理，避免了手动 lock() 和 unlock() 忘记配对而导致的死锁或资源泄漏问题。
当我们创建一个 Synchronized<T> 对象时，实际上是创建了一个包含以下元素的复合对象：
① 内部数据成员: 类型为 T 的共享数据。
② 互斥锁: 用于保护对共享数据 T 的访问。 默认情况下是 std::mutex。
Synchronized<T> 的基本工作流程：
- 构造函数: 当创建
Synchronized<T>对象时，内部的互斥锁被初始化，但此时锁并未被获取。 wlock()/rlock()方法: 当调用wlock()（写锁）或rlock()（读锁，仅ReadWriteMutex支持）方法时，会返回一个LockGuard对象（例如Synchronized<T>::WriteLock或Synchronized<T>::ReadLock）。LockGuard的构造函数中会尝试获取互斥锁。如果锁已经被其他线程持有，当前线程会被阻塞，直到锁变为可用。- 访问共享数据: 在
LockGuard对象的作用域内，线程可以安全地访问和修改Synchronized<T>对象内部的共享数据T。因为此时互斥锁已经被当前线程持有，其他线程无法同时访问。 - 析构函数: 当
LockGuard对象超出作用域被销毁时，其析构函数会被调用，析构函数中会自动释放之前获取的互斥锁。
代码示例：Synchronized<T> 的简化内部结构
为了更好地理解 Synchronized 的内部机制，我们可以用一个简化的 C++ 类来模拟其核心行为：
1
#include <mutex>
2
3
template <typename T>
4
class SimpleSynchronized {
5
private:
6
T data_;
7
std::mutex mutex_;
8
9
public:
10
SimpleSynchronized(const T& initial_data) : data_(initial_data) {}
11
12
class LockGuard { // 简化版的 LockGuard
13
private:
14
std::mutex& mutex_;
15
public:
16
LockGuard(std::mutex& m) : mutex_(m) {
17
mutex_.lock(); // 构造时获取锁
18
}
19
~LockGuard() {
20
mutex_.unlock(); // 析构时释放锁
21
}
22
};
23
24
LockGuard getLock() { // 返回 LockGuard 对象
25
return LockGuard(mutex_);
26
}
27
28
T& getData() { // 获取共享数据的引用，必须在持有锁的情况下调用
29
return data_;
30
}
31
};
代码解释：
⚝ SimpleSynchronized<T>: 模拟 Synchronized<T>，包含共享数据 data_ 和互斥锁 mutex_。
⚝ LockGuard: 简化版的锁保护类，构造函数获取锁，析构函数释放锁。
⚝ getLock(): 返回 LockGuard 对象，用于获取锁。
⚝ getData(): 返回共享数据 data_ 的引用。注意: getData() 方法本身并不获取锁，锁的获取和释放是由 LockGuard 对象负责的。使用者必须先通过 getLock() 获取 LockGuard，才能安全地访问 getData() 返回的数据。
ReadWriteMutex 的实现
ReadWriteMutex 的实现比普通的互斥锁更复杂，因为它需要区分读锁和写锁。ReadWriteMutex 通常基于操作系统提供的读写锁原语（如 pthread_rwlock_t）实现。
⚝ 读锁（Shared Lock）: 允许多个线程同时持有读锁，用于读取共享数据。
⚝ 写锁（Exclusive Lock）: 只允许一个线程持有写锁，用于修改共享数据。当有线程持有写锁时，其他线程（包括读线程和写线程）都必须等待。
ReadWriteMutex 的实现需要维护读锁和写锁的状态，并根据请求的锁类型进行相应的操作。例如，当请求读锁时，如果当前没有写锁被持有，则允许获取读锁；当请求写锁时，必须等待所有读锁和写锁都被释放后才能获取写锁。
条件变量的集成
Synchronized 也集成了条件变量，用于实现线程间的等待和通知机制。条件变量通常与互斥锁一起使用。当线程需要等待某个条件满足时，它可以先释放互斥锁，然后等待条件变量。当条件满足时，其他线程可以通过条件变量通知等待线程，等待线程被唤醒后会重新尝试获取互斥锁，并检查条件是否真的满足。
Synchronized 提供的 wait(), notify_one(), notify_all() 等方法，实际上是对底层条件变量操作的封装，使得在 Synchronized 上使用条件变量更加方便和安全。
总结
Synchronized 的内部实现机制主要围绕互斥锁、读写锁和条件变量展开。它利用 RAII 机制实现了锁的自动管理，简化了并发编程的复杂性，并提供了类型安全的接口。理解其内部实现，有助于我们更好地选择合适的同步工具，并编写高效、可靠的并发程序。
9.3 C++ 并发编程的未来趋势 (Future Trends in C++ Concurrent Programming)
C++ 作为一门系统级编程语言，一直以来都在并发编程领域扮演着重要的角色。随着硬件架构的不断发展，特别是多核处理器和异构计算的普及，以及应用场景对高性能、低延迟和高吞吐量的不断追求，C++ 并发编程也在持续演进和发展。展望未来，C++ 并发编程将呈现出以下几个重要的趋势：
① 标准库的持续增强与现代化
C++ 标准委员会一直在积极推动并发编程特性的标准化和完善。从 C++11 引入线程库、原子操作、互斥锁、条件变量等基础并发工具，到 C++17 引入并行算法（Parallel Algorithms），C++20 引入协程（Coroutines）、std::latch、std::barrier、std::semaphore 等更高级的同步原语，C++ 标准库的并发支持能力不断增强。
未来趋势：
⚝ 执行器（Executors）: C++ 标准委员会正在积极推进执行器（Executors）的标准化。执行器旨在提供一种统一的、可扩展的、高效的异步任务执行框架，将任务的提交和执行策略解耦，允许开发者更灵活地管理和调度并发任务。执行器有望成为未来 C++ 并发编程的核心组件之一。
⚝ 网络和 IO 异步化: 随着网络应用和 IO 密集型应用的普及，异步 IO 变得越来越重要。C++ 标准库可能会进一步增强对异步 IO 的支持，例如，标准化异步网络库，提供更高效、更易用的异步 IO 接口。
⚝ 反射与元编程在并发中的应用: 反射（Reflection）和元编程（Metaprogramming）技术在 C++ 中越来越受到重视。未来，可能会看到更多利用反射和元编程技术来简化并发编程、提高代码可维护性和可扩展性的尝试。例如，自动生成并发代码、静态检查并发错误等。
② 异构计算与 GPU 并发
GPU（图形处理器）在并行计算领域展现出强大的计算能力。随着 GPU 计算的普及，C++ 并发编程也开始关注如何更好地利用 GPU 进行并行计算。
未来趋势：
⚝ GPU 计算库的成熟与易用: 已经涌现出许多 C++ GPU 计算库，例如 CUDA、OpenCL、SYCL 等。未来，这些库将更加成熟、易用，提供更高级的抽象和更丰富的功能，降低 GPU 并发编程的门槛。
⚝ 标准化的异构计算支持: C++ 标准委员会也在考虑如何更好地支持异构计算。例如，SYCL 已经被提交给 ISO C++ 标准委员会作为可能的标准化方案。未来，C++ 标准可能会直接支持异构计算，提供统一的编程模型，使得开发者可以更方便地在 CPU 和 GPU 等不同类型的处理器上进行并发编程。
⚝ 数据并行与任务并行结合: GPU 计算通常擅长数据并行（Data Parallelism），而 CPU 更适合任务并行（Task Parallelism）。未来，C++ 并发编程可能会更加强调数据并行和任务并行的结合，充分发挥 CPU 和 GPU 的优势，实现更高效的混合并行计算。
③ 响应式编程与函数式并发
响应式编程（Reactive Programming）和函数式编程（Functional Programming）范式在并发编程领域越来越受到关注。这些范式强调数据流、事件驱动和不可变性，有助于简化异步编程和并发程序的设计和开发。
未来趋势：
⚝ 响应式编程库的普及: 已经存在一些 C++ 响应式编程库，例如 RxCpp、ReactorCpp 等。未来，响应式编程库可能会更加普及，并被广泛应用于构建事件驱动、异步非阻塞的应用。
⚝ 函数式并发编程模型的应用: 函数式编程的不可变性、纯函数等特性，天然地适合并发编程。未来，可能会看到更多 C++ 并发编程实践借鉴函数式编程的思想，例如，使用不可变数据结构、避免共享状态、使用消息传递等方式来构建并发程序。
⚝ 协程与异步编程的融合: C++20 引入的协程为异步编程提供了更强大的工具。未来，协程可能会与响应式编程、函数式编程等范式进一步融合，形成更简洁、更高效的异步并发编程模型。
④ 形式化验证与并发安全
并发程序的正确性验证一直是一个挑战。传统的测试方法难以覆盖所有可能的并发执行路径，容易出现难以复现的并发错误。形式化验证（Formal Verification）技术可以对并发程序的正确性进行数学证明，提高并发程序的可靠性。
未来趋势：
⚝ 形式化验证工具的成熟与应用: 形式化验证工具在软件工程领域越来越受到重视。未来，可能会看到更多针对 C++ 并发程序的形式化验证工具出现，并被应用于关键系统的并发安全验证。
⚝ 静态分析与并发错误检测: 静态分析工具可以在编译时或编译后对代码进行分析，检测潜在的并发错误，例如数据竞争、死锁等。未来，静态分析工具将更加智能、精确，能够更有效地帮助开发者发现和修复并发错误。
⚝ 类型系统与并发安全: 类型系统可以在编译时对程序进行类型检查，防止类型错误。未来，可能会看到类型系统在并发安全方面发挥更大的作用，例如，通过类型系统来强制执行某些并发编程规则，防止数据竞争等错误。
⑤ 性能优化与硬件感知
随着硬件架构的不断发展，并发程序的性能优化也变得越来越重要。未来的 C++ 并发编程将更加关注性能优化和硬件感知。
未来趋势：
⚝ 硬件感知的并发编程: 不同的硬件架构具有不同的特性，例如，内存访问模式、缓存一致性协议、NUMA 架构等。未来的 C++ 并发编程将更加强调硬件感知，根据不同的硬件架构进行性能优化，充分发挥硬件的性能潜力。
⚝ 低延迟并发: 在某些对延迟敏感的应用场景下，例如金融交易、实时系统等，低延迟并发至关重要。未来，C++ 并发编程将更加关注低延迟并发技术，例如，减少锁竞争、优化上下文切换、使用无锁算法等。
⚝ 能源效率与绿色计算: 随着能源消耗问题日益突出，绿色计算成为一个重要的发展方向。未来的 C++ 并发编程将更加关注能源效率，例如，通过合理的并发策略、降低 CPU 功耗、优化资源利用率等方式，实现更节能的并发程序。
总结
C++ 并发编程的未来发展前景广阔，充满了机遇和挑战。标准库的持续增强、异构计算的兴起、响应式编程的流行、形式化验证的应用以及性能优化的需求，都将推动 C++ 并发编程不断向前发展。作为 C++ 开发者，我们需要密切关注这些趋势，不断学习和掌握新的并发编程技术，才能更好地应对未来的并发编程挑战。folly::Synchronized 作为一种成熟、易用的并发同步工具，在未来的 C++ 并发编程中仍然会发挥重要的作用，并随着 C++ 并发编程的整体发展而不断演进和完善。
END_OF_CHAPTER