C++ 多线程：互斥量(mutex)

最新推荐文章于 2024-09-06 06:45:00 发布
最新推荐文章于 2024-09-06 06:45:00 发布
阅读量2.8k 收藏 20
点赞数 8
分类专栏： CPP 文章标签： c++ 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iuices/article/details/123099747
版权

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

构造函数

mutex();
mutex(const mutex&) = delete;

从上面的构造函数可以看出，std::mutex不允许拷贝构造，当然也不允许move，最初构造的mutex对象是处于未锁定状态的，若构造不成功会抛出 std::system_error 。

析构函数

~mutex();

销毁互斥。若互斥被线程占有，或在占有mutex时线程被终止，则会产生未定义行为。

lock

void lock();

锁定互斥，调用线程将锁住该互斥量。线程调用该函数会发生下面 3 种情况：

  • 如果该互斥量当前没有被其他线程锁住，则调用线程将该互斥量锁住，直到调用unlock之前，该线程一直拥有该锁。
  • 如果当前互斥量被其他线程锁住，则当前的调用线程被阻塞住，指导其他线程unlock该互斥量。
  • 如果当前互斥量被当前调用线程锁住，则会产生死锁(deadlock)。

try_lock

bool try_lock();

尝试锁住互斥量，立即返回。成功获得锁时返回 true ，否则返回 false。
如果互斥量被其他线程占有，则当前线程也不会被阻塞。线程调用该函数也会出现下面 3 种情况：

  • 如果当前互斥量没有被其他线程占有，则该线程锁住互斥量，直到该线程调用 unlock 释放互斥量。
  • 如果当前互斥量被其他线程锁住，则当前调用线程返回 false，而并不会被阻塞掉。
  • 如果当前互斥量被当前调用线程锁住，则会产生死锁(deadlock)。

unlock

void unlock();

解锁互斥。互斥量必须为当前执行线程所锁定(以及调用lock)，否则行为未定义。

看下面一个简单的例子实现两个线程竞争全局变量g_num对其进行写操作，然后打印输出：

#include <iostream>
#include <chrono>  // std::chrono
#include <thread>  // std::thread
#include <mutex>  // std::mutex
 
int g_num = 0;  // 为 g_num_mutex 所保护
std::mutex g_num_mutex;
 
