并发编程

C++11 引入的并发支持，包括线程、互斥、条件变量、原子操作等。

并发编程核心

• 线程：std::thread、std::jthread (C++20)
• 同步：std::mutex、std::lock_guard、std::unique_lock
• 条件变量：std::condition_variable
• 原子操作：std::atomic、内存序

学习内容

线程基础

---

std::thread、线程管理、线程参数传递

互斥与锁

---

mutex、lock_guard、unique_lock、shared_mutex

条件变量

---

condition_variable、生产者消费者模式

原子操作

---

std::atomic、内存序、无锁编程

异步操作

---

std::future、std::promise、std::async、std::packaged_task

并发模型

图：C++ 并发编程体系

基础示例

创建线程

#include <thread>
#include <iostream>

void hello() {
    std::cout << "Hello from thread!" << std::endl;
}

int main() {
    // 创建线程
    std::thread t(hello);

    // 等待线程完成
    t.join();

    return 0;
}

互斥锁

#include <thread>
#include <mutex>

std::mutex mtx;
int counter = 0;

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

int main() {
    std::thread t1(increment);
    std::thread t2(increment);

    t1.join();
    t2.join();

    std::cout << "Counter: " << counter << std::endl;
    return 0;
}

条件变量

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

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

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

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

性能建议

并发陷阱

1. 死锁：避免循环等待锁
2. 数据竞争：确保共享数据的同步访问
3. 过度同步：锁粒度太大会降低性能
4. 虚假唤醒：condition_variable::wait 要配合谓词

最佳实践

1. 使用 RAII 管理锁：lock_guard、unique_lock
2. 尽量减少锁的持有时间
3. 优先使用原子操作：简单场景下避免锁
4. 使用 jthread（C++20）：自动 join