正确使用std::mutex和std::lock_guard是C++多线程同步的基础，通过RAII机制避免死锁，确保共享数据安全。
在C++多线程编程中，std::mutex 是最常用的同步机制之一，用于保护共享数据，防止多个线程同时访问造成数据竞争。正确使用互斥锁是编写安全多线程程序的基础。
1. 包含头文件并声明互斥锁
使用互斥锁前，需要包含 <mutex> 头文件，并定义一个 std::mutex 对象：
#include <iostream> #include <thread> #include <mutex> std::mutex mtx; // 全局互斥锁 int shared_data = 0;
这个互斥锁可以是全局变量、类成员变量，或局部静态变量，取决于共享数据的范围。
2. 使用 lock() 和 unlock() 手动加锁解锁
最基本的用法是在线程函数中调用 lock() 加锁，操作完共享资源后调用 unlock() 解锁：
立即学习“C++免费学习笔记（深入）”；
void unsafe_increment() {
mtx.lock(); // 加锁
++shared_data; // 操作共享数据
std::cout << "Value: " << shared_data << "\n";
mtx.unlock(); // 解锁
}
这种方式容易出错，比如忘记 unlock() 或者在 unlock 前发生异常，会导致死锁。因此不推荐直接使用。
3. 推荐方式：使用 std::lock_guard 自动管理锁
std::lock_guard 是RAII（资源获取即初始化）风格的锁管理类，构造时自动加锁，析构时自动解锁：
void safe_increment() {
std::lock_guard<std::mutex> guard(mtx);
++shared_data;
std::cout << "Value: " << shared_data << "\n";
// 离开作用域时自动释放锁
}
- 代码更安全，即使抛出异常也能保证解锁
- 写法简洁，避免人为疏漏
- 是实际开发中最常见的用法
4. 更灵活的选择：std::unique_lock
如果需要延迟加锁、条件变量配合或手动控制解锁时机，可以使用 std::unique_lock：
std::unique_lock<std::mutex> ulock(mtx, std::defer_lock); // do something else... ulock.lock(); // 手动加锁 // 操作共享资源 ulock.unlock(); // 可提前释放 // 其他操作... // 析构时仍会检查是否已解锁
- 支持延迟加锁（std::defer_lock）
- 可转移所有权
- 常与 std::condition_variable 配合使用
5. 实际多线程示例
下面是一个完整的例子，创建多个线程安全地递增共享变量：
#include <iostream>
#include <thread>
#include <mutex>
#include <vector>
std::mutex mtx;
int counter = 0;
void worker(int id) {
for (int i = 0; i < 1000; ++i) {
std::lock_guard<std::mutex> guard(mtx);
++counter;
}
}
int main() {
std::vector<std::thread> threads;
for (int i = 0; i < 10; ++i) {
threads.emplace_back(worker, i);
}
for (auto& t : threads) {
t.join();
}
std::cout << "Final counter value: " << counter << "\n";
return 0;
}
输出结果始终为 10000，说明互斥锁有效防止了数据竞争。
基本上就这些。掌握 mutex 和 lock_guard 的组合使用，就能应对大多数多线程同步场景。关键是避免裸调用 lock/unlock，优先使用 RAII 封装，确保程序健壮性。
