std::mutex与std::lock

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

std::mutex与std::lock详解及使用指南

std::mutex和std::lock是 C++11 标准库中用于多线程同步的核心组件，主要解决数据竞争和死锁问题。其中，std::mutex是基础的互斥锁类型，而std::lock是用于安全锁定多个互斥锁的函数模板，二者常配合使用。

一、std::mutex详解

1. 什么是std::mutex

std::mutex（互斥量，Mutual Exclusion）是 C++ 标准库提供的基础互斥锁，属于<mutex>头文件。它的核心作用是保护临界区（多个线程同时访问的共享资源代码段），确保同一时间只有一个线程能进入临界区，从而避免数据竞争（未定义行为）。

std::mutex是非递归锁（也叫非重入锁），即同一个线程不能对同一个std::mutex多次调用lock()（否则会导致死锁）。

2.std::mutex的核心成员函数

3.std::mutex的基本使用（不推荐直接用，仅作示例）

直接调用lock()和unlock()是最基础的用法，但存在严重缺陷（如忘记解锁、异常导致解锁失败），仅用于理解原理。

示例1：基础使用（存在风险）

#include<iostream>#include<thread>#include<mutex>#include<vector>// 共享资源intg_count=0;// 互斥锁：保护g_countstd::mutex g_mutex;// 累加函数voidincrement(inttimes){for(inti=0;i<times;++i){// 加锁：进入临界区g_mutex.lock();// 临界区：操作共享资源g_count++;// 解锁：退出临界区g_mutex.unlock();// 模拟耗时操作（锁外执行，减少阻塞）std::this_thread::sleep_for(std::chrono::nanoseconds(1));}}intmain(){constintthread_num=5;constinttimes_per_thread=1000;std::vector<std::thread>threads;// 创建线程for(inti=0;i<thread_num;++i){threads.emplace_back(increment,times_per_thread);}// 等待线程结束for(auto&t:threads){t.join();}std::cout<<"最终count值："<<g_count<<std::endl;// 正确输出5000return0;}

示例2：直接使用的缺陷（异常导致死锁）

如果临界区中抛出异常，unlock()不会被执行，锁会被永久占用，导致其他线程死锁：

