C++- CPP教程

首页 / 教程 / C++ 教程 / C++- CPP教程

C++ 标准库 <mutex>

在多线程编程中，确保数据的一致性和线程安全是至关重要的。

C++ 标准库提供了一套丰富的同步原语，用于控制对共享资源的访问。

C++ 标准库中的 <mutex> 头文件提供了一组工具，用于在多线程程序中实现线程间的同步和互斥。

<mutex> 头文件是 C++11 引入的，它包含了用于互斥锁（mutex）的类和函数。互斥锁是一种同步机制，用于防止多个线程同时访问共享资源。

互斥锁（Mutex）是一个用于控制对共享资源访问的同步原语。当一个线程需要访问共享资源时，它会尝试锁定互斥锁。如果互斥锁已经被其他线程锁定，请求线程将被阻塞，直到互斥锁被释放。

基本语法

在 C++ 中， <mutex> 头文件提供了以下主要类：

  • std::mutex ：基本的互斥锁。
  • std::recursive_mutex ：递归互斥锁，允许同一个线程多次锁定。
  • std::timed_mutex ：具有超时功能的互斥锁。
  • std::recursive_timed_mutex ：具有超时功能的递归互斥锁。

实例

1. 使用 std::mutex

下面是一个简单的示例，展示了如何在 C++ 中使用 std::mutex 来同步对共享资源的访问。

示例代码 
#include <iostream>#include <thread>#include <mutex>std::mutexmtx;// 全局互斥锁intshared_resource=0;voidincrement(){for(inti=0;i<10000;++i){mtx.lock();// 锁定互斥锁++shared_resource;mtx.unlock();// 解锁互斥锁}}intmain(){std::threadt1(increment);std::threadt2(increment);t1.join();t2.join();std::cout<<"Final value of shared_resource: "<<shared_resource<<std::endl;return0;}

输出结果： 


Final value of shared_resource: 20000

2. 使用 std::recursive_mutex

递归互斥锁允许同一个线程多次锁定同一个互斥锁。下面是一个使用 std::recursive_mutex 的示例。

示例代码 
#include <iostream>#include <thread>#include <mutex>std::recursive_mutexrmtx;// 创建一个递归 mutex 对象intshared_resource=0;// 共享资源// 递归函数voidrecursive_increment(intcount){if(count<=0)return;std::lock_guard<std::recursive_mutex>lock(rmtx);// 上锁，确保线程安全++shared_resource;std::cout<<"Incremented shared_resource to "<<shared_resource<<" (count = "<<count<<")"<<std::endl;// 递归调用recursive_increment(count-1);}intmain(){std::threadt1(recursive_increment,3);// 线程 t1 执行 recursive_increment(3)std::threadt2(recursive_increment,3);// 线程 t2 执行 recursive_increment(3)t1.join();// 等待线程 t1 完成t2.join();// 等待线程 t2 完成std::cout<<"Final value of shared_resource: "<<shared_resource<<std::endl;return0;}

输出结果： 

Incremented shared_resource to 1 (count = 3)

Incremented shared_resource to 2 (count = 2)

Incremented shared_resource to 3 (count = 1)

Incremented shared_resource to 4 (count = 0)

Incremented shared_resource to 5 (count = 3)

Incremented shared_resource to 6 (count = 2)

Incremented shared_resource to 7 (count = 1)

Incremented shared_resource to 8 (count = 0)

Final value of shared_resource: 8

代码解析：

  1. 创建 std::recursive_mutex 对象 ： std::recursive_mutex rmtx; 是一个递归互斥量，允许同一线程多次获得锁。

  2. 共享资源 ： int shared_resource = 0; 是多个线程共同访问的资源。

  3. 递归函数 recursive_increment ：

    • 使用 std::lock_guard<std::recursive_mutex> 对 rmtx 上锁。由于使用的是递归互斥量，同一个线程可以多次获得锁。
    • 通过 ++shared_resource 增加共享资源的值。
    • 函数自身递归调用，演示了递归函数在多次锁定的情况下如何安全地工作。

  4. 创建和运行线程 ：

    • std::thread t1(recursive_increment, 3); 和 std::thread t2(recursive_increment, 3); 分别创建两个线程，它们都会执行 recursive_increment(3) 。
    • t1.join() 和 t2.join() 等待两个线程执行完毕。

