C++ 多线程编程

1. 核心头文件

要使用 C++ 多线程，首先需要包含以下头文件：

cpp

#include <thread>   // 线程管理（创建、休眠、获取ID等）
#include <mutex>    // 互斥锁（std::mutex, std::lock_guard, std::unique_lock）
#include <atomic>   // 原子操作（无锁编程）
#include <future>   // 异步操作（std::async, std::promise, std::future）
#include <condition_variable> // 条件变量（线程间同步）

2. 创建线程

创建线程最基本的方式是使用 std::thread 类，其构造函数接受一个可调用对象（函数、Lambda表达式、函数对象等）以及该对象所需的参数。

示例1：使用函数

cpp

#include <iostream>
#include <thread>

void helloFunction() {
    std::cout << "Hello from function! Thread ID: " << std::this_thread::get_id() << std::endl;
}

int main() {
    // 创建线程对象 t1，并立即执行 helloFunction
    std::thread t1(helloFunction);

    // 使用 Lambda 表达式创建线程 t2
    std::thread t2([](){
        std::cout << "Hello from lambda! Thread ID: " << std::this_thread::get_id() << std::endl;
    });

    // 等待两个线程执行完毕
    t1.join(); // main 线程阻塞，直到 t1 完成
    t2.join(); // main 线程阻塞，直到 t2 完成

    std::cout << "Main thread done." << std::endl;
    return 0;
}

重要提示：

• join(): 等待子线程结束，然后继续执行主线程。必须在你创建的 std::thread 对象被销毁前调用 join() 或 detach()，否则程序会调用 std::terminate 终止。

• detach(): 将子线程与主线程分离，使其成为守护线程（daemon thread），在后台独立运行。一旦分离，你将无法再与之交互。通常用于长时间运行的任务。

3. 数据共享与竞态条件

当多个线程读写同一块共享数据时，如果没有任何同步措施，程序的执行结果将变得不确定，这就是竞态条件。

示例：一个有问题的计数器

cpp

#include <thread>
#include <iostream>

int counter = 0;

void incrementCounter(int numIterations) {
    for (int i = 0; i < numIterations; ++i) {
        ++counter; // 这不是原子操作！
    }
}

int main() {
    const int numIterations = 1000000;
    std::thread t1(incrementCounter, numIterations);
    std::thread t2(incrementCounter, numIterations);

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

    // 结果几乎肯定不是 2000000
    std::cout << "Final counter value: " << counter << std::endl;
    return 0;
}

++counter 看起来是一条语句，但底层对应读取-修改-写入三条指令，线程可能会在这三条指令之间被中断，导致数据覆盖。

4. 使用互斥锁保护共享数据

互斥锁（Mutex） 是最常用的同步原语。它保证同一时间只有一个线程能进入被保护的代码段（临界区）。

a. std::mutex 和 std::lock_guard

std::lock_guard 是一个 RAII 类，在构造时自动加锁，在析构时自动解锁，避免了手动解锁的麻烦，异常安全。

cpp

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

int counter = 0;
std::mutex counter_mutex; // 保护 counter 的互斥锁

void safeIncrement(int numIterations) {
    for (int i = 0; i < numIterations; ++i) {
        std::lock_guard<std::mutex> lock(counter_mutex); // 构造时加锁
        ++counter; // 临界区
        // lock 析构时自动解锁
    }
}

int main() {
    const int numIterations = 1000000;
    std::thread t1(safeIncrement, numIterations);
    std::thread t2(safeIncrement, numIterations);

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

    // 结果总是 2000000
    std::cout << "Final counter value: " << counter << std::endl;
    return 0;
}

b. std::unique_lock

std::unique_lock 比 std::lock_guard 更灵活（但开销稍大），可以延迟加锁、手动解锁/加锁，并且是条件变量所必需的。

cpp

std::mutex mtx;
void complexFunction() {
    std::unique_lock<std::mutex> lock(mtx, std::defer_lock); // 延迟加锁
    // ... do some work that doesn't need the lock ...
    lock.lock(); // 现在手动加锁
    // ... critical section ...
    lock.unlock(); // 可以手动解锁
    // ... more non-critical work ...
    // 如果锁还在，析构时会自动解锁
}

5. 原子操作

对于简单的计数器，使用 std::atomic 类型是更轻量级且高效的选择。它通过硬件指令保证操作的原子性，无需锁。

cpp

#include <atomic>
#include <thread>
#include <iostream>

std::atomic<int> atomic_counter(0); // 原子整数

void atomicIncrement(int numIterations) {
    for (int i = 0; i < numIterations; ++i) {
        ++atomic_counter; // 这是一个原子操作
        // atomic_counter.fetch_add(1, std::memory_order_relaxed); // 也可以这样写
    }
}

int main() {
    const int numIterations = 1000000;
    std::thread t1(atomicIncrement, numIterations);
    std::thread t2(atomicIncrement, numIterations);

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

    // 结果总是 2000000，且性能比用互斥锁高
    std::cout << "Final atomic counter value: " << atomic_counter << std::endl;
    return 0;
}

