并发设计模式
本节是并发卷的收官之章。我们将前面学到的所有工具——jthread、mutex、atomic、future、协程——组合成可复用的设计模式。这些模式经过工业界验证,可以直接应用到生产代码中。
模式一:线程池(Thread Pool)
线程池是最常用的并发基础设施。预先创建一组工作线程,通过任务队列分发工作,避免反复创建/销毁线程的开销。
#include <thread>
#include <queue>
#include <functional>
#include <future>
#include <vector>
#include <mutex>
#include <condition_variable>
#include <stop_token>
class ThreadPool {
public:
explicit ThreadPool(size_t num_threads = std::thread::hardware_concurrency()) {
for (size_t i = 0; i < num_threads; ++i) {
workers_.emplace_back([this](std::stop_token stoken) {
worker_loop(stoken);
});
}
}
~ThreadPool() {
// jthread 析构时自动请求停止并 join
}
// 提交任务,返回 future 获取结果
template<typename F, typename... Args>
auto submit(F&& f, Args&&... args)
-> std::future<std::invoke_result_t<F, Args...>>
{
using R = std::invoke_result_t<F, Args...>;
auto task = std::make_shared<std::packaged_task<R()>>(
std::bind(std::forward<F>(f), std::forward<Args>(args)...)
);
auto future = task->get_future();
{
std::lock_guard lock(mutex_);
tasks_.push([task]() { (*task)(); });
}
cv_.notify_one();
return future;
}
// 等待所有已提交任务完成
void wait_idle() {
std::unique_lock lock(mutex_);
idle_cv_.wait(lock, [this] {
return tasks_.empty() && active_tasks_ == 0;
});
}
private:
void worker_loop(std::stop_token stoken) {
while (!stoken.stop_requested()) {
std::function<void()> task;
{
std::unique_lock lock(mutex_);
cv_.wait(lock, [&] {
return stoken.stop_requested() || !tasks_.empty();
});
if (stoken.stop_requested() && tasks_.empty()) return;
task = std::move(tasks_.front());
tasks_.pop();
++active_tasks_;
}
task();
{
std::lock_guard lock(mutex_);
--active_tasks_;
}
idle_cv_.notify_all();
}
}
std::vector<std::jthread> workers_;
std::queue<std::function<void()>> tasks_;
std::mutex mutex_;
std::condition_variable cv_;
std::condition_variable idle_cv_;
int active_tasks_ = 0;
};
// 使用示例
int main() {
ThreadPool pool(4);
std::vector<std::future<int>> results;
for (int i = 0; i < 20; ++i) {
results.push_back(pool.submit([i] {
std::this_thread::sleep_for(std::chrono::milliseconds(50));
return i * i;
}));
}
for (auto& fut : results) {
std::cout << fut.get() << " ";
}
}
jthread + stop_token 的优势
使用 std::jthread 而非 std::thread,线程池析构时自动请求停止并等待线程退出——无需手动设置"shutdown"标志和调用 join。stop_token 与 condition_variable 配合实现优雅关闭。
模式二:生产者-消费者(有界队列)
有界队列(bounded queue)在生产者和消费者之间提供背压(backpressure)——当队列满时生产者阻塞,防止内存无限增长。
#include <queue>
#include <mutex>
#include <condition_variable>
#include <optional>
template<typename T>
class BoundedQueue {
public:
explicit BoundedQueue(size_t capacity) : capacity_(capacity) {}
// 生产者调用:放入元素(队列满时阻塞)
void push(T item) {
std::unique_lock lock(mutex_);
not_full_.wait(lock, [this] {
return queue_.size() < capacity_ || closed_;
});
if (closed_) throw std::runtime_error("queue closed");
queue_.push(std::move(item));
not_empty_.notify_one();
}
// 消费者调用:取出元素(队列空时阻塞)
// 返回 nullopt 表示队列已关闭且为空
std::optional<T> pop() {
std::unique_lock lock(mutex_);
not_empty_.wait(lock, [this] {
return !queue_.empty() || closed_;
});
if (queue_.empty()) return std::nullopt; // 关闭且空
T item = std::move(queue_.front());
queue_.pop();
not_full_.notify_one();
return item;
}
// 关闭队列:不再接受新元素,消费者可以 drain 剩余
void close() {
{
std::lock_guard lock(mutex_);
closed_ = true;
}
not_full_.notify_all();
not_empty_.notify_all();
}
private:
std::queue<T> queue_;
size_t capacity_;
bool closed_ = false;
std::mutex mutex_;
std::condition_variable not_full_;
std::condition_variable not_empty_;
};
// 使用示例
void producer_consumer_example() {
BoundedQueue<int> queue(10); // 最多缓冲10个元素
// 生产者
std::jthread producer([&](std::stop_token st) {
for (int i = 0; i < 100 && !st.stop_requested(); ++i) {
queue.push(i);
}
queue.close();
});
// 多个消费者
std::vector<std::jthread> consumers;
for (int c = 0; c < 3; ++c) {
consumers.emplace_back([&, c] {
while (auto item = queue.pop()) {
std::cout << "Consumer " << c
<< " got: " << *item << "\n";
}
});
}
}
模式三:Active Object(活动对象)
Active Object 将方法调用转化为消息,放入私有队列,由专属工作线程串行执行。这样对象的所有操作都在同一线程中运行——无需加锁!
#include <thread>
#include <queue>
#include <functional>
#include <mutex>
#include <condition_variable>
#include <future>
class ActiveObject {
public:
ActiveObject() : worker_([this](std::stop_token st) { run(st); }) {}
~ActiveObject() {
// jthread 析构时请求停止并 join
}
// 异步调用:将操作入队,返回 future
template<typename F>
auto async_call(F&& f) -> std::future<std::invoke_result_t<F>> {
using R = std::invoke_result_t<F>;
auto task = std::make_shared<std::packaged_task<R()>>(
std::forward<F>(f));
auto future = task->get_future();
{
std::lock_guard lock(mutex_);
queue_.push([task] { (*task)(); });
}
cv_.notify_one();
return future;
}
// 同步调用:入队并等待完成
template<typename F>
auto sync_call(F&& f) -> std::invoke_result_t<F> {
return async_call(std::forward<F>(f)).get();
}
private:
void run(std::stop_token stoken) {
while (!stoken.stop_requested()) {
std::function<void()> task;
{
std::unique_lock lock(mutex_);
cv_.wait(lock, [&] {
return stoken.stop_requested() || !queue_.empty();
});
if (stoken.stop_requested() && queue_.empty()) return;
task = std::move(queue_.front());
queue_.pop();
}
task();
}
}
std::jthread worker_;
std::queue<std::function<void()>> queue_;
std::mutex mutex_;
std::condition_variable cv_;
};
// 使用:线程安全的日志记录器
class Logger : private ActiveObject {
public:
void log(std::string msg) {
// 所有写操作在同一线程串行执行——无需锁保护 file_
async_call([this, msg = std::move(msg)] {
file_ << "[" << timestamp() << "] " << msg << "\n";
file_.flush();
});
}
std::string get_last_entry() {
return sync_call([this] { return last_entry_; });
}
private:
std::ofstream file_{"app.log"};
std::string last_entry_;
std::string timestamp() { /* ... */ return "2026-01-01"; }
};
Active Object 的适用场景
当一个对象需要被多个线程访问,但内部状态修改比较复杂(涉及多个成员变量的一致性)时,Active Object 比细粒度锁更容易写对。代价是每次调用有队列入队的开销和一次线程切换的延迟。
模式四:无锁 SPSC 环形缓冲区
单生产者-单消费者(SPSC)场景下,可以用原子变量实现完全无锁的环形缓冲区——零互斥开销,极低延迟。
#include <atomic>
#include <array>
#include <optional>
#include <cstddef>
template<typename T, size_t Capacity>
class SPSCRingBuffer {
static_assert((Capacity & (Capacity - 1)) == 0,
"Capacity must be a power of 2");
public:
// 生产者线程调用
bool try_push(const T& item) {
size_t head = head_.load(std::memory_order_relaxed);
size_t next = (head + 1) & mask_;
// 检查是否满
if (next == tail_.load(std::memory_order_acquire)) {
return false; // 队列满
}
buffer_[head] = item;
head_.store(next, std::memory_order_release);
return true;
}
// 消费者线程调用
std::optional<T> try_pop() {
size_t tail = tail_.load(std::memory_order_relaxed);
// 检查是否空
if (tail == head_.load(std::memory_order_acquire)) {
return std::nullopt; // 队列空
}
T item = buffer_[tail];
tail_.store((tail + 1) & mask_, std::memory_order_release);
return item;
}
bool empty() const {
return head_.load(std::memory_order_acquire)
== tail_.load(std::memory_order_acquire);
}
private:
static constexpr size_t mask_ = Capacity - 1;
std::array<T, Capacity> buffer_;
alignas(64) std::atomic<size_t> head_{0}; // cache line 对齐
alignas(64) std::atomic<size_t> tail_{0}; // 避免 false sharing
};
// 使用示例:低延迟消息传递
void spsc_example() {
SPSCRingBuffer<int, 1024> ring;
std::jthread producer([&](std::stop_token st) {
for (int i = 0; !st.stop_requested(); ++i) {
while (!ring.try_push(i)) {
// 自旋等待(或 yield)
std::this_thread::yield();
}
}
});
std::jthread consumer([&](std::stop_token st) {
while (!st.stop_requested()) {
if (auto val = ring.try_pop()) {
process(*val);
} else {
std::this_thread::yield();
}
}
});
std::this_thread::sleep_for(std::chrono::seconds(1));
// jthread 析构时自动停止
}
无锁编程的注意事项
SPSC 环形缓冲是无锁编程中最简单的情况。MPMC(多生产者多消费者)的无锁实现复杂度急剧上升(需要处理 ABA 问题、需要 CAS 循环)。在你确实需要极致性能之前,优先使用 mutex 方案——它更简单、更不易出错。
模式五:并行管道(Pipeline)
将处理流程分为多个阶段,每个阶段在独立线程中运行,通过队列连接。数据像流水线一样依次经过各阶段。
#include <functional>
#include <thread>
#include <iostream>
// 使用前面定义的 BoundedQueue
// 管道阶段:从输入队列读取,处理后写入输出队列
template<typename In, typename Out>
std::jthread make_stage(
BoundedQueue<In>& input,
BoundedQueue<Out>& output,
std::function<Out(In)> transform)
{
return std::jthread([&input, &output, transform] {
while (auto item = input.pop()) {
output.push(transform(std::move(*item)));
}
output.close(); // 输入结束时关闭输出
});
}
// 示例:图像处理管道
struct RawImage { std::vector<uint8_t> data; std::string name; };
struct DecodedImage { int width, height; std::vector<float> pixels; };
struct ProcessedImage { std::vector<float> pixels; bool enhanced; };
void image_pipeline() {
BoundedQueue<RawImage> raw_queue(8);
BoundedQueue<DecodedImage> decoded_queue(4);
BoundedQueue<ProcessedImage> processed_queue(4);
// 阶段1: 解码
auto decoder = make_stage<RawImage, DecodedImage>(
raw_queue, decoded_queue,
[](RawImage raw) {
// 解码逻辑...
return DecodedImage{1920, 1080, {}};
});
// 阶段2: 图像增强
auto enhancer = make_stage<DecodedImage, ProcessedImage>(
decoded_queue, processed_queue,
[](DecodedImage img) {
// 增强逻辑...
return ProcessedImage{std::move(img.pixels), true};
});
// 阶段3: 消费者(写入磁盘)
auto writer = std::jthread([&] {
while (auto img = processed_queue.pop()) {
// 写入文件...
std::cout << "写入处理后的图像\n";
}
});
// 生产者:读取文件送入管道
for (int i = 0; i < 100; ++i) {
raw_queue.push(RawImage{{}, "img_" + std::to_string(i)});
}
raw_queue.close();
}
如何选择正确的模式
| 场景 | 推荐模式 | 关键特征 |
|---|---|---|
| 大量独立短任务 | 线程池 | 任务无依赖,复用线程 |
| 数据流:一方生产、另一方消费 | 有界队列 | 背压控制,解耦速度差异 |
| 对象需被多线程调用、内部状态复杂 | Active Object | 串行化访问,无需内部加锁 |
| 超低延迟、单生产者单消费者 | 无锁 SPSC | 零系统调用,cache-friendly |
| 多阶段处理、可并行的流水线 | Pipeline | 阶段解耦,吞吐量叠加 |
| 简单的一次性异步计算 | std::async | 最简单,适合 prototype |
| I/O 密集型、大量并发连接 | 协程 + 事件循环 | 少量线程处理海量连接 |
经验法则
1) 先用 std::async 或线程池解决问题;2) 性能不满足时测量瓶颈;3) 根据瓶颈类型选择更专用的模式。过早引入无锁数据结构是并发编程中最常见的"过度工程"。
模式组合:线程池 + Pipeline + 有界队列
真实系统往往组合多种模式。下面展示一个日志处理系统的骨架:
// 真实系统的骨架:多源日志聚合器
class LogAggregator {
public:
LogAggregator()
: pool_(4) // 4 工作线程处理解析
, raw_queue_(1024)
, output_queue_(256)
, writer_([this](std::stop_token st) { write_loop(st); })
{}
// 多个生产者可以并发调用
void ingest(std::string raw_log) {
raw_queue_.push(std::move(raw_log));
}
void start_processing() {
processor_ = std::jthread([this](std::stop_token st) {
while (!st.stop_requested()) {
auto raw = raw_queue_.pop();
if (!raw) break;
// 将解析工作提交到线程池
pool_.submit([this, log = std::move(*raw)] {
auto parsed = parse(log);
output_queue_.push(std::move(parsed));
});
}
});
}
void shutdown() {
raw_queue_.close();
pool_.wait_idle();
output_queue_.close();
}
private:
struct ParsedLog { std::string level, message; };
ParsedLog parse(const std::string& raw) {
// 解析逻辑...
return {"INFO", raw};
}
void write_loop(std::stop_token st) {
while (!st.stop_requested()) {
if (auto log = output_queue_.pop()) {
// 写入数据库/文件/网络
std::cout << "[" << log->level << "] "
<< log->message << "\n";
} else {
break;
}
}
}
ThreadPool pool_;
BoundedQueue<std::string> raw_queue_;
BoundedQueue<ParsedLog> output_queue_;
std::jthread processor_;
std::jthread writer_;
};
本节小结
- 线程池:jthread + stop_token + 任务队列,是通用并发任务调度的基础设施
- 有界队列:背压控制,防止快生产者压垮慢消费者,用 condition_variable 实现阻塞
- Active Object:将并发访问串行化为消息队列,对象内部无需加锁——简化推理
- 无锁 SPSC 环形缓冲:极致低延迟场景的利器,利用 acquire/release 语义保证正确性
- 并行管道:将处理分阶段,每阶段独立线程,通过队列传递数据——适合多步骤数据处理
- 选择模式的核心原则:先用简单方案,测量瓶颈,再按需升级复杂度