C++ Linux下的并发编程模型

C++ Linux 并发编程模型全景

一、模型总览与适用场景

• 多线程共享内存：使用 C++11 / std::mutex / std::condition_variable / std::atomic，或直接使用 POSIX threads（pthreads）。适合计算密集型、需要共享大量数据、细粒度同步的场景。pthreads 在 Linux 上广泛使用，C++11 线程库底层通常基于 pthread 实现。
• 异步任务与 Future/Promise：使用 std::async / std::future / std::promise 解耦任务提交与结果获取，适合“发起即忘”或需要后续取回结果的任务编排。
• 并行算法（C++17）：使用 策略并行化 STL 算法（如 std::for_each(std::execution::par, …)），适合数据并行、对容器批量操作的场景。
• 线程池与任务队列：预创建线程、复用执行单元，减少线程创建销毁开销，适合高吞吐、短任务为主的服务器/后台任务。
• 事件驱动 + I/O 多路复用：基于 epoll 的事件循环，配合非阻塞 I/O、回调/协程，适合高并发网络服务与大量 I/O 等待的场景。
• 信号与异步 I/O：使用 信号（signal/sigaction） 做简单异步通知，或使用 Linux AIO/io_uring 做真正的异步磁盘/网络 I/O（配合线程或事件循环）。
• 协程与 Sender/Receiver：基于 C++20 协程 或 Sender/Receiver 模型（如 libunifex）构建可组合、可取消、零开销抽象的异步流水线，适合复杂异步流程编排与高性能网络/存储。

二、关键模型要点与对比

三、实践建议与常见陷阱

• 优先选择高层抽象：能用 并行算法 就不用手写线程；能用 Future/Promise 就不用裸线程 join；I/O 密集优先 事件驱动/协程。
• 避免数据竞争：共享数据必须加锁（如 std::mutex），或使用 std::atomic 做无锁原子操作；优先使用 RAII 锁管理（如 std::lock_guard / std::unique_lock）。
• 条件变量的正确用法：总是配合 while(!ready) 循环检查谓词，避免虚假唤醒；用 notify_one/notify_all 合理唤醒。
• 防止死锁：固定加锁顺序、缩小临界区、避免在持有锁时调用未知回调；必要时使用 try_lock 或超时。
• 线程池与队列：设置合理的 并发度（≈ CPU 核数或 I/O 并发能力） 与 有界任务队列，并实现拒绝策略与背压。
• 编译与链接：启用 -std=c++11/-std=c++17/-std=c++20；使用 pthreads 时链接 -pthread；确保标准库与 ABI 一致。

四、最小示例

• 多线程 + 互斥锁 + 条件变量（任务协调）

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>

std::mutex mtx;
std::condition_variable cv;
bool ready = false;

void worker(int id) {
    std::unique_lock<std::mutex> lk(mtx);
    cv.wait(lk, []{ return ready; });
    std::cout << "Worker " << id << " running\n";
}

int main() {
    std::thread t1(worker, 1), t2(worker, 2);
    {
        std::lock_guard<std::mutex> lk(mtx);
        ready = true;
    }
    cv.notify_all();
    t1.join(); t2.join();
}

• 并行算法（C++17）

#include <iostream>
#include <vector>
#include <algorithm>
#include <execution>

int main() {
    std::vector<int> v = {1,2,3,4,5};
    std::for_each(std::execution::par, v.begin(), v.end(), [](int& n){ n *= 2; });
    for (int n : v) std::cout << n << ' ';
}

• Future/Promise（异步任务取结果）

#include <iostream>
#include <thread>
#include <future>

int work(int x) { return x * x; }

int main() {
    std::promise<int> p;
    std::future<int> f = p.get_future();
    std::thread t([p = std::move(p)]() mutable { p.set_value(work(6)); });
    std::cout << "Result: " << f.get() << '\n'; // 36
    t.join();
}

• 编译提示

g++ -O2 -std=c++17 -pthread your_file.cpp -o your_app