C++并发编程基础与实践指南一、引言随着多核处理器的普及，并发编程成为提升程序性能的重要手段。C++11引入了丰富的并

一、引言

随着多核处理器的普及，并发编程成为提升程序性能的重要手段。C++11引入了丰富的并发支持库，提供线程管理、同步机制、原子操作等功能，帮助开发者安全高效地编写并发程序。

本文将系统介绍C++并发编程的基础知识、常用工具和实战技巧，帮助你构建高性能、多线程的现代C++应用。

二、线程管理

1. 创建和启动线程

使用std::thread创建线程：

cpp复制编辑#include <thread>
#include <iostream>

void worker() {
    std::cout << "工作线程执行\n";
}

int main() {
    std::thread t(worker);
    t.join();  // 等待线程完成
    return 0;
}

2. 线程分离（detach）

分离线程让其独立运行：

cpp复制编辑std::thread t(worker);
t.detach();

注意：分离后无法再join，程序结束时可能线程未完成。

三、线程同步

1. 互斥量 std::mutex

防止多线程同时访问共享资源：

cpp复制编辑#include <mutex>

std::mutex mtx;
int counter = 0;

void increment() {
    std::lock_guard<std::mutex> lock(mtx);
    ++counter;
}

2. 读写锁 std::shared_mutex（C++17）

允许多读单写，提升读多写少场景性能。

3. 条件变量 std::condition_variable

线程间通信与同步：

cpp复制编辑std::condition_variable cv;
std::mutex mtx;
bool ready = false;

void worker() {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, []{ return ready; });
    // 执行任务
}

void notifier() {
    {
        std::lock_guard<std::mutex> lock(mtx);
        ready = true;
    }
    cv.notify_one();
}

四、原子操作与内存模型

1. std::atomic

支持原子读写，避免竞态条件：

cpp复制编辑#include <atomic>

std::atomic<int> count{0};

void increment() {
    count.fetch_add(1, std::memory_order_relaxed);
}

2. 内存序模型

理解memory_order对性能和正确性的影响，常用memory_order_relaxed、memory_order_acquire和memory_order_release。

五、线程局部存储（TLS）

通过thread_local关键字为每个线程创建独立变量副本，避免共享冲突。

cpp复制编辑thread_local int tls_var = 0;

六、任务和未来（std::async和std::future）

异步任务执行与结果获取：

cpp复制编辑#include <future>

int compute() {
    return 42;
}

int main() {
    std::future<int> fut = std::async(compute);
    std::cout << "结果: " << fut.get() << std::endl;
}

七、线程池与高阶并发

C++标准库没有直接支持线程池，但可以通过第三方库（如Boost.Asio、ThreadPool）实现。线程池避免频繁创建销毁线程，提高性能。

八、实战示例：多线程安全队列

cpp复制编辑#include <queue>
#include <mutex>
#include <condition_variable>

template<typename T>
class ThreadSafeQueue {
    std::queue<T> queue_;
    std::mutex mutex_;
    std::condition_variable cv_;
public:
    void push(T value) {
        {
            std::lock_guard<std::mutex> lock(mutex_);
            queue_.push(std::move(value));
        }
        cv_.notify_one();
    }

    T pop() {
        std::unique_lock<std::mutex> lock(mutex_);
        cv_.wait(lock, [this]{ return !queue_.empty(); });
        T val = std::move(queue_.front());
        queue_.pop();
        return val;
    }
};