C++ 线程库与多线程编程实战

若使用 Lambda 表达式，还能通过引用捕获外部变量：

#include <iostream>
#include <thread>

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;
}

底层原理简析

thread 构造函数是模板函数，接收可变参数包。内部通过 std::tuple 存储参数，利用 std::apply 解包传递给可调用对象。由于 pthread_create 要求函数签名为 void* (*)(void*)，thread 类定义了一个静态代理函数 thread_proxy，将用户传入的可调用对象包装成符合 POSIX 要求的函数形式，实现了类型安全的适配。

线程生命周期管理

创建线程后，需要管理其状态。thread 类维护一个状态字段（Joinable、Detached、Joined）和原生线程 ID。

• join: 等待线程结束。若重复调用或线程已分离，会抛出异常。
• detach: 分离线程，使其独立运行，之后不能再 join。
• 析构: 若线程处于 Joinable 状态且未处理，析构时会调用 std::terminate 终止进程。因此务必确保线程被正确 join 或 detach。

此外，thread 类禁用了拷贝构造和赋值，但允许移动语义。移动操作可以转移线程的所有权，避免资源竞争。

互斥锁与 RAII

多线程访问共享资源时，需保证互斥。C++ 提供了 mutex 类，封装了底层的互斥锁操作。

手动加锁解锁容易因异常导致死锁，因此推荐使用基于 RAII 的锁管理器：

• lock_guard: 简单高效，构造即加锁，析构即解锁。适用于整个作用域都需要锁的场景。
• unique_lock: 更灵活，支持延迟加锁、接管已加锁的 mutex 等策略，常用于配合条件变量。

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（唤醒所有）。注意 wait 函数通常只接受 unique_lock，若需兼容其他锁类型可使用 condition_variable_any。

实战案例：奇偶打印

需求：两个线程交替打印 1 到 10 的奇数和偶数。

方案一：使用两个条件变量分别对应奇偶状态。

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

std::mutex mtx;
std::condition_variable cv_even, cv_odd;
int counter = 0;

void print_even(int max_num) {
    while (true) {
        std::unique_lock<std::mutex> lock(mtx);
        while (counter < max_num && counter % 2 != 0) {
            cv_even.wait(lock);
        }
        if (counter >= max_num) break;
        std::cout << "Even: " << counter << std::endl;
        ++counter;
        cv_odd.notify_one();
    }
}

void print_odd(int max_num) {
    while (true) {
        std::unique_lock<std::mutex> lock(mtx);
        while (counter < max_num && counter % 2 != 1) {
            cv_odd.wait(lock);
        }
        if (counter >= max_num) break;
        std::cout << "Odd: " << counter << std::endl;
        ++counter;
        cv_even.notify_one();
    }
}

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

方案二：使用一个条件变量和一个布尔标志位控制轮流执行，逻辑更简洁。

原子操作与内存模型

对于简单的计数操作，互斥锁开销较大。C++ 提供了 atomic 类模板，利用硬件指令保证操作的原子性。

底层原理

数据不一致往往源于非原子操作被中断。现代 CPU 通过总线锁定或缓存一致性协议（如 MESI）来保证多核环境下的可见性。带有 lock 前缀的指令能确保内存读写连续完成。

atomic 特化类重载了运算符，底层映射为原子指令。对于内置类型，通常是真正的无锁实现；对于自定义类型，可能退化为基于锁的实现。可通过 is_lock_free() 查询。

内存顺序

原子操作默认提供顺序一致性（memory_order_seq_cst），防止指令重排。在高性能场景中，可根据需求调整内存序（如 memory_order_relaxed），但需谨慎使用。

CAS 与无锁编程

CAS（Compare-And-Swap）是一种经典的原子机制。std::atomic 提供了 compare_exchange_weak 接口。它常用于实现自旋锁或无锁数据结构（如无锁链表）。

struct Node {
    int data;
    std::atomic<Node*> next;
};

// 伪代码示意
bool success = node->next.compare_exchange_weak(expected, new_node);

智能指针的线程安全

shared_ptr 的引用计数修改是线程安全的，但指向的对象本身并非自动保护。多个线程同时修改同一个 shared_ptr 对象（如赋值）仍会导致竞争，需自行加锁保护。

结语

C++ 标准线程库提供了强大的并发原语。理解其底层机制（如条件编译、内存模型、CAS）有助于编写更高效、安全的并发代码。在实际开发中，优先使用原子操作减少锁竞争，合理使用 RAII 管理资源，是构建高可靠多线程系统的关键。