C++11互斥量mutex使用详解

最新推荐文章于 2024-11-02 20:20:37 发布
最新推荐文章于 2024-11-02 20:20:37 发布
阅读量56 收藏
点赞数
文章标签： c++ 开发语言
原文链接：https://zhuanlan.zhihu.com/p/598993031
版权
本文介绍了C++11中的四种互斥量类型（std::mutex,std::time_mutex,std::recursive_mutex,std::recursive_timed_mutex），重点讲解了std::mutex的基本原理和使用，以及lock_guard和unique_lock的使用方法，强调了避免死锁和合理使用递归锁的重要性。
摘要由CSDN通过智能技术生成

一、前言

mutex又称互斥量，C++ 11中与 mutex相关的类（包括锁类型）和函数都声明在#include<mutex>头文件中，所以如果你需要使用 std::mutex，就必须包含#include<mutex>头文件。

C++11提供如下4种语义的互斥量（mutex） ：

  1. std::mutex，独占的互斥量，不能递归使用。
  2. std::time_mutex，带超时的独占互斥量，不能递归使用。
  3. std::recursive_mutex，递归互斥量，不带超时功能。
  4. std::recursive_timed_mutex，带超时的递归互斥量。

二、独占互斥量std::mutex

std::mutex 是C++11 中最基本的互斥量，std::mutex 对象提供了独占所有权的特性，即不支持递归地对 std::mutex 对象上锁，而 std::recursive_lock 则可以递归地对互斥量对象上锁。

2.1、std::mutex 的成员函数

  1. 构造函数，std::mutex不允许拷贝构造，也不允许 move 拷贝，最初产生的 mutex 对象是处于 unlocked 状态的。
  2. lock()，调用线程将锁住该互斥量。线程调用该函数会发生下面 3 种情况：(1). 如果该互斥量当前没 有被锁住，则调用线程将该互斥量锁住，直到调用 unlock之前，该线程一直拥有该锁。(2). 如果当 前互斥量被其他线程锁住，则当前的调用线程被阻塞住。(3). 如果当前互斥量被当前调用线程锁 住，则会产生死锁(deadlock)。
  3. unlock()， 解锁，释放对互斥量的所有权。
  4. try_lock()，尝试锁住互斥量，如果互斥量被其他线程占有，则当前线程也不会被阻塞。线程调用该 函数也会出现下面 3 种情况，(1). 如果当前互斥量没有被其他线程占有，则该线程锁住互斥量，直 到该线程调用 unlock 释放互斥量。(2). 如果当前互斥量被其他线程锁住，则当前调用线程返回 false，而并不会被阻塞掉。(3). 如果当前互斥量被当前调用线程锁住，则会产生死锁(deadlock)。

2.2、使用示例

#include <mutex>
#include <iostream>
#include <thread>

#define TRY_MUTEX       0
#define MY_MUTEX        1

volatile int counter(0); // non-atomic counter

std::mutex mtx;

void increases10k()
{
        for(int i=0;i<10000;i++)
        {
#if TRY_MUTEX
                if(mtx.try_lock())
                {
                        ++counter;
                        mtx.unlock();
                }
#elif MY_MUTEX
                mtx.lock();
                ++counter;
                mtx.unlock();
#endif
        }

}

int main(int argc,char **argv)
{
        std::thread threads[10];
        for(int i=0;i<10;i++)
        {
                threads[i]=std::thread(increases10k);
        }
        for(auto& th:threads)
                th.join();
        std::cout << " successful increases of the counter " << counter <<std::endl;
        return 0;

}

编译：

 g++ -o mutex_test mutex_test.c -std=c++11 -lpthread

执行效果：

# try_lock
$ ./mutex_test 
 successful increases of the counter 53612
# lock
$ vim mutex_test.c
 successful increases of the counter 100000

可以看到try_lock只是尝试加锁，不管是否成功都不阻塞，而lock如果加锁失败会一直阻塞直到加锁成功。

三、lock_guard和unique_lock的使用和区别

相对于手动lock和unlock，可以使用RAII(通过类的构造析构)来实现更好的编码方式。 RAII：也称为“资源获取就是初始化”，是c++等编程语言常用的管理资源、避免内存泄露的方法。它保证 在任何情况下，使用对象时先构造对象，最后析构对象。

