并发设计模式

本节是并发卷的收官之章。我们将前面学到的所有工具——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 语义保证正确性
  • 并行管道:将处理分阶段,每阶段独立线程,通过队列传递数据——适合多步骤数据处理
  • 选择模式的核心原则:先用简单方案,测量瓶颈,再按需升级复杂度