void slow_increment(int id) 
{
    for (int i = 0; i < 3; ++i) {
        g_num_mutex.lock();
        ++g_num;
        std::cout << "th" << id << " => " << g_num << '\n';
        g_num_mutex.unlock();
 
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
}  
 
int main()
{
    std::thread t1(slow_increment, 0);
    std::thread t2(slow_increment, 1);
    t1.join();
    t2.join();
}

加了互斥量实现有序的写操作并输出：

th0 => 1
th1 => 2
th0 => 3
th1 => 4
th1 => 5
th0 => 6

如果不增加mutex包含，可能输出就不是有序的打印1到6，如下：

thth01 => 2 => 2

th1 => 3
th0 => 4
th0 => 5
th1 => 6

std::recursive_mutex

如上面所说的，如果使用std::mutex，如果一个线程在执行中需要再次获得锁，会出现死锁现象。要避免这种情况下就需要使用递归式互斥量std::recursive_mutex，它不会产生上述的死锁问题，可以理解为同一个线程多次获得锁“仅仅增加锁的计数”，同时，必须要确保unlock和lock的次数相同，其他线程才可能取得这个mutex。它的接口与std::mutex的完全一样，用法也基本相同除了可重入(必须同一线程才可重入，其他线程需等待），看下面的例子：

#include <iostream>
#include <thread>
#include <mutex>
 
class X {
    std::recursive_mutex m;
    std::string shared;
  public:
    void fun1() {
      m.lock();
      shared = "fun1";
      std::cout << "in fun1, shared variable is now " << shared << '\n';
      m.unlock();
    }
    void fun2() {
      m.lock();
      shared = "fun2";
      std::cout << "in fun2, shared variable is now " << shared << '\n';
      fun3(); // 递归锁在此处变得有用
      std::cout << "back in fun2, shared variable is " << shared << '\n';
      m.unlock();
    }
    void fun3() {
      m.lock();
      shared = "fun3";
      std::cout << "in fun3, shared variable is now " << shared << '\n';
      m.unlock();
    }
};
 
int main() 
{
    X x;
    std::thread t1(&X::fun1, &x);
    std::thread t2(&X::fun2, &x);
    t1.join();
    t2.join();
}

在fun2中调用fun3，而fun3中还使用了lock和unlock，只有递归式互斥量才能满足当前情况。

输出如下：

in fun1, shared variable is now fun1
in fun2, shared variable is now fun2
in fun3, shared variable is now fun3
back in fun2, shared variable is fun3

std::time_mutex

timed_mutex增加了带时限的try_lock。即try_lock_for和try_lock_until。

try_lock_for
尝试锁互斥。阻塞直到超过指定的 timeout_duration 或得到锁，取决于何者先到来。成功获得锁时返回 true，否则返回false 。函数原型如下：

template< class Rep, class Period >
bool try_lock_for( const std::chrono::duration<Rep,Period>& timeout_duration );

若timeout_duration小于或等于timeout_duration.zero()，则函数表现同try_lock()。由于调度或资源争议延迟，此函数可能阻塞长于timeout_duration。

#include <iostream>
#include <sstream>
#include <thread>
#include <chrono>
#include <vector>
#include <mutex>

std::timed_mutex mutex;

using namespace std::chrono_literals;

void do_work(int id) {
  std::ostringstream stream;
  for (int i = 0; i < 3; ++i) {
    if (mutex.try_lock_for(100ms)) {
      stream << "success ";
      std::this_thread::sleep_for(100ms);
      mutex.unlock();
    } else {
      stream << "failed ";
    }
    std::this_thread::sleep_for(100ms);
  }

  std::cout << "[" << id << "] " << stream.str() << std::endl;
}

int main() {
  // try_lock_for
  std::vector<std::thread> threads;
  for (int i = 0; i < 4; ++i) {
    threads.emplace_back(do_work, i);
  }

  for (auto& t : threads) {
    t.join();
  }
}


[3] failed success failed 
[0] success failed success 
[2] failed failed failed 
[1] success success success

try_lock_until
也是尝试锁互斥。阻塞直至抵达指定的timeout_time或得到锁，取决于何者先到来。成功获得锁时返回 true，否则返回false。timeout_time与上面的timeout_duration不一样，timeout_duration表示一段时间，比如1秒，5秒或者10分钟，而timeout_time表示一个时间点，比如说要等到8点30分或10点24分才超时。

使用倾向于timeout_time的时钟，这表示时钟调节有影响。从而阻塞的最大时长可能小于但不会大于在调用时的 timeout_time - Clock::now() ，依赖于调整的方向。由于调度或资源争议延迟，函数亦可能阻塞长于抵达timeout_time之后。同try_lock()，允许此函数虚假地失败并返回false，即使在 timeout_time 前的某点任何线程都不锁定互斥。函数原型如下：

template< class Clock, class Duration >
bool try_lock_until( const std::chrono::time_point<Clock,Duration>& timeout_time);

看下面的例子：

#include <iostream>
#include <sstream>
#include <thread>
#include <chrono>
#include <vector>
#include <mutex>

std::timed_mutex mutex;
using namespace std::chrono;

void do_work() {
    mutex.lock();
    std::cout << "thread 1, sleeping..." << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(4));
    mutex.unlock();
}
 
void do_work2() {
    auto now = std::chrono::steady_clock::now();
    if (mutex.try_lock_until(now + 5s)) {
        auto end = steady_clock::now();
        std::cout << "try_lock_until success, ";
        std::cout << "time use: " << duration_cast<milliseconds>(end-now).count() 
            << "ms." << std::endl;
        mutex.unlock();
    } else {
        auto end = steady_clock::now();
        std::cout << "try_lock_until failed, ";
        std::cout << "time use: " << duration_cast<milliseconds>(end-now).count() 
            << "ms." << std::endl;
    }
}

int main() {
  // try_lock_until
  std::thread t1(do_work);
  std::thread t2(do_work2);
  t1.join();
  t2.join();
}

获得锁时输出：

thread 1, sleeping...
try_lock_until success, time use: 4000ms.

修改一下，让其超时，输出：

thread 1, sleeping...
try_lock_until failed, time use: 5000ms.

std::recursive_timed_mutex

以类似std::recursive_mutex的方式，recursive_timed_mutex提供排他性递归锁，同线程可以重复获得锁。另外，recursive_timed_mutex通过try_lock_for与try_lock_until方法，提供带时限地获得recursive_timed_mutex锁，类似std::time_mutex。

std::shared_mutex

c++ 17 新出的具有独占模式和共享模式的锁。共享模式能够被std::shared_lock(这个后面再详细将)占有。

std::shared_mutex 是读写锁，把对共享资源的访问者划分成读者和写者，读者只对共享资源进行读访问，写者则需要对共享资源进行写操作。

它提供两种访问权限的控制：共享性（shared）和排他性（exclusive）。通过lock/try_lock获取排他性访问权限(仅有一个线程能占有互斥)，通过lock_shared/try_lock_shared获取共享性访问权限(多个线程能共享同一互斥的所有权)。这样的设置对于区分不同线程的读写操作特别有用。

std::shared_mutex通常用于多个读线程能同时访问同一资源而不导致数据竞争，但只有一个写线程能访问的情形。比如，有多个线程调用shared_mutex.lock_shared()，多个线程都可以获得锁，可以同时读共享数据，如果此时有一个写线程调用 shared_mutex.lock()，则读线程均会等待该写线程调用shared_mutex.unlock()。对于C++11 没有提供读写锁，可使用 boost::shared_mutex。

std::shared_mutex新增加的三个接口：

void lock_shared();
bool try_lock_shared();
void unlock_shared();

一个简单例子如下：

#include <iostream>
#include <mutex>  // 对于 std::unique_lock
#include <shared_mutex>
#include <thread>
 
class ThreadSafeCounter {
 public:
  ThreadSafeCounter() = default;
 
  // 多个线程/读者能同时读计数器的值。
  unsigned int get() const {
    std::shared_lock<std::shared_mutex> lock(mutex_);
    return value_;
  }
 
  // 只有一个线程/写者能增加/写线程的值。
  void increment() {
    std::unique_lock<std::shared_mutex> lock(mutex_);
    value_++;
  }
  
  // 只有一个线程/写者能重置/写线程的值。
  void reset() {
    std::unique_lock<std::shared_mutex> lock(mutex_);
    value_ = 0;
  }
 
 private:
  mutable std::shared_mutex mutex_;
  unsigned int value_ = 0;
};
 
int main() {
  ThreadSafeCounter counter;
 
  auto increment_and_print = [&counter]() {
    for (int i = 0; i < 3; i++) {
      counter.increment();
      std::cout << std::this_thread::get_id() << ' ' << counter.get() << '\n';
 
      // 注意：写入 std::cout 实际上也要由另一互斥同步。省略它以保持示例简洁。
    }
  };
 
  std::thread thread1(increment_and_print);
  std::thread thread2(increment_and_print);
 
  thread1.join();
  thread2.join();
}

// 解释：下列输出在单核机器上生成。 thread1 开始时，它首次进入循环并调用 increment() ，
// 随后调用 get() 。然而，在它能打印返回值到 std::cout 前，调度器将 thread1 置于休眠
// 并唤醒 thread2 ，它显然有足够时间一次运行全部三个循环迭代。再回到 thread1 ，它仍在首个
// 循环迭代中，它最终打印其局部的计数器副本的值，即 1 到 std::cout ，再运行剩下二个循环。
// 多核机器上，没有线程被置于休眠，且输出更可能为递增顺序。

可能的输出：

139847802500864 1
139847802500864 2
139847802500864 3
139847794108160 4
139847794108160 5
139847794108160 6

std::shared_timed_mutex

它是从C++14 才提供的限时读写锁：std::shared_timed_mutex。
对比std::shared_mutex新增下面两个接口，其实这两个接口与上面讲到的std::timed_mutex的try_lock_for和try_lock_until类似。都是限时等待锁。只不过是增加了共享属性。

template< class Rep, class Period >
bool try_lock_shared_for( const std::chrono::duration<Rep,Period>& timeout_duration );

template< class Clock, class Duration >
bool try_lock_shared_until( const std::chrono::time_point<Clock,Duration>& timeout_time );

总结

由于它们额外的复杂性，读/写锁std::shared_mutex ， std::shared_timed_mutex优于普通锁std::mutex，std::timed_mutex的情况比较少见。但是理论上确实存在。

如果在频繁但短暂的读取操作场景，读/写互斥不会提高性能。它更适合于读取操作频繁且耗时的场景。当读操作只是在内存数据结构中查找时，很可能简单的锁会胜过读/写锁。

如果读取操作的开销非常大，并且您可以并行处理许多操作，那么在某些时候增加读写比率应该会导致读取/写入器性能优于排他锁的情况。断点在哪里取决于实际工作量。

另请注意，在持有锁的同时执行耗时的操作通常是一个坏兆头。可能有更好的方法来解决问题，然后使用读/写锁。

还要注意，在使用mutex时，要时刻注意lock()与unlock()的加锁临界区的范围，不能太大也不能太小，太大了会导致程序运行效率低下，大小了则不能满足我们对程序的控制。并且我们在加锁之后要及时解锁，否则会造成死锁，lock()与unlock()应该是成对出现。

参考：
https://www.apiref.com/cpp-zh/cpp/thread.html

胖小迪
关注
专栏目录
Windows C++ 多线程：使用互斥量 Mutex 的实现
m0_47037246的博客
08-27 290
在上面的代码中，我们使用了 WaitForSingleObject 函数来等待获取锁，它的第一个参数为互斥量对象，第二个参数表示等待的时间，我们这里将其设为 INFINITE 表示无限等待。如果当前互斥量对象已被其他线程锁定，则当前线程将进入等待状态，直到互斥量对象可用，并被当前线程成功锁定。它提供了一种排他的方式，即同一时间只能有一个线程访问被保护的共享资源，其他线程需要等待当前线程释放锁后才能访问。通过使用 Mutex，我们可以保证多个线程访问共享资源的正确性和一致性，并且避免了竞态条件等问题的出现。
Windows C++ 多线程：使用互斥量Mutex
pytorchCode的博客
08-29 210
在多线程中对临界区进行保护，以避免线程之间的竞态条件，常使用的方法是使用互斥量 Mutex。本文将介绍在 C++ 中使用互斥量 Mutex 的方法，并提供相应的代码实例。在以上代码中，WaitForSingleObject 函数用于等待获取互斥量 Mutex，直到获取成功为止；这里使用了 Windows API 函数 CreateMutex 来创建一个互斥量 Mutex，并将其句柄保存在变量 hMutex 中。Windows C++ 多线程：使用互斥量Mutex。
C++ 多线程中互斥信号量的使用
yangkunqiankun的博客
07-09 3365
互斥信号量mutex 互斥量使用示例互斥信号量mutex互斥信号量是一种内核对象，它用来保证一个线程独占一个资源的访问。在使用互斥信号量的时候，有四个主要的函数： （1）CreateMutex，创建互斥信号量。函数原型如下所示：HANDLE CreateMutex( LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInitialOwner,
C++多线程之互斥量
qq_39515533的博客
08-07 791
 在学习互斥量之前，我们要清楚什么情况下需要使用互斥量，第一个例子中有一段共享数据g_v，在main()函数中创建了10个线程，这10个线程的入口函数均为myprint()，在函数中打印出共享数据，代码如下： #include<map> #include<iostream> #include<thread> #include<list> #inclu...
使用互斥锁解决多线程竞态条件：C++实战指南
最新发布
windowshht的博客
09-06 519
竞态条件是指多个线程在没有正确同步的情况下同时访问和修改共享数据，导致程序行为不可预测。竞态条件通常会导致数据损坏、程序崩溃或其他意外行为。互斥锁是多线程编程中的重要同步机制，通过合理使用互斥锁，可以有效地解决多线程竞态条件问题。本文详细介绍了如何在C++中使用互斥锁实现线程安全的计数器，并提供了完整的代码示例和详细的解释。希望这篇文章能帮助你更好地理解和掌握互斥锁技术。如果你有任何问题或需要进一步的解释，欢迎在评论区留言。祝你在多线程编程的学习和实践中取得好成绩！
C++多线程——互斥量
princeteng's blogs
01-11 2880
并发的优点 分离关注点 通过将相关的代码与无关的代码分离，可以使程序更容易理解和测试，从而减少出错的可能性 更好的性能 将一个单个任务分成几部分，且各自并行运行，从而降低总运行时间。这就是任务并行（task parallelism）。 为性能而使用并发就像所有其他优化策略一样:它拥有大幅度提高应用性能的潜力，但它也可能使代码复杂化，使其更难理解，并更容易出错。 并发的缺点 线程是有限...
C++ 多线程编程 互斥量
x-2010的笔记
12-04 736
Win10下多线程中访问公共变量时，可使用mutex类来做，头文件为mutex，实例（VS2013）：
C/C++多线程编程：互斥量
m0_61243666的博客
06-27 618
UNIX、Liunx环境下C/C++多线程编程：互斥锁。posix标准。C库编程适用于嵌入式开发、C/C++服务器开发。
C++——互斥量
yi_chengyu的博客
12-24 2419
文章目录一、基本知识二、独占互斥量mutex1.mutex的介绍2.mutex的成员函数3.实例演示三、lock_guard和unique_lock的使用和区别四、递归互斥量recursive_mutex1.基本知识2.演示示例五、带超时的互斥量std::timed_mutex和std::recursive_timed_mutex 一、基本知识 C++11提供如下4种语义的互斥量（mutex） std::mutex，独占的互斥量，不能递归使用。 std::time_mutex，带超时的独占互斥量，不能递.
【并发编程九】c++线程同步——互斥（mutex）
junxuezheng的博客
01-03 1698
简介：本篇文章，我们详细的介绍下c++标准库提供的线程同步方法中的第一个——互斥（mutex）。
C++11多线程之std::mutex互斥锁
十三阿哥的博客
08-11 839
【代码】C++11多线程之std::mutex互斥锁。
C++11 并发指南之std::mutex详解
12-20
2. **std::recursive_mutex**：递归互斥量允许同一线程多次锁定，每次解锁会减少锁定计数，直到计数为零才真正释放锁。 3. **std::timed_mutex**：这种类型的互斥量允许在等待锁时设置一个超时时间，如果在指定时间...
C++——多线程（互斥量概念及用法、死锁及解决方式）
小白一直白
04-20 796
目录引入互斥量背景互斥量（mutex）如何保证lock和unlock成对出现——lock_guard类模板死锁演示死锁解决死锁std::lock()函数模板std::lock_guard函数模板 引入互斥量背景 我们知道，线程之间是共享数据内存的，那么一块内存如果在同一时刻同时进行读取和修改，就会造成一个十分混乱的局面，到时系统崩溃。 如下面一段代码：两个线程分别在共享数据vector容器内进行存取操作，一旦存取在同一个内存地址进行，就可能出现异常。 #include <iostream&gt
C++并发与多线程编程--互斥量用法
locahuang的博客
07-23 202
1、互斥量概念 互斥量是个类对象。 理解成一把锁，多个线程尝试使用lock()成员函数来加锁，只有一个线程能锁定成功。 如果没有锁定成功，那么流程卡在lock()这里不断的尝试去锁住这把锁头。 互斥量使用要小心，保护数据不多也不少，少了，没达到保护的效果，多了，影响效率。 2、互斥量用法 （1）lock()，unlock() lock() 和unlock()要成对使用，有lock()，必然有unlock()。 不应该也不允许调用了一次lock()，却调用多次unlock()。 std::mutex ..
[C++]C++ 多线程互斥量mutex与锁lock
FL1768317420的博客
03-16 932
unique_lock想比于lock_guard，都是基于RAII思想的，也支持std::lock_guard的功能，但是区别在于它提供更多的成员函数，比如：lock(),unlock()使用更加灵活，并且可以和condiction_variable一起使用控制线程同步。lock_guard构造函数执行了mutex::lock()，在作用域结束时，自动调用析构函数，执行mutex::unlock()adopt_guard为结构体对象，起一个标记作用，表示这个互斥量已经lock()，不需要在lock()。
c++多线程互斥量（mute）与原子变量（atomic）
weixin_43482965的博客
08-21 1265
c++多线程互斥量（mute）与原子变量（atomic）
c++多线程（二）互斥量
天涯遍地是小草的博客
08-15 863
一、简介 互斥量是一种同步原语,是一种线程同步的手段,用来保护多线程同时访问的共享数据. std::mutex: 独占的互斥量,不能递归使用. std::timed_mutex: 带超时的独占互斥量,不能递归使用. std::recursive_mutex: 递归互斥量,不带超时功能. std::recursive_timed_mutex: 带超时的递归互斥量. 这些互斥量的基本接口十分...
C++多线程中的互斥量和互斥锁
努力的八戒
07-17 554
C++多线程竞争时经常用到互斥量用std::mutex，它可以单独使用，也可以和互斥锁在一起使用。 std::mutex单独使用的话就lock()加锁，用unlock()解锁。 为了方便的话可以用用互斥锁lock_guard，lock_guard会在创建时自动加锁，并且在作用域结束时自动析构释放锁。 lock_guard只能在创建时加锁，在作用域结束时释放锁，如果想中间释放锁呢，此时就需要加强版的unique_lock了，unique_lock可以随时加锁和解锁，并且可以和条件变量 std::cond
C++线程之使用互斥量
Stay hungry, Stay foolish
10-13 479
保护共享数据结构的最基本的方式，就是使用C++标准库提供的互斥量。访问共享数据前，将数据锁住，在访问结束后，再将数据解锁。线程库需要保证，当线程使用互斥量锁住共享数据时，其他的线程都必须等到之前那个线程对数据进行解锁后，才能进行访问数据。互斥量是C++保护数据最通用的机制，但也需要编排代码来保护数据的正确性，并避免接口间的条件竞争也非常重要。不过，互斥量也会造成死锁，或对数据保护的太多(或太少)。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值