3.1、unique_lock和lock_guard的使用

#include <iostream>
#include <thread>
#include <mutex>
#include <stdexcept>

std::mutex mtx;

void print_event(int x)
{
        if(x%2==0)
                std::cout << x << " is even\n";
        else
                throw (std::logic_error("not even"));

}

void print_thread_id(int id)
{
        try{
                std::unique_lock<std::mutex> lck(mtx);
                print_event(id);
        }
        catch(std::logic_error&)
        {
                std::cout << "[exception caught]\n";
        }
}

int main(int argc,char **argv)
{
        std::thread threads[10];
        for(int i=0;i<10;i++)
        {
                threads[i]=std::thread(print_thread_id,i+1);
        }
        for (auto& th : threads) th.join();
        return 0;

}

编译和执行：

$ g++ -o mutex_test lock_test.cc -std=c++11 -lpthread
$ ./mutex_test 
[exception caught]
6 is even
[exception caught]
4 is even
[exception caught]
2 is even
[exception caught]
8 is even
[exception caught]
10 is even

这里的unique_lock换成lock_guard是一样的。

3.2、unique_lock和lock_guard的区别

  1. unique_lock与lock_guard都能实现自动加锁和解锁，但是前者更加灵活，能实现更多的功能。
  2. unique_lock可以进行临时解锁和再上锁，如在构造对象之后使用lck.unlock()就可以进行解锁， lck.lock()进行上锁，而不必等到析构时自动解锁。lock_guard是不支持手动释放的。
  3. 一般来说，使用unique_lock比较多，除非追求极致的性能才会考虑使用lock_guard。
#include <iostream>
#include <mutex>
#include <thread>
#include <deque>
#include <condition_variable>
#include <unistd.h>

std::deque<int> q;
std::mutex mtx;
std::condition_variable cond;
int count=0;

void func1()
{
        while(true)
        {
                // {
                std::unique_lock<std::mutex> locker(mtx);
                q.push_front(count++);
                locker.unlock();//如果是lock_guard，不支持手动解锁
                cond.notify_one();

                sleep(1);
        }
}

void func2()
{
        while(true)
        {
                std::unique_lock<std::mutex> locker(mtx);
                cond.wait(locker,[](){return !q.empty();});
                auto data=q.back();
                q.pop_back();
                std::cout << "thread2 get value form thread1: " << data << std::endl;
        }
}

int main(int atgc,char ** argv)
{
        std::thread t1(func1);
        std::thread t2(func2);
        t1.join();
        t2.join();
        return 0;
}

条件变量的目的就是为了，在没有获得某种提醒时长时间休眠; 如果正常情况下, 我们需要一直循环 (+sleep), 这样的问题就是CPU消耗+时延问题，条件变量的意思是在cond.wait这里一直休眠直到 cond.notify_one唤醒才开始执行下一句; 还有cond.notify_all()接口用于唤醒所有等待的线程。

那么这里为什么必须使用unique_lock呢? 原因是条件变量在wait时会进行unlock再进入休眠, lock_guard并无该操作接口。

  1. wait: 如果线程被唤醒或者超时那么会先进行lock获取锁, 再判断条件(传入的参数)是否成立, 如果成立则 wait函数返回否则释放锁继续休眠。
  2. notify: 进行notify动作并不需要获取锁。
  3. 使用场景：需要结合notify+wait的场景使用unique_lock； 如果只是单纯的互斥使用lock_guard。

3.3、小结

lock_guard：

  1. std::lock_guard 在构造函数中进行加锁，析构函数中进行解锁。
  2. 锁在多线程编程中，使用较多，因此c++11提供了lock_guard模板类；在实际编程中，我们也可以根据自己的场景编写resource_guard RAII类，避免忘掉释放资源。

std::unique_lock：

  1. unique_lock 是通用互斥包装器，允许延迟锁定、锁定的有时限尝试、递归锁定、所有权转移和与 条件变量一同使用。
  2. unique_lock比lock_guard使用更加灵活，功能更加强大。
  3. 使用unique_lock需要付出更多的时间、性能成本。

