C++ 并发编程进阶：线程同步、原子操作与死锁规避实战 - 教程
引言
在多核处理器成为硬件主流的今天，并发编程已从可选技能转变为开发高性能应用的必备能力。C++11 标准首次引入 <thread> 库，正式将并发编程纳入标准规范，后续 C++14/17/20 持续迭代优化，提供了更完善的同步机制、原子操作和并发工具链。然而，并发编程的复杂性远超串行编程，线程间的数据竞争、死锁、条件竞争等问题往往隐蔽且难以调试，成为开发者面临的主要挑战。
本文聚焦 C++ 并发编程的核心进阶技术，从线程同步机制的深度解析、原子操作的原理与实践，到死锁的成因与规避策略，结合真实场景案例与可运行代码，系统讲解并发编程的关键知识点与实战技巧。本文旨在帮助开发者掌握并发编程的核心逻辑，能够编写高效、安全、可靠的并发代码，应对实际开发中的复杂场景。
一、线程同步机制深度解析
线程同步是并发编程的基础，其核心目标是解决多个线程对共享资源的并发访问冲突，确保数据一致性与操作原子性。C++ 标准提供了多种同步机制，包括互斥锁、条件变量、信号量等，每种机制都有其适用场景与使用要点。
1.1 互斥锁（Mutex）家族：从基础到进阶
互斥锁是最常用的同步工具，通过“排他性访问”保证同一时刻只有一个线程能进入临界区。C++ 标准库提供了四种核心互斥锁类型，覆盖不同场景需求：
（1）std::mutex：基础排他锁
std::mutex 是最基础的互斥锁，提供 lock()、unlock() 和 try_lock() 三个核心接口。使用时需严格遵循“锁-访问-解锁”的流程，且必须保证解锁操作在任何退出路径上都能执行，否则会导致锁泄露。
基础使用示例：
#include <mutex>#include <thread>#include <vector>#include <iostream>std::mutex mtx;int shared_count = 0;void increment() {for (int i = 0; i < 10000; ++i) {mtx.lock(); // 加锁，若已被锁定则阻塞shared_count++; // 临界区：操作共享资源mtx.unlock(); // 解锁，必须执行}}int main() {std::vector<std::thread> threads;for (int i = 0; i < 4; ++i) {threads.emplace_back(increment);}for (auto& t : threads) {t.join();}std::cout << "Final count: " << shared_count << std::endl; // 输出 40000return 0;}注意事项：
- 手动调用
lock()和unlock()存在风险，若临界区抛出异常，unlock()可能无法执行，导致锁泄露； try_lock()尝试加锁时不会阻塞，返回true表示加锁成功，false表示失败，适用于非阻塞场景。
（2）std::lock_guard：RAII 风格的安全锁
为解决手动解锁的风险，C++11 引入 std::lock_guard，其核心是基于 RAII（资源获取即初始化）机制，在构造时自动加锁，析构时自动解锁，即使发生异常也能保证锁的释放。
优化后示例：
void increment_safe() {
for (int i = 0; i < 10000; ++i) {
std::lock_guard<std::mutex> lock(mtx); // 构造时加锁，析构时解锁shared_count++;}}std::lock_guard 不可复制、不可移动，仅支持默认构造（需传入已锁定的互斥锁）或带互斥锁参数的构造，适用于临界区范围明确的场景。
（3）std::unique_lock：灵活的高级锁
std::unique_lock 是功能最强大的互斥锁包装器，支持延迟加锁、条件变量配合、锁所有权转移等高级特性，灵活性远超 std::lock_guard，但性能开销略高。
核心特性与示例：
- 延迟加锁：构造时不自动加锁，后续通过
lock()手动加锁； - 条件变量配合：必须使用
std::unique_lock作为std::condition_variable的等待参数； - 锁所有权转移：支持通过
std::move()转移锁的所有权，适用于锁需要跨函数传递的场景。
// 延迟加锁与条件变量配合示例
std::mutex mtx;
std::condition_variable cv;
bool ready = false;
void worker() {
std::unique_lock<std::mutex> lock(mtx); // 构造时不加锁cv.wait(lock, []{ return ready; }); // 等待时自动解锁，被唤醒后重新加锁std::cout << "Worker thread started" << std::endl;}void notify() {{std::lock_guard<std::mutex> lock(mtx);ready = true;}cv.notify_one(); // 唤醒一个等待的线程}（4）std::recursive_mutex：递归锁
std::recursive_mutex 允许同一线程多次加锁，解锁次数需与加锁次数一致，否则会导致锁状态异常。适用于递归函数或同一线程需多次进入临界区的场景，但应尽量避免使用——递归锁可能隐藏逻辑错误，且性能开销高于普通互斥锁。
使用示例：
std::recursive_mutex rmtx;
int depth = 0;
void recursive_func() {
std::lock_guard<std::recursive_mutex> lock(rmtx);depth++;std::cout << "Depth: " << depth << std::endl;if (depth < 3) {recursive_func(); // 同一线程再次加锁，允许执行}depth--;}1.2 条件变量（Condition Variable）：线程间通信的核心
条件变量用于线程间的“通知-等待”机制，允许一个线程等待某个条件满足，另一个线程在条件满足时通知等待线程，避免线程忙等（忙等会浪费 CPU 资源）。C++ 标准库提供 std::condition_variable（配合 std::unique_lock）和 std::condition_variable_any（可配合任意满足 BasicLockable 要求的锁），前者性能更优，是首选。
核心工作流程
- 等待线程：获取互斥锁 → 检查条件 → 条件不满足则调用
wait()释放锁并阻塞 → 被唤醒后重新获取锁并再次检查条件； - 通知线程：获取互斥锁 → 修改条件 → 释放锁 → 调用
notify_one()或notify_all()通知等待线程。
经典生产者-消费者模型示例：
#include <mutex>#include <condition_variable>#include <queue>#include <thread>#include <iostream>const int MAX_QUEUE_SIZE = 5;std::queue<int> task_queue;std::mutex mtx;std::condition_variable not_full; // 队列未满条件std::condition_variable not_empty; // 队列非空条件// 生产者线程：生成任务并加入队列void producer(int id) {for (int i = 0; i < 10; ++i) {std::unique_lock<std::mutex> lock(mtx);// 等待队列未满not_full.wait(lock, []{ return task_queue.size() < MAX_QUEUE_SIZE; });int task = id * 100 + i;task_queue.push(task);std::cout << "Producer " << id << " added task: " << task << std::endl;lock.unlock();not_empty.notify_one(); // 通知消费者队列非空}<