适用场景：适用于单个变量（整数、指针、甚至自定义结构，如果满足特定条件）的简单读写、递增、比较交换（CAS）等操作。

6. 条件变量

条件变量允许线程在某个条件不满足时主动阻塞（睡眠），直到另一个线程通知条件可能已改变。它必须和互斥锁一起使用。

经典模式：生产者-消费者

cpp

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

std::queue<int> data_queue;
std::mutex mtx;
std::condition_variable cv;

void data_producer() {
    for (int i = 0; i < 10; ++i) {
        std::this_thread::sleep_for(std::chrono::milliseconds(500)); // 模拟生产耗时
        {
            std::lock_guard<std::mutex> lock(mtx);
            data_queue.push(i);
            std::cout << "Produced: " << i << std::endl;
        }
        cv.notify_one(); // 通知一个等待的消费者
    }
}

void data_consumer() {
    while (true) {
        std::unique_lock<std::mutex> lock(mtx);
        // 等待条件：队列不为空。lambda 表达式是谓词，防止虚假唤醒
        cv.wait(lock, []{ return !data_queue.empty(); });

        int data = data_queue.front();
        data_queue.pop();
        lock.unlock(); // 尽早释放锁

        std::cout << "Consumed: " << data << std::endl;
        if (data == 9) break; // 简单终止条件
    }
}

int main() {
    std::thread producer(data_producer);
    std::thread consumer(data_consumer);

    producer.join();
    consumer.join();
    return 0;
}

• cv.wait(lock, predicate)：会原子地解锁 lock 并阻塞当前线程。当被 notify 唤醒时，它会重新获取锁，并检查 predicate。如果 predicate 返回 false，它会继续等待。

• 防止虚假唤醒：使用带谓词的 wait 是标准做法，因为条件变量可能因为系统原因被意外唤醒。

7. 异步操作与 Future/Promise

<future> 头文件提供了更高层次的抽象，用于获取异步任务（在其他线程上运行的任务）的结果。

a. std::async 和 std::future

最简单的启动异步任务的方式。

cpp

#include <future>
#include <iostream>

int expensiveCalculation(int x) {
    std::this_thread::sleep_for(std::chrono::seconds(2));
    return x * x;
}

int main() {
    // 启动一个异步任务
    // std::launch::async 保证在新线程中执行
    // std::launch::deferred 表示延迟计算（直到调用 get() 时才在当前线程执行）
    std::future<int> result_future = std::async(std::launch::async, expensiveCalculation, 10);

    std::cout << "Doing some other work..." << std::endl;

    // .get() 会阻塞，直到异步任务完成并返回结果
    int result = result_future.get();
    std::cout << "Result: " << result << std::endl; // Output: Result: 100

    return 0;
}

b. std::promise 和 std::future

std::promise 允许你在一个线程中设置一个值（或异常），并通过与之关联的 std::future 在另一个线程中获取它。这是一种更手动的线程间传递结果的机制。

cpp

void doWork(std::promise<int> prom) {
    std::this_thread::sleep_for(std::chrono::seconds(2));
    prom.set_value(42); // 设置结果
}

int main() {
    std::promise<int> myPromise;
    std::future<int> myFuture = myPromise.get_future();

    std::thread worker(doWork, std::move(myPromise)); // promise 不可复制，只能移动

    std::cout << "Waiting for the result..." << std::endl;
    int result = myFuture.get(); // 阻塞并获取结果
    std::cout << "The answer is: " << result << std::endl;

    worker.join();
    return 0;
}

最佳实践与注意事项

1. 优先使用 RAII：始终使用 std::lock_guard 或 std::unique_lock 来管理锁，而不是手动调用 lock() 和 unlock()，以确保异常安全。

2. 缩小临界区：锁的粒度要细。只在绝对必要的时候持有锁，锁住后尽快释放。

3. 避免死锁：以固定的顺序获取多个锁（例如，总是先锁 mutex A，再锁 mutex B），或者使用 std::lock(m1, m2, ...) 来一次性锁住多个互斥量而避免死锁。

4. 考虑无锁编程：对于简单的数据，优先考虑 std::atomic。

5. 线程不宜过多：线程的创建和上下文切换有开销。线程数量通常与 CPU 核心数相匹配是较好的起点。对于 I/O 密集型任务，可以多一些。

6. 使用高级抽象：如果可能，优先使用 std::async 和 std::future，而不是手动管理 std::thread 和同步原语，这可以减少错误。

7. 注意线程安全：标准库的容器和函数通常不是线程安全的（除了像 std::atomic 这样的特例）。多个线程读写同一个容器必须手动加锁。

C++ 多线程编程是一个庞大而复杂的主题，这里只是冰山一角。但掌握了这些核心概念（thread, mutex, atomic, condition_variable, future），已经可以应对绝大多数多线程开发场景了。实践中，务必谨慎小心，多使用线程检查工具（如 ThreadSanitizer）来发现潜在的竞态条件和死锁。