C++ 线程库与多线程编程核心机制解析

生命周期管理

线程对象的生命周期由 join 和 detach 控制。

• join: 阻塞当前线程直到目标线程结束。一个线程只能被 join 一次。
• detach: 分离线程，使其在后台独立运行，脱离原线程对象的管理。

如果 std::thread 对象析构时仍处于可连接（Joinable）状态，程序会调用 std::terminate 终止进程。因此，务必确保在对象销毁前完成 join 或 detach。

void thread::join() {
    if (!joinable() || thread_id_ == 0) {
        throw std::runtime_error("Thread is not joinable");
    }
    int result = pthread_join(thread_id_, nullptr);
    if (result != 0) {
        throw std::runtime_error("pthread_join failed");
    }
    state_ = ThreadState::JOINED;
    thread_id_ = 0;
}

移动语义

std::thread 禁止拷贝，但支持移动。通过移动构造函数，可以将线程的所有权从一个对象转移到另一个对象，原对象变为空线程。这避免了资源重复释放的问题。

互斥锁与同步

Mutex 与 RAII

当多个线程访问共享资源时，必须使用互斥锁（Mutex）保证原子性。C++ 提供了 std::mutex 类，其内部封装了原生锁对象。

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

• lock_guard: 最简单的锁管理器，构造时加锁，析构时自动解锁。适用于整个作用域都需要锁的场景。
• 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: 支持超时等待，避免无限阻塞，适合对响应时间有要求的场景。

条件变量

条件变量用于线程间的通信与同步。std::condition_variable 配合 std::unique_lock 使用。

• wait: 释放锁并进入阻塞，直到被通知。
• notify_one: 唤醒一个等待线程。
• notify_all: 唤醒所有等待线程。

注意：wait 必须在循环中检查条件，因为虚假唤醒（Spurious Wakeup）可能导致条件未满足但线程已被唤醒。

实战案例：交替打印奇偶数

这是一个经典的并发问题，需要两个线程交替打印 1 到 10 的奇数和偶数。

方案一：双条件变量 每个线程对应一个条件变量，分别等待奇偶条件满足。

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

std::mutex mutex;
std::condition_variable cond_even, cond_odd;
int counter = 0;

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

void print_odd(size_t max_num) {
    while (true) {
        std::unique_lock<std::mutex> lock(mutex);
        while (counter < max_num && counter % 2 == 0) {
            cond_odd.wait(lock);
        }
        if (counter >= max_num) break;
        std::cout << "Odd: " << counter << std::endl;
        ++counter;
        cond_even.notify_one();
    }
}

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

原子操作与无锁编程

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

CAS 原理

Compare-And-Swap (CAS) 是一种乐观锁机制。它包含三个操作数：内存地址、预期值和新值。只有当内存中的值等于预期值时，才将新值写入，否则失败重试。现代 CPU 提供硬件支持的 CAS 指令（如 x86 的 LOCK XCHG），效率远高于互斥锁。

内存顺序

原子操作默认提供顺序一致性（memory_order_seq_cst），但这可能带来性能损耗。根据需求可选择宽松顺序（memory_order_relaxed）或获取 - 释放顺序（memory_order_acquire/release），以平衡性能与正确性。

#include <atomic>
std::atomic<int> var(0);

void add() {
    var.fetch_add(1, std::memory_order_relaxed);
}

智能指针的线程安全

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

总结

C++ 标准线程库通过 std::thread、std::mutex、std::condition_variable 和 std::atomic 提供了完善的多线程支持。理解其底层机制（如条件编译、RAII、CAS、内存屏障）有助于编写高效且安全的并发代码。在实际开发中，优先使用原子操作优化简单场景，复杂同步则依赖锁与条件变量，并注意避免死锁和数据竞争。