在 c++ 并发编程中，采用设计模式可以提高代码的可读性、可维护性和可扩展性，其中常见的模式包括：生产者-消费者模式：一个线程生成数据，其他线程消耗数据。读者-写者模式：多个读者可同时访问共享资源，但只能有一个写者访问。监视器模式：保护并发访问共享资源，强制执行同步和状态检查。线程池模式：预先创建线程组，避免频繁创建和销毁线程的开销。
C++ 并发编程中的常见设计模式
在并发编程中，采用设计模式可以显著提高代码的可读性、可维护性和可扩展性。下面列举了一些在 C++ 并发编程中常见的模式：
生产者-消费者模式
立即学习“C++免费学习笔记（深入）”；
在这种模式中，一个生产者线程生成数据，而一个或多个消费者线程消费这些数据。常见的实现方法是使用队列或共享内存。
例子：
class Producer {
public:
void produce(const T& data) {
std::lock_guard<std::mutex> lock(queue_mutex);
queue.push(data);
}
private:
std::queue<T> queue;
std::mutex queue_mutex;
};
class Consumer {
public:
void consume() {
std::unique_lock<std::mutex> lock(queue_mutex);
if (queue.empty()) {
condition_variable.wait(lock);
}
const T& data = queue.front();
queue.pop();
lock.unlock();
// ...
}
private:
std::shared_ptr<Producer> producer;
std::condition_variable condition_variable;
std::mutex queue_mutex;
};读者-写者模式
此模式允许多个读者同时访问共享资源，但只能有一个写者访问。重入锁或读写锁通常用于实现此模式。
例子：
class ReadWriteLock {
public:
void read_lock() {
while (write_locked) {
unique_lock<std::mutex> lock(read_mutex);
read_count++;
}
}
void read_unlock() {
std::lock_guard<std::mutex> lock(read_mutex);
read_count--;
}
void write_lock() {
std::lock_guard<std::mutex> lock(write_mutex);
while (read_count > 0) { /* 等待读完成 */}
write_locked = true;
}
void write_unlock() {
std::lock_guard<std::mutex> lock(write_mutex);
write_locked = false;
}
private:
bool write_locked = false;
int read_count = 0;
std::mutex read_mutex;
std::mutex write_mutex;
};监视器模式
监视器模式通过将数据访问限制在单个对象来保护并发访问共享资源。监视器对象封装了数据和操作，并强制执行同步和状态检查。
例子：
class Account {
public:
void deposit(int amount) {
std::lock_guard<std::mutex> lock(balance_mutex);
balance += amount;
}
int withdraw(int amount) {
std::lock_guard<std::mutex> lock(balance_mutex);
if (amount <= balance) {
balance -= amount;
return amount;
}
return 0;
}
int get_balance() {
std::lock_guard<std::mutex> lock(balance_mutex);
return balance;
}
private:
int balance = 0;
std::mutex balance_mutex;
};线程池模式
线程池模式提供了一个预先创建的线程组，由客户端线程使用。通过使用线程池，可以避免频繁创建和销毁线程的开销。
例子：
class ThreadPool {
public:
ThreadPool(int num_threads) {
for (int i = 0; i < num_threads; i++) {
threads.emplace_back(std::thread([this] {
while (true) {
std::function<void()> task;
{
std::unique_lock<std::mutex> lock(tasks_mutex);
if (tasks.empty()) {
condition_variable.wait(lock);
}
task = std::move(tasks.front());
tasks.pop();
}
task();
}
}));
}
}
void submit(std::function<void()> task) {
std::lock_guard<std::mutex> lock(tasks_mutex);
tasks.push(std::move(task));
condition_variable.notify_one();
}
private:
std::vector<std::jthread> threads;
std::queue<std::function<void()>> tasks;
std::mutex tasks_mutex;
std::condition_variable condition_variable;
}; 