虽然递归锁能解决这种情况的死锁问题，但是尽量不要使用递归锁，主要原因如下：

  1. 需要用到递归锁的多线程互斥处理本身就是可以简化的，允许递归很容易放纵复杂逻辑的产生，并 且产生晦涩，当要使用递归锁的时候应该重新审视自己的代码是否一定要使用递归锁。
  2. 递归锁比起非递归锁，效率会低。

3. 递归锁虽然允许同一个线程多次获得同一个互斥量，但可重复获得的最大次数并未具体说明，一旦 超过一定的次数，再对lock进行调用就会抛出std::system错误。

四、递归互斥量std::recursive_mutex

递归锁允许同一个线程多次获取该互斥锁，可以用来解决同一线程需要多次获取互斥量时死锁的问题。

死锁示例：

#include <iostream>
#include <thread>
#include <mutex>
struct Complex
{
	std::mutex mutex;
	int i;
	Complex() : i(0){}
	void mul(int x)
	{
		std::lock_guard<std::mutex> lock(mutex);
		i *= x;
	}
	void div(int x)
	{
		std::lock_guard<std::mutex> lock(mutex);
		i /= x;
	}
	void both(int x, int y)
	{
		std::lock_guard<std::mutex> lock(mutex);
		mul(x);
		div(y);
	}
};
int main(void)
{
    Complex complex;
    complex.both(32, 23);
    return 0;
}

运行后出现死锁的情况。在调用both时获取了互斥量，在调用mul时又要获取互斥量，但both的并没有 释放，从而产生死锁。

使用递归锁解决同一个线程的死锁问题：

#include <iostream>
#include <thread>
#include <mutex>
struct Complex
{
	std::recursive_mutex mutex;
	int i;
	Complex() : i(0){}
	void mul(int x)
	{
		std::lock_guard<std::recursive_mutex> lock(mutex);
		i *= x;
	}
	void div(int x)
	{
		std::lock_guard<std::recursive_mutex> lock(mutex);
		i /= x;
	}
	void both(int x, int y)
	{
		std::lock_guard<std::recursive_mutex> lock(mutex);
		mul(x);
		div(y);
	}
};
int main(void)
{
	Complex complex;
	complex.both(32, 23); //因为同一线程可以多次获取同一互斥量，不会发生死锁
	std::cout << "main finish\n";
	return 0;
}

五、带超时的互斥量std::timed_mutex和 std::recursive_timed_mutex

std::timed_mutex比std::mutex多了两个超时获取锁的接口：try_lock_for和try_lock_until。

#include <iostream>
#include <thread>
#include <mutex>
#include <chrono>
std::timed_mutex mutex;
void work()
{
	std::chrono::milliseconds timeout(100);
	while (true)
	{
		if (mutex.try_lock_for(timeout))
		{
			std::cout << std::this_thread::get_id() << ": do work with the mutex" << std::endl;
			std::chrono::milliseconds sleepDuration(250);
			std::this_thread::sleep_for(sleepDuration);
			mutex.unlock();
			std::this_thread::sleep_for(sleepDuration);
		}
		else
		{
			std::cout << std::this_thread::get_id() << ": do work without the mutex" << std::endl;
			std::chrono::milliseconds sleepDuration(100);
			std::this_thread::sleep_for(sleepDuration);
		}
	}
}
int main(void)
{
	std::thread t1(work);
	std::thread t2(work);
	t1.join();
	t2.join();
	std::cout << "main finish\n";
	return 0;
}

总结

互斥锁mutex是为了临界资源的安全访问，C++11的unique_lock和lock_guard可以防止释放锁导致死锁问题。一般工作中比较少用recursive_mutex、std::timed_mutex和 std::recursive_timed_mutex。

