18、并发与多线程:std::thread、线程池设计、锁与无锁编程、死锁预防

并发编程,说白了就是让程序同时干多件事。我早年接手过一个后台服务,单线程处理请求,高峰期直接卡死。后来改成多线程,吞吐量翻了三倍。但别高兴太早——并发带来的坑,一个比一个深。

18.1 std::thread 基础用法

C++11 开始,标准库终于自带了线程支持。我个人习惯直接用 std::thread,简单直接。

#include <thread>
#include <iostream>

void worker(int id) {
    std::cout << "线程 " << id << " 开始工作\n";
}

int main() {
    std::thread t1(worker, 1);
    std::thread t2(worker, 2);

    t1.join();  // 等待线程结束
    t2.detach(); // 分离线程,让它自己跑

    return 0;
}

这里有个关键点:join() 和 detach() 只能选一个。我见过有人两个都调,程序直接崩溃。嗯,线程对象一旦被分离,就不能再 join 了。

注意: 线程对象析构时,如果线程还在运行且未被 join 或 detach,会触发 std::terminate。这算是个经典坑,我早期踩过好几次。

18.2 线程池设计

每次来任务就 new 一个线程?别闹。线程创建销毁的开销不小,尤其在高并发场景下。线程池就是解决这个问题的——提前创建一批线程,任务来了直接分配。

我设计线程池时,核心思路就三点:

  • 任务队列:存放待执行的任务,用 std::queue 加互斥锁保护
  • 工作线程:固定数量,循环从队列取任务执行
  • 同步机制:用条件变量通知线程有新任务
class ThreadPool {
public:
    ThreadPool(size_t threads) : stop(false) {
        for (size_t i = 0; i < threads; ++i) {
            workers.emplace_back([this] {
                while (true) {
                    std::function<void()> task;
                    {
                        std::unique_lock<std::mutex> lock(this->queue_mutex);
                        this->condition.wait(lock, [this] {
                            return this->stop || !this->tasks.empty();
                        });
                        if (this->stop && this->tasks.empty())
                            return;
                        task = std::move(this->tasks.front());
                        this->tasks.pop();
                    }
                    task();
                }
            });
        }
    }

    template<class F>
    void enqueue(F&& f) {
        {
            std::unique_lock<std::mutex> lock(queue_mutex);
            tasks.emplace(std::forward<F>(f));
        }
        condition.notify_one();
    }

    ~ThreadPool() {
        {
            std::unique_lock<std::mutex> lock(queue_mutex);
            stop = true;
        }
        condition.notify_all();
        for (std::thread &worker : workers)
            worker.join();
    }

private:
    std::vector<std::thread> workers;
    std::queue<std::function<void()>> tasks;
    std::mutex queue_mutex;
    std::condition_variable condition;
    bool stop;
};
经验之谈: 线程数设多少合适?我一般按 CPU 核心数 + 1 来设。如果是 IO 密集型任务,可以适当多开一些。但别超过核心数的两倍,否则上下文切换反而拖慢速度。

18.3 锁与死锁预防

多线程最头疼的就是数据竞争。锁是解决手段,但用不好就是给自己挖坑。

常用锁类型

锁类型 特点 适用场景
std::mutex 基础互斥锁,独占 保护临界区
std::recursive_mutex 允许同一线程重复加锁 递归函数中加锁
std::shared_mutex 读写分离,多读单写 读多写少的场景
std::timed_mutex 带超时的锁 避免死锁

死锁这东西,说白了就是两个线程互相等对方释放锁。我曾经在一个项目里调试了整整两天,最后发现是加锁顺序不一致导致的。

死锁四大条件:
  1. 互斥条件:资源一次只能被一个线程占用
  2. 持有并等待:线程持有资源的同时等待其他资源
  3. 不可剥夺:资源不能被强行拿走
  4. 循环等待:形成等待环路

预防死锁,我总结了几条铁律:

  • 固定加锁顺序:所有线程按相同顺序获取锁。比如先锁 A 再锁 B,别搞反了
  • 使用 std::lock:一次性锁住多个互斥量,避免中间状态
  • 尽量缩小锁范围:只锁必要的代码,别把整个函数都包进去
  • 考虑用锁超时:try_lock_for() 可以避免无限等待
// 正确的加锁方式
std::mutex m1, m2;

void safe_operation() {
    // 使用 std::lock 同时锁两个
    std::lock(m1, m2);
    // 用 adopt_lock 表示锁已经获取
    std::lock_guard<std::mutex> lock1(m1, std::adopt_lock);
    std::lock_guard<std::mutex> lock2(m2, std::adopt_lock);
    // 临界区操作...
}

18.4 无锁编程

锁虽然好用,但性能开销不小。高并发场景下,锁竞争会成为瓶颈。无锁编程就是通过原子操作来避免锁。

核心工具是 std::atomic。它利用 CPU 的 CAS(Compare-And-Swap)指令,实现无锁的数据操作。

#include <atomic>

std::atomic<int> counter(0);

void increment() {
    counter.fetch_add(1, std::memory_order_relaxed);
}

// 无锁栈的 push 操作
void push(int value) {
    node* new_node = new node(value);
    new_node->next = head.load(std::memory_order_relaxed);
    while (!head.compare_exchange_weak(
        new_node->next,
        new_node,
        std::memory_order_release,
        std::memory_order_relaxed
    ));
}
慎用无锁编程: 无锁代码写起来爽,调试起来要命。我建议只在性能瓶颈处使用,而且一定要做充分的压力测试。ABA 问题、内存序问题,都是无锁编程的常见陷阱。

18.5 实战建议

说了这么多,最后给几条实在的建议:

  • 先从锁开始:别一上来就搞无锁,锁用好了性能也不差
  • 用 RAII 管理锁:std::lock_guard 和 std::unique_lock 是标配
  • 多写测试:并发 bug 很难复现,写单元测试时多跑几轮
  • 善用工具:ThreadSanitizer、Valgrind 都能帮你发现竞态条件

我记得有一次线上服务莫名其妙挂掉,查了三天日志才发现是死锁。从那以后,我每个涉及多线程的模块都会加死锁检测代码。你想想看,线上出问题的时候,多花半小时预防,能省下多少排查时间?

小技巧: 调试多线程程序时,可以用 std::this_thread::sleep_for() 人为制造时间窗口,更容易复现竞态条件。我经常用这招来验证锁是否正确。