c++中mutex(互斥锁)怎么使用_c++多线程互斥锁用法详解-C++-PHP中文网

正确使用std::mutex和std::lock_guard是C++多线程同步的基础，通过RAII机制避免死锁，确保共享数据安全。

c++中mutex(互斥锁)怎么使用_c++多线程互斥锁用法详解

在C++多线程编程中，std::mutex 是最常用的同步机制之一，用于保护共享数据，防止多个线程同时访问造成数据竞争。正确使用互斥锁是编写安全多线程程序的基础。

1. 包含头文件并声明互斥锁

使用互斥锁前，需要包含头文件，并定义一个 std::mutex 对象：

#include 
#include 
#include 

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 前发生异常，会导致死锁。因此不推荐直接使用。

Magic Write

Canva旗下AI文案生成器

下载

3. 推荐方式：使用 std::lock_guard 自动管理锁

std::lock_guard 是RAII（资源获取即初始化）风格的锁管理类，构造时自动加锁，析构时自动解锁：

void safe_increment() {
    std::lock_guard guard(mtx);
    ++shared_data;
    std::cout << "Value: " << shared_data << "\n";
    // 离开作用域时自动释放锁
}

代码更安全，即使抛出异常也能保证解锁
写法简洁，避免人为疏漏
是实际开发中最常见的用法

4. 更灵活的选择：std::unique_lock

如果需要延迟加锁、条件变量配合或手动控制解锁时机，可以使用 std::unique_lock：

std::unique_lock ulock(mtx, std::defer_lock);
// do something else...
ulock.lock();   // 手动加锁
// 操作共享资源
ulock.unlock(); // 可提前释放
// 其他操作...
// 析构时仍会检查是否已解锁

支持延迟加锁（std::defer_lock）
可转移所有权
常与 std::condition_variable 配合使用

5. 实际多线程示例

下面是一个完整的例子，创建多个线程安全地递增共享变量：

#include 
#include 
#include 
#include 

std::mutex mtx;
int counter = 0;

void worker(int id) {
    for (int i = 0; i < 1000; ++i) {
        std::lock_guard guard(mtx);
        ++counter;
    }
}

int main() {
    std::vector 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 封装，确保程序健壮性。