C++ 线程库与多线程编程详解

也可以使用 Lambda 表达式捕获外部变量：

int main() {
    size_t i = 0, j = 2;
    std::thread t1([&]() {
        for (; i < j; ++i) {
            std::cout << "I am a thread" << std::endl;
        }
    });
    t1.join();
    return 0;
}

内部机制简析

std::thread 构造函数是模板化的，利用可变参数包接收任意类型的参数。内部通过 std::tuple 存储参数，并使用一个代理函数（proxy）适配 pthread_create 要求的函数签名。代理函数负责调用用户提供的可调用对象，并管理内存生命周期。

线程状态与管理

线程对象有三种主要状态：可连接（Joinable）、已分离（Detached）、已连接（Joined）。

• join: 阻塞当前线程直到目标线程结束。若重复调用会抛出异常。
• detach: 让线程独立运行，脱离原线程控制。一旦分离不可再 join。
• 析构: 如果 std::thread 对象析构时仍为 Joinable 状态，程序会调用 std::terminate 终止进程。因此必须确保在析构前完成 join 或 detach。

移动语义允许线程所有权转移，但拷贝被禁用，防止资源竞争。

互斥锁 mutex

当多个线程访问共享资源时，需使用互斥锁保证原子性。std::mutex 是最基础的互斥锁。

RAII 锁管理

手动加锁解锁容易因异常导致死锁。C++ 提供了基于 RAII 的锁管理器：

1. lock_guard: 构造时加锁，析构时自动解锁。作用域固定，无法中途释放。
2. unique_lock: 更灵活，支持延迟加锁、接管已有锁等策略，常用于条件变量配合。

std::mutex mtx;
void safe_operation() {
    std::unique_lock<std::mutex> lock(mtx, std::defer_lock);
    // 预处理...
    lock.lock();
    // 临界区...
    lock.unlock();
}

其他锁类型

• recursive_mutex: 允许同一线程多次加锁，适用于递归场景。
• timed_mutex: 支持超时尝试获取锁，避免无限阻塞。

条件变量 condition_variable

条件变量用于线程间的同步通知。核心方法包括 wait（等待条件满足）、notify_one（唤醒一个等待者）和 notify_all（唤醒所有）。

典型用法是配合 unique_lock 使用：

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

void wait_for_ready() {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, []{ return ready; });
}

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

应用案例：交替打印

面试中常见题目：两个线程交替打印奇数和偶数。关键在于使用条件变量控制执行顺序。

方案一：使用两个条件变量分别对应奇偶线程。 方案二：使用一个布尔标志位配合一个条件变量。

以下展示方案二的实现逻辑：

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

std::mutex mtx;
std::condition_variable cv;
int counter = 0;
bool is_even_turn = true;

void print_odd(int max_num) {
    while (true) {
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, [&](){ return !is_even_turn && counter < max_num; });
        if (counter >= max_num) break;
        std::cout << "Odd: " << counter++ << std::endl;
        is_even_turn = true;
        cv.notify_one();
    }
}

void print_even(int max_num) {
    while (true) {
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, [&](){ return is_even_turn && counter < max_num; });
        if (counter >= max_num) break;
        std::cout << "Even: " << counter++ << std::endl;
        is_even_turn = false;
        cv.notify_one();
    }
}

int main() {
    std::thread t1(print_odd, 10);
    std::thread t2(print_even, 10);
    t1.join();
    t2.join();
    return 0;
}

atomic 原子操作

对于简单的计数器递增，使用互斥锁开销较大。std::atomic 提供硬件级别的原子操作，避免数据竞争且性能更高。

底层原理

原子操作依赖 CPU 指令集（如 x86 的 lock add）。这些指令在执行期间锁定总线或缓存行，确保读写操作不被中断。现代多核 CPU 通过 MESI 协议维护缓存一致性，保证修改后的数据对其他核心可见。

内存顺序

原子操作默认提供顺序一致性（memory_order_seq_cst），保证指令不重排。也可指定宽松顺序以优化性能，但需谨慎使用。

std::atomic<int> var(0);
var.fetch_add(1, std::memory_order_relaxed);

CAS 无锁编程

CAS（Compare-And-Swap）是无锁编程的基础。compare_exchange_weak 尝试比较并更新值，成功返回 true，失败则重试。常用于实现自旋锁或无锁数据结构。

智能指针的线程安全

std::shared_ptr 的引用计数修改是线程安全的，但指向的对象本身并非线程安全。多线程访问同一对象仍需额外加锁保护。

结语

C++11 引入的标准线程库极大地简化了并发编程。理解其底层机制，合理选用锁与原子操作，是构建高性能多线程应用的关键。在实际开发中，应优先使用标准库组件，避免直接使用原生线程接口，以确保代码的可移植性与安全性。