并发编程
用标准库线程、互斥量与 future 写出正确的并发代码
#先建立正确的心智模型
如果你从 Java 转过来,C++ 的并发模型会让你意外地熟悉:std::thread 对应 Thread,std::mutex 对应 synchronized 的底层原语,condition_variable 就是 wait/notify 那套机制。从 Python 过来则要重新适应——CPython 有 GIL,多线程几乎无法并行执行字节码,所以 Python 程序员习惯用多进程或 asyncio 绕开;而 C++ 的线程是真正的操作系统线程,没有全局锁,能跑满多核,代价是每一个数据竞争都要你自己负责。至于 JavaScript 的单线程事件循环,它用「不存在共享内存」的方式回避了整个问题域:Web Worker 之间靠消息传递,天然没有数据竞争。C++ 走的是最硬核的路线——共享内存 + 显式同步。
本章默认 C++17。核心原则只有一条:只要两个线程访问同一块内存,且至少一个是写操作,且没有同步关系,就是数据竞争(data race),而数据竞争在 C++ 标准里属于未定义行为。 不是「可能出错」,是标准明确说结果不可预测。这点比 Java 严格,Java 的内存模型至少保证不出离谱结果。
#std::thread 与线程生命周期
线程对象在构造完成后立刻开始执行。关键在于:std::thread 析构时如果仍然 joinable(即线程还在运行且未被 join/detach),程序会直接调用 std::terminate 崩溃。这是新手最常踩的坑——Python 的 threading.Thread 默认是非守护线程,解释器会等它结束;Java 的线程同理。C++ 要求你显式表态。
#include <chrono>
#include <iostream>
#include <thread>
#include <vector>
void worker(int id) {
for (int i = 0; i < 3; ++i) {
std::cout << "thread " << id << " step " << i << "\n";
std::this_thread::sleep_for(std::chrono::milliseconds(10));
}
}
int main() {
std::vector<std::thread> pool;
for (int i = 0; i < 4; ++i) {
pool.emplace_back(worker, i); // 传参:值拷贝进线程
}
// 传引用必须显式 std::ref,否则是拷贝
int shared = 0;
std::thread t([&shared] { shared = 42; });
for (auto& th : pool) {
if (th.joinable()) th.join(); // join:等待结束并回收
}
t.join();
std::cout << "shared = " << shared << "\n";
std::cout << "hardware_concurrency = "
<< std::thread::hardware_concurrency() << "\n";
}join() 是「等待并回收」,会阻塞当前线程;detach() 是「放任不管」,线程变成后台线程,资源在结束时自动回收,但一旦 detach,你必须保证它访问的所有对象活得比它久——否则就是悬垂引用。绝大多数情况下不该用 detach,正确做法是用 RAII 包装(C++20 的 std::jthread 会在析构时自动 join,还能通过 stop_token 请求取消,推荐在新项目中使用)。
异常安全也要注意:如果 join 之前的代码抛异常,线程对象析构就会终止程序,所以用 RAII 的 thread_guard 或 jthread 更稳妥。另外 std::thread 的构造函数是按值拷贝参数的,传引用必须显式写 std::ref(obj),否则你修改的只是一份副本——这一点极易出错,因为普通函数调用传引用是直接写 obj。
最后是输出问题:std::cout 本身是线程安全的(不会交错出半个字符串),但多条 << 之间会互相穿插。上面的示例之所以看起来整齐,是因为每个线程只输出一句;真实项目里需要日志库或额外的互斥量来保证行的完整性。
#数据竞争与互斥量家族
#include <iostream>
#include <mutex>
#include <thread>
#include <vector>
class Counter {
public:
void add(int n) {
std::lock_guard<std::mutex> lk(m_); // 构造加锁,析构解锁
value_ += n;
}
int get() const {
std::lock_guard<std::mutex> lk(m_); // mutable mutex
return value_;
}
private:
mutable std::mutex m_;
int value_ = 0;
};
int main() {
Counter c;
std::vector<std::thread> ts;
for (int i = 0; i < 8; ++i) {
ts.emplace_back([&c] {
for (int k = 0; k < 10000; ++k) c.add(1);
});
}
for (auto& t : ts) t.join();
std::cout << "value = " << c.get() << "\n"; // 稳定输出 80000
}四种锁的取舍:
std::lock_guard:最简单,作用域内持锁,不可手动解锁。首选。std::unique_lock:可延迟加锁、可unlock()、可转移所有权,必须配合condition_variable::wait使用。std::scoped_lock(C++17):一次锁住多个互斥量,内部用死锁避免算法(类似std::lock),彻底解决加锁顺序导致的死锁。取代手写lock_guard套两层。std::shared_mutex(C++17):读写锁,多读单写,配合shared_lock使用。
#include <map>
#include <mutex>
#include <shared_mutex>
#include <string>
class Config {
public:
std::string get(const std::string& key) const {
std::shared_lock<std::shared_mutex> rk(m_); // 多个读者并行
auto it = data_.find(key);
return it == data_.end() ? "" : it->second;
}
void set(std::string key, std::string value) {
std::unique_lock<std::shared_mutex> wk(m_); // 写者独占
data_[std::move(key)] = std::move(value);
}
private:
mutable std::shared_mutex m_;
std::map<std::string, std::string> data_;
};
// 需要同时锁两个互斥量时:scoped_lock 用死锁避免算法,不必关心加锁顺序
struct Account {
mutable std::mutex m_;
int balance_ = 100;
};
bool transfer(Account& from, Account& to, int amount) {
std::scoped_lock lk(from.m_, to.m_); // 同时锁住两个,不会死锁
if (from.balance_ < amount) return false;
from.balance_ -= amount;
to.balance_ += amount;
return true;
}对比 Java:synchronized 是可重入锁,编译器自动插入 monitorenter/monitorexit,退出作用域自动释放——语义上最接近 lock_guard,而且 Java 的 synchronized 还能直接配合 Object.wait/notify。C++ 的 std::mutex 不可重入,同一线程重复加锁是未定义行为(需要递归请用 std::recursive_mutex,但那通常说明设计有问题);等待机制也拆成了独立的 condition_variable,不与锁绑定。
还有一个容易被忽略的点:锁的粒度。把整个循环体锁住,多线程就退化成串行;只在真正修改共享状态的那一行加锁,才有并行收益。上面的 Counter::add 演示的是正确但低效的写法——实际项目中应该用 std::atomic 或让每个线程先在本地累加、最后合并一次。
#条件变量与生产者-消费者
互斥量解决互斥,条件变量解决「等待某个条件成立」。经典的三段式是:拿 unique_lock → wait 配合谓词 → 修改后 notify。用 lambda 谓词是必须的,它能正确处理虚假唤醒(spurious wakeup)。
#include <condition_variable>
#include <iostream>
#include <mutex>
#include <queue>
#include <thread>
template <typename T>
class BlockingQueue {
public:
void push(T item) {
{
std::lock_guard<std::mutex> lk(m_);
q_.push(std::move(item));
}
cv_.notify_one(); // 先解锁再通知,减少唤醒抖动
}
T pop() {
std::unique_lock<std::mutex> lk(m_);
cv_.wait(lk, [this] { return !q_.empty() || closed_; });
if (q_.empty()) throw std::runtime_error("closed");
T item = std::move(q_.front());
q_.pop();
return item;
}
void close() {
{
std::lock_guard<std::mutex> lk(m_);
closed_ = true;
}
cv_.notify_all(); // 唤醒所有等待者收尾
}
private:
mutable std::mutex m_;
std::condition_variable cv_;
std::queue<T> q_;
bool closed_ = false;
};
int main() {
BlockingQueue<int> q;
std::thread producer([&] {
for (int i = 0; i < 5; ++i) q.push(i);
q.close();
});
std::thread consumer([&] {
try {
while (true) std::cout << "got " << q.pop() << "\n";
} catch (const std::exception&) { /* 关闭后退出 */ }
});
producer.join();
consumer.join();
}#std::atomic 与内存序入门
#include <atomic>
#include <iostream>
#include <thread>
#include <vector>
int main() {
std::atomic<int> hits{0};
std::atomic<bool> done{false};
std::vector<std::thread> ts;
for (int i = 0; i < 4; ++i) {
ts.emplace_back([&] {
for (int k = 0; k < 100000; ++k) {
hits.fetch_add(1, std::memory_order_relaxed);
}
done.store(true, std::memory_order_release);
});
}
for (auto& t : ts) t.join();
std::cout << hits.load() << "\n"; // 400000,无锁且正确
}原子操作是无锁的(对整型通常编译成单条 lock xadd 指令),比互斥量快一个数量级,但只适合单个变量的简单操作。内存序(memory order)入门记三条就够:
memory_order_relaxed:只保证原子性,不保证顺序。适合计数器这类「只关心最终值」的场景。memory_order_acquire/release:成对使用,构成同步关系。release 之前的写,对 acquire 之后的读可见。上面的done就是典型用法。memory_order_seq_cst:默认值,最强也是最慢,保证全局单一顺序。不确定时就用它。
Java 的 volatile 和 C++ 的 volatile 完全不同——前者有 acquire/release 语义,后者只防止编译器优化、对线程同步毫无帮助。这是从 Java 转 C++ 的经典误区。
#async / future / promise
std::async 是最简单的高层并发入口,适合「丢一个任务出去,稍后取结果」。
#include <future>
#include <iostream>
#include <numeric>
#include <vector>
long long sum_range(const std::vector<int>& v, size_t lo, size_t hi) {
return std::accumulate(v.begin() + lo, v.begin() + hi, 0LL);
}
int main() {
std::vector<int> data(1'000'000, 1);
// 显式指定 async 策略:默认可能是 deferred(延迟到 get 时才执行)
auto f1 = std::async(std::launch::async, sum_range, std::cref(data), 0, 500'000);
auto f2 = std::async(std::launch::async, sum_range, std::cref(data), 500'000, data.size());
std::cout << "total = " << f1.get() + f2.get() << "\n";
// promise:手动设置结果,常用于把回调转成 future
std::promise<int> p;
std::future<int> f = p.get_future();
std::thread setter([&p] {
std::this_thread::sleep_for(std::chrono::milliseconds(50));
p.set_value(99); // 或 set_exception 传递异常
});
std::cout << "promised = " << f.get() << "\n";
setter.join();
}注意三点:future::get() 只能调用一次,且会阻塞;std::async 默认策略是实现定义的,可能是 deferred(在 get() 时同步执行),想要真并发必须显式传 std::launch::async;std::future 的析构在 async 返回时会阻塞等待任务完成——这是个容易被忽略的隐式同步点。
#线程池的基本思路
线程创建销毁开销大(约数十微秒),高频小任务应该复用线程。一个最小线程池由三部分组成:一个 BlockingQueue<std::function<void()>>、一组常驻工作线程、以及提交接口。任务类型用 std::function 做类型擦除是这里唯一合理的选择——队列必须存储异构的可调用对象。想拿到返回值,就让提交接口返回 std::future<R>,内部用 packaged_task 包装。C++20 之后可以再加 std::jthread + stop_token 实现优雅关闭。
#小结
std::thread析构时若仍 joinable 会terminate;优先join(),C++20 用std::jthread自动回收。- 数据竞争 = 未定义行为。共享可写数据必须同步:
lock_guard为默认选择,多锁用scoped_lock,条件变量必须配unique_lock。 - 条件变量的
wait必须带谓词 lambda,以应对虚假唤醒;修改状态后notify,先解锁再通知。 - 单变量的简单计数用
std::atomic;内存序默认用seq_cst,只在明确知道语义时才降级。 std::async必须显式std::launch::async才是真并发;future::get()一次性且会阻塞。
#练习
- 把
Counter的互斥量去掉,跑 8 线程各加 10000 次,观察结果是否等于 80000;再用-fsanitize=thread运行,阅读 ThreadSanitizer 给出的竞争报告。 - 为
BlockingQueue增加try_pop()(队列空时立即返回std::optional<T>)和size(),并说明为什么size()加锁后返回的值可能立刻失效。 - 用
std::async实现并行版「统计一个大 vector 中大于阈值的元素个数」,拆成 4 段并行求和;对比单线程版本耗时。 - (进阶)实现一个最小线程池:
submit(F&&) -> std::future<R>,内部用packaged_task+ 上一章的BlockingQueue,支持析构时等待所有任务完成。线程数取hardware_concurrency()。