学懂C++（三十四）：深入详解 C++ 高级多线程编程技术中的并发设计模式

引言

        在现代软件开发中，多线程编程已成为提升性能和响应能力的重要手段。设计模式为解决并发问题提供了有效的解决方案。本文将探讨常见的并发设计模式，包括生产者-消费者模式、读者-写者模式、单例模式、帧-工作者模式以及Future-Task模式，并为每个示例提供详细的注释和解析，以帮助读者更好地理解其实现原理。

1. 生产者-消费者模式

1.1 概念

        生产者-消费者模式涉及两个角色：生产者和消费者。生产者负责生成数据并将其放入缓冲区，而消费者则从缓冲区中取出数据进行处理。此模式的关键在于协调生产者和消费者之间的工作，以避免竞态条件和资源浪费。

1.2 示例及解析

以下是一个简单的生产者-消费者模式的实现：

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <queue>
#include <chrono>// 定义一个线程安全的缓冲区
std::queue<int> buffer; // 用于存放生产的数据
const unsigned int maxBufferSize = 5; // 定义缓冲区的最大大小
std::mutex mtx; // 用于保护缓冲区的互斥锁
std::condition_variable cv; // 用于条件变量通知// 生产者线程函数
void producer(int id) {for (int i = 0; i < 10; ++i) {std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 模拟生产过程std::unique_lock<std::mutex> lock(mtx); // 锁定缓冲区// 等待缓冲区有空间cv.wait(lock, [] { return buffer.size() < maxBufferSize; });buffer.push(i); // 生产数据std::cout << "Producer " << id << " produced: " << i << std::endl;cv.notify_all(); // 通知消费者有新数据可用}
}// 消费者线程函数
void consumer(int id) {for (int i = 0; i < 10; ++i) {std::this_thread::sleep_for(std::chrono::milliseconds(150)); // 模拟消费过程std::unique_lock<std::mutex> lock(mtx); // 锁定缓冲区// 等待缓冲区有数据cv.wait(lock, [] { return !buffer.empty(); });int value = buffer.front(); // 取出数据buffer.pop(); // 移除数据std::cout << "Consumer " << id << " consumed: " << value << std::endl;cv.notify_all(); // 通知生产者有空间可以生产}
}int main() {std::thread p1(producer, 1); // 创建生产者线程std::thread c1(consumer, 1); // 创建消费者线程p1.join(); // 等待生产者线程结束c1.join(); // 等待消费者线程结束return 0;
}

1.3 运行结果分析

在这个示例中，生产者和消费者线程通过互斥锁和条件变量进行同步，确保了对共享缓冲区的安全访问。生产者在缓冲区满时等待，而消费者在缓冲区空时等待。

2. 读者-写者模式

2.1 概念

读者-写者模式允许多个读者并行访问资源，但在写者访问资源时，所有读者和其他写者必须被阻塞。这种模式适用于读操作远远多于写操作的场景。

2.2 示例及解析

以下是一个简单的读者-写者模式的实现：

#include <iostream>
#include <thread>
#include <mutex>
#include <shared_mutex>
#include <chrono>std::shared_mutex rwMutex; // 读写锁
int sharedData = 0; // 共享数据// 读者线程函数
void reader(int id) {for (int i = 0; i < 5; ++i) {std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 模拟读操作rwMutex.lock_shared(); // 获取共享锁std::cout << "Reader " << id << " read: " << sharedData << std::endl; // 输出共享数据rwMutex.unlock_shared(); // 释放共享锁}
}// 写者线程函数
void writer(int id) {for (int i = 0; i < 5; ++i) {std::this_thread::sleep_for(std::chrono::milliseconds(200)); // 模拟写操作rwMutex.lock(); // 获取独占锁sharedData++; // 修改共享数据std::cout << "Writer " << id << " wrote: " << sharedData << std::endl; // 输出更新后的数据rwMutex.unlock(); // 释放独占锁}
}int main() {std::thread r1(reader, 1); // 创建读者线程std::thread r2(reader, 2); // 创建另一个读者线程std::thread w1(writer, 1); // 创建写者线程r1.join(); // 等待读者线程结束r2.join(); // 等待读者线程结束w1.join(); // 等待写者线程结束return 0;
}

2.3 运行结果分析

在这个示例中，多个读者可以同时读取数据，而在写者写入数据时，读者会被阻塞，提高了性能。

3. 单例模式

3.1 概念

单例模式确保一个类仅有一个实例，并提供全局访问点。在线程安全的上下文中，特别需要确保在多线程环境下创建实例的安全性。

3.2 示例及解析

以下是一个线程安全的单例模式实现示例：

#include <iostream>
#include <mutex>// 单例类定义
class Singleton {
public:// 获取单例实例static Singleton& getInstance() {std::call_once(initFlag, []() { // 确保单例只被初始化一次instance.reset(new Singleton());});return *instance; // 返回单例实例}void displayMessage() {std::cout << "Singleton Instance Address: " << this << std::endl; // 输出实例地址}private:Singleton() = default; // 私有构造函数static std::unique_ptr<Singleton> instance; // 存储单例实例的智能指针static std::once_flag initFlag; // 一次性标志
};// 静态成员初始化
std::unique_ptr<Singleton> Singleton::instance;
std::once_flag Singleton::initFlag;int main() {std::thread t1([]() { Singleton::getInstance().displayMessage(); });std::thread t2([]() { Singleton::getInstance().displayMessage(); });t1.join(); // 等待线程t1结束t2.join(); // 等待线程t2结束return 0;
}

3.3 运行结果分析

运行结果显示无论创建多少线程，单例实例只会创建一个，保证了线程安全。

4. 帧-工作者模式

4.1 概念

帧-工作者模式是一种常见的并发设计模式，适用于需要将大量任务分配给多个工作线程处理的场景。通过将任务分成较小的块，将这些块分配给多个工作线程，可以实现高效的并发处理。

4.2 示例及解析

以下是帧-工作者模式的简单实现：

#include <iostream>
#include <vector>
#include <thread>
#include <mutex>std::mutex mtx; // 用于保护输出的互斥锁// 工作线程函数
void worker(int id, int start, int end) {for (int i = start; i < end; ++i) {std::this_thread::sleep_for(std::chrono::milliseconds(50)); // 模拟工作std::lock_guard<std::mutex> lock(mtx); // 锁定互斥锁std::cout << "Worker " << id << " processing: " << i << std::endl; // 输出处理信息}
}int main() {const int totalWork = 20; // 总工作量const int numWorkers = 4; // 工作线程数量std::vector<std::thread> workers; // 存储线程的向量int workPerThread = totalWork / numWorkers; // 每个线程处理的工作量for (int i = 0; i < numWorkers; ++i) {// 创建工作线程，分配不同的任务块workers.emplace_back(worker, i + 1, i * workPerThread, (i + 1) * workPerThread);}for (auto& worker : workers) {worker.join(); // 等待所有工作线程结束}return 0;
}

4.3 运行结果分析

在该示例中，多个工作线程可以并行处理不同的任务块，提升了效率。

5. Future-Task 模式

5.1 概念

Future-Task模式是一种用于异步编程的设计模式，允许任务在后台异步执行，并在需要时获取结果。这种模式通常与线程池结合使用，以提高资源利用率。

5.2 示例及解析

以下是 Future-Task 模式的实现示例：

#include <iostream>
#include <future>
#include <thread>
#include <chrono>// 异步任务
int asyncTask(int id) {std::this_thread::sleep_for(std::chrono::milliseconds(100 * id)); // 模拟耗时任务return id * 2; // 返回计算结果
}int main() {// 使用 std::async 启动异步任务std::future<int> fut1 = std::async(std::launch::async, asyncTask, 1);std::future<int> fut2 = std::async(std::launch::async, asyncTask, 2);// 获取结果并输出std::cout << "Result from task 1: " << fut1.get() << std::endl; // 阻塞等待 task 1 完成std::cout << "Result from task 2: " << fut2.get() << std::endl; // 阻塞等待 task 2 完成return 0;
}

5.3 运行结果分析

在这个示例中，两个任务在后台异步执行，主线程可以在等待结果的同时继续处理其他逻辑。

6. 核心点总结与技术精髓

6.1 设计模式的核心点

• 生产者-消费者模式：利用互斥锁和条件变量保证缓冲区的安全访问，避免竞争条件。
• 读者-写者模式：允许多个读者并发访问，确保写者访问时的独占性，适用读多写少的场景。
• 单例模式：确保全局只有一个实例，并提供线程安全的访问方式，适合需要共享资源的情况。
• 帧-工作者模式：将工作分配给多个线程，提升处理效率，适合大规模并行处理。
• Future-Task模式：支持异步执行和结果获取，通过将任务放入后台执行来优化资源利用率。

7. 结语

        掌握并发设计模式是实现高效、多线程程序的关键。通过合理的设计和实现，我们能够有效地解决并发问题，提高程序的性能和可靠性。希望本文能够为您在 C++ 的多线程编程中提供有价值的参考和指导。

上一篇：学懂C++（三十三）：深入详解 C++ 高级多线程编程技术中的并发数据结构

下一篇：学懂C++（三十五）：深入详解C++ 多线程编程性能优化