C++ 多线程之互斥量(mutex)详解
作者：胖小迪 发布时间：2023-12-20 18:51:32
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 );
来源：https://blog.csdn.net/iuices/article/details/123099747
0
投稿猜你喜欢
- 一.需求使用JAVA实现单链表，使用单链表检测字符串是否是回文串二.需求分析回文串最重要的就是对称，那么最重要的问题就是找到那个中心，用快指
- 首先是.select在MP查询中，默认查询所有的字段，如果有需要也可以通过select方法进行指定字段。其中要注意的细节：wrapper.s
一、概要我们可以用java实现简单的登录界面。如上效果，直观但也需要一步一步来完成，从界面弹窗的设置，图片的插入，文本框的设置，到登录的按钮- Android 动画实现几种方案在 Android 的 FrameWork 中，为我们提供三种动画的实现方式：逐帧（Frame）动画、视图/
- 有时候在单机部署，或者项目没有在IDea 开发工具中运行（idea可以自动打开tomcat项目），需要项目启动后自动打开浏览器访问项目，配置
- 引言思考：HashTable是线程安全的，为什么不推荐使用？HashTable是一个线程安全的类，它使用synchronized来锁住整张H
- 本文实例讲述了C#实现两个时间相减的方法。分享给大家供大家参考。具体实现方法如下：using System; using Sys
- 给对象按照字符串属性进行排序在java中对象进行排序，排序的属性是string，我们只需要实现Comparator接口，然后实现比较的方式。
- 概述 ScrollView也是一个容器，它是FrameLayout的子类，它的主要作用就是将超出物理屏幕的内容显示
- 一、前言又见面了哈，今天为大家介绍时钟、钟表的实现方法教程。实现的方法有很多，这里只是提供了一个思路，本着抛砖引玉的心态，希望能和大家共同学
- 文件夹，文件这是常见的，怎么创建？要不要先判断是否存在？非常非常基础的知识点using System;using System.Collec
- HashMap 概述HashMap 是通过 put(key,value) 存储，get(key)来获取。当传入 key 时，HashMap
- 下面是我自己收集整理的2017年Java岗位的面试题，可以用它来好好准备面试。一、Java基础1. String类为什么是final的。2.
- 一、背景spring-data-mongo 实现了基于 MongoDB 的 ORM-Mapping 能力，通过一些简单的注解、Query封装
- 程序中的错误分为编译时的错误和运行时的错误。编译时的错误主要是语法错误，比如：句尾没有加分号，括号不匹配，关键字错误等，这类错误比较容易修改
- 一、概述在微服务架构中，我们将系统拆分成了很多服务单元，各单元的应用间通过服务注册与订阅的方式互相依赖。由于每个单元都在不同的进程中运行，依
- 一、Mybatis1、mybatis-config.xml<?xml version="1.0" encoding
- 用来记录自己所用到的知识前两天在做项目的时候发现有时候在访问网络数据的时候由于后台要做的工作较多,给我们返回数据的时间较长,所以老大叫我加了
- 一. 安装依赖包yum install -y wgetyum install -y gcc-c++yum install -y zlib-d
- 在很多web产品中都需要实现在同一时刻，只能允许一个账号同时只能在一个浏览器当中登录。通俗点讲就是当A账号在浏览器1当中登录了，此时在浏览器
