c++ 11 recursive_mutex 递归锁,互斥量(mutex)

(700条消息) c++ 11 recursive_mutex 递归锁_繁星璀璨G的博客-CSDN博客

[C++] - C++11 多线程 - Mutex_std::lock_guard<std::recursive_mutex-CSDN博客

锁定互斥。若另一线程已锁定互斥，则到 lock 的调用将阻塞执行，直至获得锁。

线程可以在递归互斥上重复调用 lock 。在线程调用 unlock 匹配数量次后，所有权才会得到释放。

所有权的最大层数是未指定的。若超出此数，则可能抛 std::system_error 类型异常。

同一互斥上先前的 unlock() 操作同步于（定义于 std::memory_order ）此操作。

参数
 

C++ 多线程：互斥量(mutex)_shared_timed_mutex-CSDN博客

C++ 11中的互斥量，声明在 <mutex> 头文件中，互斥量的使用可以在各种方面，比较常用在对共享数据的读写上，如果有多个线程同时读写一个数据，那么想要保证多线程安全，就必须对共享变量的读写进行保护(上锁)，从而保证线程安全。
互斥量主要有四中类型：

    std::mutex，最基本的 Mutex 类。
    std::recursive_mutex，递归 Mutex 类。
    std::time_mutex，限时 Mutex 类。
    std::recursive_timed_mutex，限时递归 Mutex 类。
    当然C++14和C++17各增加了一个：
    std::shared_timed_mutex，限时读写锁（C++14）
    std::shared_mutex，读写锁（C++17）

std::mutex

std::recursive_mutex 介绍

std::recursive_mutex 与 std::mutex 一样，也是一种可以被上锁的对象，但是和 std::mutex 不同的是，std::recursive_mutex 允许同一个线程对互斥量多次上锁（即递归上锁），来获得对互斥量对象的多层所有权，std::recursive_mutex 释放互斥量时需要调用与该锁层次深度相同次数的 unlock()，可理解为 lock() 次数和 unlock() 次数相同，除此之外，std::recursive_mutex 的特性和 std::mutex 大致相同。

#include <iostream>       // std::cout
#include <thread>         // std::thread
#include <mutex>          // std::mutex
 
class counter
{
public:
    counter() : count(0) { }
 
    int add(int val) {
        std::lock_guard<std::recursive_mutex> lock(mutex);
        count += val;
        return count;
    }   
    int increment() {
        std::lock_guard<std::recursive_mutex> lock(mutex);
        return add(1);
    }
 
private:
    std::recursive_mutex mutex;
    int count;
};
 
counter c;
 
void change_count()
{
    std::cout << "count == " << c.increment() << std::endl;
}
 
int main(int, char*[])
{
 
    std::thread threads[10];
    // spawn 10 threads:
    for (int i=0; i<10; ++i)
        threads[i] = std::thread(change_count);
 
    for (auto& th : threads) th.join();
   
    return 0;
}