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 | 带超时的锁 | 避免死锁 |
死锁这东西,说白了就是两个线程互相等对方释放锁。我曾经在一个项目里调试了整整两天,最后发现是加锁顺序不一致导致的。
死锁四大条件:
- 互斥条件:资源一次只能被一个线程占用
- 持有并等待:线程持有资源的同时等待其他资源
- 不可剥夺:资源不能被强行拿走
- 循环等待:形成等待环路
预防死锁,我总结了几条铁律:
- 固定加锁顺序:所有线程按相同顺序获取锁。比如先锁 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() 人为制造时间窗口,更容易复现竞态条件。我经常用这招来验证锁是否正确。