az44yao
关注
C++11互斥量mutex详解，再也不怕多线程的数据竞争！
Lion_Long的博客
02-07 6208
mutex又称互斥量，C++ 11中与 mutex相关的类（包括锁类型）和函数都声明在头文件中，所以如果你需要使用 std::mutex，就必须包含头文件。std::mutex，独占的互斥量，不能递归使用。std::time_mutex，带超时的独占互斥量，不能递归使用。std::recursive_mutex，递归互斥量，不带超时功能。std::recursive_timed_mutex，带超时的递归互斥量。
c++11互斥量mutex使用-详解
qq_58806884的博客
05-30 271
mutex又称互斥量，C++ 11中与 mutex相关的类（包括锁类型）和函数都声明在#include头文件中，所以如果你需要使用 std::mutex，就必须包含#include头文件 C++11提供如下4种语义的互斥量（mutex） std::mutex，独占的互斥量，不能递归使用 std::time_mutex带超时的独占互斥量，不能递归使用 std::recursive_mutex递归互斥量，不带超时功能 std::recursive_timed_mu带超的递归互斥量
学懂C++（二十五）：高级教程——深入详解C++ 互斥量（Mutex）在多线程开发中的应用
martian665的专栏
08-13 2020
C++ 互斥量（Mutex）详解
22-C++11互斥量mutex详解，再也不怕多线程的数据竞争！
成长需要沉淀。
03-24 867
互斥锁mutex是为了临界资源的安全访问，C++11的unique_lock和lock_guard可以防止释放锁导致死锁问题。一般工作中比较少用recursive_mutex、std::timed_mutex和 std::recursive_timed_mutex。
【C++多线程编程】（一）之详解互斥量mutex
SensizliK
12-15 688
当一个线程获得互斥量的锁时，其他线程尝试获取锁将会被阻塞，直到持有锁的线程解锁。mutex 是互斥量（Mutex）的缩写，是一种用于多线程编程的同步机制。互斥量是一种用于保护共享资源免受并发访问的机制，以防止多个线程同时修改相同的数据而引发竞态条件（Race Condition）。在多线程环境中，多个线程可能同时访问共享的数据，如果没有适当的同步机制，就会导致数据不一致或产生其他问题。在上述示例中，std::mutex 用于创建一个互斥量，std::lock_guard 则用于在作用域结束时自动释放锁。
【C++多线程编程】（七）之 详解互斥量mutex、上锁lock、解锁unlock
SensizliK
12-23 666
在多线程环境中，多个线程可能同时访问共享的数据，如果没有适当的同步机制，就会导致数据不一致或产生其他问题。）是一种用于实现线程同步的机制，用于保护共享资源免受并发访问的机制，以防止多个线程同时访问或修改相同的数据而引发竞态条件（Race Condition）。当一个线程获得互斥量的锁时，其他线程尝试获取锁将会被阻塞，直到持有锁的线程解锁。上锁是指在访问共享资源之前，通过互斥量锁住资源，确保只有一个线程能够进入临界区，从而防止其他线程同时访问相同的资源。手动解锁，执行一些不需要互斥量保护的代码，最后通过。
c++中互斥锁和条件变量详解
qq_54199569的博客
07-01 1170
线程2执行线程函数funcNotify，首先是获得了锁，然后进行cv.notify_all()操作，唤醒线程1，此时线程1已经苏醒，但是线程1并未向下执行，这是由于虽然线程1苏醒了，还没有获得锁不能向下执行，我们让线程1先执行然后cv_.wait(lck)让线程1释放锁，然后线程2获得了锁，执行了自己的任务，然后释放了锁，可以看到线程1仍然在阻塞，并没有看到wait end字样，但是此时锁是可用的，说明，首先让线程id为2，3，4的线程阻塞，然后线程id为5的线程负责唤醒他们，之后线程2，3，4苏醒；
[c++11]互斥mutex和锁lock笔记
willis
08-17 1034
std::mutex std::recursive_mutex std::unique_lock std::lock_guard static std::mutex m_muxInstance; //作用域 { std::lock_guard<mutex> mlock(m_muxInstance); }
【C++入门到精通】互斥锁 (Mutex) C++11 [ C++入门 ]
Yawesh的博客
12-22 9802
本文介绍了四种C++中常用的互斥锁类型，这些互斥锁类型用于控制多线程对共享资源的访问，避免数据竞争和不确定行为的发生。其中，std::mutex是最基本的互斥锁类型，std::recursive_mutex是可递归的互斥锁类型，std::timed_mutex是限时等待互斥锁类型，std::recursive_timed_mutex是限时等待递归互斥锁类型。使用互斥锁时需注意正确的加锁和解锁操作，选择合适的互斥锁类型应根据具体需求和场景来进行。通过合理使用互斥锁，可以提高多线程程序的性能和并发能力。
C++11 并发指南之std::mutex详解
08-25
C++11 并发指南之std::mutex详解 C++11 中的 std::mutex 是一种基本的互斥量，提供了独占所有权的特性，即不支持递归地对 std::mutex 对象上锁。std::mutex 对象提供了 lock()、unlock() 和 try_lock() 三种成员...
C++11 并发指南之Lock 详解
08-25
std::lock_guard 是 C++11 中定义的模板类，用于管理某个锁（Lock）对象，因此与 Mutex RAII 相关，方便线程对互斥量上锁。在某个 std::lock_guard 对象的声明周期内，它所管理的锁对象会一直保持上锁状态；而 std::...
C++11 并发指南三(mutex详解)
轻口味的专栏
07-21 923
std::mutex，最基本的 Mutex 类。std::recursive_mutex，递归 Mutex 类。std::time_mutex，定时 Mutex 类。std::recursive_timed_mutex，定时递归 Mutex 类。下面以 std::mutex 为例介绍 C++11 中的互斥量用法。
c++中局部变量和全局变量同名，使用::访问全局变量
weixin_43845922的博客
11-02 198
局部变量可以与全局变量同名，在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。于有些编译器而言，在同一个函数内可以定义多个同名的局部变量，比如在两个循环体内都定义一个同名的局。答：能，局部会屏蔽全局。要用全局变量，需要使用”::”部变量，而那个局部变量的作用域就在那个循环体内。局部变量能否和全局变量重名？
Camp4-L0：Linux 前置基础
fangsfdavid的博客
10-29 876
书生浦语大模型实战营第四期：Linux前置基础
【C语言】预处理(预编译)详解(下)（C语言最终篇）
hdxbufcbjuhg的博客
10-29 2226
在编译⼀个程序的时候我们如果要将⼀条语句（⼀组语句）编译或者放弃编译，就可以使用条件编译，比如调试性的代码删掉很浪费，保留又很碍事，我们就可以使用条件编译，在编译的时候不编译这些调试性的代码在这里我们就可以使用一个技巧，在最开头使用#define定义一个符号，如果我们没有注释或者删除这个符号，那么我们就可以编译里面的调试性代码，进行正常调试，如果我们注释或者删除这个符号，那么我们就不编译里面的调试性代码，不影响代码的正常运行。
C++编程法则365天一天一条（344）理解std::optional的设计初衷
二进制君
11-02 40
的设计初衷是为了解决处理可选值时的安全性和清晰性问题，提供一种简洁、易用的方式来表示和管理可能不存在的值。通过引入，C++ 提供了一个更现代化的替代方案，减少了使用传统空指针和特定标记值所带来的复杂性和错误风险。
第20课-C++【二叉搜索树】
2401_83603768的博客
10-25 1155
二叉搜索树（Binary search tree）是一种特殊的二叉树，它的每个节点的左子树中的所有节点值都小于该节点值，而右子树中的所有节点值都大于该节点值。
C语言之长整型有符号数与短整型有符号数转换
qq_40939768的博客
10-29 710
最近考证的新星，问了一个问题：int a = 1234565789;为什么在输出%hd时的值为-1379？其实这个很简单，只不过对于可能初入“编程坑”以及经验不是很丰富的朋友来说，感觉知道这么个道理，但就是解释不上来，无法做出实际的推论。作者想说的是，这个知识点亦涉及多方面，比较广泛，所以就以咱们未来的新星所提的问题进行分析。
C++ -- 模板进阶
最新发布
zy1215058242的博客
11-02 539
一个程序/项目由若干源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件的过程称为分离编译模式。模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生。增强了代码的灵活性。模板会导致会导致代码代码膨胀问题，也会导致编译时间变长。出现模板编译错误时，错误信息非常凌乱，不易定位错误。
C++11实现Android Handler机制详解
"使用C++11实现Android系统的Handler机制，通过实例代码详细讲解，旨在提供学习和工作中的参考借鉴价值。" 在Android开发中，Handler机制是一个关键的组件，用于解决多线程间的通信问题，特别是对于UI更新和异步...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值