注意事项

  • 确保在每次锁定互斥锁后，都进行解锁操作，以避免死锁。
  • 使用 std::lock_guard 或 std::unique_lock 可以自动管理互斥锁的锁定和解锁，减少出错的可能性。
  • 避免在持有互斥锁的情况下调用可能抛出异常的函数，因为这可能导致死锁。

<mutex> 是 C++ 标准库中一个非常重要的头文件，它为多线程编程提供了基本的同步机制。通过使用互斥锁，我们可以确保对共享资源的访问是安全的，从而避免数据竞争和不一致的问题。

更多说明

1. std::mutex

提供基本的互斥量，确保在同一时刻只有一个线程可以访问共享资源。

示例代码 
#include <mutex>std::mutexmtx;voidthread_function(){std::lock_guard<std::mutex>lock(mtx);// 访问共享资源}

2. std::recursive_mutex

允许同一线程多次获得锁，而不会造成死锁，这对递归函数特别有用。

示例代码 
#include <mutex>std::recursive_mutexrmtx;voidrecursive_function(intcount){if(count<=0)return;std::lock_guard<std::recursive_mutex>lock(rmtx);// 递归调用recursive_function(count-1);}

3. std::timed_mutex

提供定时的互斥量，可以在尝试获得锁时设置超时时间。

示例代码 
#include <mutex>#include <chrono>std::timed_mutextm;voidtry_lock_for_example(){if(tm.try_lock_for(std::chrono::seconds(1))){// 成功获得锁tm.unlock();}else{// 锁获取失败}}

4. std::recursive_timed_mutex

继承自 std::timed_mutex，允许同一线程多次获得锁，同时支持定时功能。

示例代码 
#include <mutex>#include <chrono>std::recursive_timed_mutexrtm;voidrecursive_timed_function(intcount){if(count<=0)return;if(rtm.try_lock_for(std::chrono::seconds(1))){// 成功获得锁recursive_timed_function(count-1);rtm.unlock();}else{// 锁获取失败}}

5. std::lock_guard

一种自动管理 std::mutex 锁的封装器，使用 RAII 风格，确保在作用域结束时自动释放锁。

示例代码 
#include <mutex>std::mutexmtx;voidfunction(){std::lock_guard<std::mutex>lock(mtx);// 访问共享资源}

6. std::unique_lock

提供比 std::lock_guard 更灵活的锁管理，可以手动释放和重新获得锁，还支持定时锁定。

示例代码 
#include <mutex>#include <chrono>std::mutexmtx;voidfunction(){std::unique_lock<std::mutex>lock(mtx);// 访问共享资源// 可以手动释放锁lock.unlock();// 可以重新获得锁lock.lock();// 可以进行定时锁定if(lock.try_lock_for(std::chrono::seconds(1))){// 成功获得锁}}

7. std::adopt_lock_t

标志类型，用于指定 std::unique_lock 采用已有的锁。

示例代码 
std::mutexmtx;std::unique_lock<std::mutex>lock(mtx, std::adopt_lock);

8. std::defer_lock_t

功能：标志类型，用于延迟锁定，初始化时不锁定。

示例代码 
std::mutexmtx;std::unique_lock<std::mutex>lock(mtx, std::defer_lock);// 可以在之后的某个时刻调用 lock.lock()

9. std::try_to_lock_t

标志类型，用于尝试锁定而不阻塞。

示例代码 
std::mutexmtx1, mtx2;std::unique_lock<std::mutex>lock1(mtx1, std::try_to_lock);std::unique_lock<std::mutex>lock2(mtx2, std::try_to_lock);if(lock1&&lock2){// 成功获得两个锁}