voidincrementWithException(inttimes){for(inti=0;i<times;++i){g_mutex.lock();// 模拟异常：比如除以0if(i==500){throwstd::runtime_error("意外异常");// 异常抛出，unlock()不会执行}g_count++;g_mutex.unlock();// 永远执行不到}}

4. 改进：RAII 风格的锁管理（推荐使用）

为了解决手动加锁/解锁的缺陷，C++ 提供了RAII（资源获取即初始化）风格的锁管理类，它们会在构造时自动加锁，析构时自动解锁（即使发生异常），从根本上避免死锁。

（1）std::lock_guard：轻量级RAII锁（推荐用于简单场景）

std::lock_guard是最简单的 RAII 锁，功能单一：构造加锁，析构解锁，不支持手动控制锁的生命周期。

示例：用std::lock_guard修复异常问题

#include<iostream>#include<thread>#include<mutex>#include<vector>#include<stdexcept>intg_count=0;std::mutex g_mutex;voidincrementSafe(inttimes){for(inti=0;i<times;++i){// RAII：构造时加锁，析构时解锁（即使异常也会解锁）std::lock_guard<std::mutex>lock(g_mutex);// 模拟异常if(i==500){// 异常抛出时，lock的析构函数会被调用，自动解锁throwstd::runtime_error("意外异常");}g_count++;}}intmain(){constintthread_num=5;constinttimes_per_thread=1000;std::vector<std::thread>threads;try{for(inti=0;i<thread_num;++i){threads.emplace_back(incrementSafe,times_per_thread);}for(auto&t:threads){t.join();}}catch(conststd::exception&e){std::cout<<"捕获异常："<<e.what()<<std::endl;}std::cout<<"最终count值："<<g_count<<std::endl;return0;}

（2）std::unique_lock：灵活的RAII锁（推荐用于复杂场景）

std::unique_lock比std::lock_guard更灵活，支持：

• 手动加锁/解锁（lock()/unlock()）；
• 延迟加锁（构造时不加锁，后续手动调用lock()）；
• 尝试加锁（try_lock()）；
• 超时加锁（try_lock_for()/try_lock_until()）；
• 配合条件变量（std::condition_variable）使用；
• 转移锁的所有权（支持移动语义，不可复制）。

示例：std::unique_lock的灵活使用

#include<iostream>#include<thread>#include<mutex>#include<vector>intg_count=0;std::mutex g_mutex;voidincrementFlexible(inttimes){for(inti=0;i<times;++i){// 延迟加锁：构造时不加锁，后续手动加锁std::unique_lock<std::mutex>lock(g_mutex,std::defer_lock);// 手动加锁（也可以用try_lock()尝试加锁）lock.lock();g_count++;// 手动解锁（可选：析构时会自动解锁，这里提前解锁以减少阻塞）lock.unlock();// 锁已释放，其他线程可进入临界区std::this_thread::sleep_for(std::chrono::nanoseconds(1));}}intmain(){constintthread_num=5;constinttimes_per_thread=1000;std::vector<std::thread>threads;for(inti=0;i<thread_num;++i){threads.emplace_back(incrementFlexible,times_per_thread);}for(auto&t:threads){t.join();}std::cout<<"最终count值："<<g_count<<std::endl;return0;}

二、std::lock详解

1. 什么是std::lock

std::lock是 C++11 提供的函数模板（位于<mutex>头文件），不是锁类型。它的核心作用是同时锁定多个互斥锁，并采用避免死锁的算法（如按互斥锁的内存地址顺序加锁），确保要么所有锁都被成功锁定，要么一个都不锁定（如果其中一个锁被占用，会释放已锁定的锁，等待后重试）。

2.std::lock的核心特点

• 接收多个互斥锁的引用作为参数（至少两个）；
• 原子操作：要么全部锁定，要么全部不锁定；
• 避免死锁：内部实现了死锁避免逻辑（如按地址排序加锁）；
• 不管理锁的生命周期：锁定后需要手动解锁（或配合 RAII 类的std::adopt_lock参数）。

3.std::lock的使用场景

当一个线程需要同时访问多个共享资源（对应多个互斥锁）时，直接依次加锁可能导致死锁，此时用std::lock可以安全锁定多个锁。

死锁示例（依次加锁导致）

两个线程同时尝试锁定两个互斥锁，但顺序相反，导致互相等待：

#include<iostream>#include<thread>#include<mutex>std::mutex m1,m2;// 线程1：先锁m1，再锁m2voidthread1Func(){for(inti=0;i<1000;++i){m1.lock();m2.lock();// 可能被线程2的m2.lock()阻塞，此时线程1持有m1，线程2持有m2，死锁// 临界区：操作共享资源std::cout<<"线程1执行临界区"<<std::endl;m2.unlock();m1.unlock();}}// 线程2：先锁m2，再锁m1voidthread2Func(){for(inti=0;i<1000;++i){m2.lock();m1.lock();// 可能被线程1的m1.lock()阻塞，导致死锁// 临界区：操作共享资源std::cout<<"线程2执行临界区"<<std::endl;m1.unlock();m2.unlock();}}intmain(){std::threadt1(thread1Func);std::threadt2(thread2Func);t1.join();t2.join();return0;}

上述代码运行后，大概率会出现死锁，程序卡死。

4.std::lock解决死锁（推荐用法）

使用std::lock同时锁定多个互斥锁，配合std::unique_lock的std::adopt_lock参数（表示锁已被手动锁定，由unique_lock接管生命周期）：

#include<iostream>#include<thread>#include<mutex>std::mutex m1,m2;// 线程1：用std::lock同时锁m1和m2voidthread1Func(){for(inti=0;i<1000;++i){// 步骤1：创建unique_lock，延迟加锁std::unique_lock<std::mutex>lock1(m1,std::defer_lock);std::unique_lock<std::mutex>lock2(m2,std::defer_lock);// 步骤2：同时锁定m1和m2，避免死锁std::lock(lock1,lock2);// 也可以写std::lock(m1, m2)// 临界区：操作共享资源std::cout<<"线程1执行临界区"<<std::endl;// 步骤3：析构时自动解锁（无需手动unlock）}}// 线程2：同样用std::lock同时锁m1和m2（顺序无关）voidthread2Func(){for(inti=0;i<1000;++i){std::unique_lock<std::mutex>lock1(m1,std::defer_lock);std::unique_lock<std::mutex>lock2(m2,std::defer_lock);std::lock(lock2,lock1);// 顺序与线程1相反，仍不会死锁// 临界区：操作共享资源std::cout<<"线程2执行临界区"<<std::endl;}}intmain(){std::threadt1(thread1Func);std::threadt2(thread2Func);t1.join();t2.join();return0;}

说明：

• std::defer_lock：表示unique_lock构造时不自动加锁；
• std::lock(lock1, lock2)：同时锁定两个unique_lock关联的互斥锁（也可以直接传m1, m2）；
• std::adopt_lock（可选）：如果直接调用std::lock(m1, m2)（手动锁定），则需要用std::unique_lock<std::mutex> lock1(m1, std::adopt_lock)表示接管已锁定的锁。

三、总结与注意事项

1. 核心总结

2. 关键注意事项

1. 避免直接使用std::mutex的lock()/unlock()：优先使用std::lock_guard或std::unique_lock，利用RAII避免死锁。
2. std::mutex是非递归锁：同一线程不能多次锁定同一个std::mutex（会死锁），如果需要递归锁，使用std::recursive_mutex（但递归锁易导致逻辑混乱，尽量避免使用）。
3. 临界区尽可能小：只在必要的代码段加锁，减少线程阻塞时间，提升并发性能。
4. 多锁场景必须用std::lock：不要手动依次加锁，否则极易导致死锁。
5. 编译时链接线程库：使用C++多线程时，GCC/Clang需加-pthread参数，MSVC需启用线程支持。

3. 编译运行命令（GCC）

# 编译示例代码g++ -std=c++11 mutex_lock_demo.cpp -o mutex_lock_demo -pthread# 运行./mutex_lock_demo