C++并发编程之线程同步 std::mutex用法总结

最新推荐文章于 2024-04-24 11:52:10 发布
最新推荐文章于 2024-04-24 11:52:10 发布
阅读量2.7k 收藏 9
点赞数 1
分类专栏： C/C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/anwh9295/article/details/120444373
版权

1、std::mutex基本介绍

1、引言
在C++多线程编程中，不同线程操作同一片数据空间时，如果没有进行进行线程访问的约束的话，那么就会出现，线程A在修改Data，同时线程B也在修改Data。那么最后的Data里面的数据是未知的，然而我们刚开始期望的是通过线程A操作完数据后的结果，线程B再接着操作的情况。所以我们需要在某一个线程操作该数据的时候，独占数据的所有权，其他线程不可获得和更改。
Mutex：互斥量，在C++11中，其头文件如下：

#include<thread>
#include<mutex>

按照Mutex的类型划分如下：

std::mutex基本的 Mutex 类
std::recursive_mutex递归 Mutex 类
std::time_mutex定时 Mutex 类
std::recursive_mutex定时递归Mutex 类

接下来，我们看下C++11中关于Mutex的定义如下：

  /// The standard mutex type.
  class mutex : private __mutex_base
  {
  public:
    typedef __native_type* 			native_handle_type;
#ifdef __GTHREAD_MUTEX_INIT
    constexpr
#endif
    mutex() noexcept = default;
    ~mutex() = default;
    mutex(const mutex&) = delete; //不允许拷贝构造
    mutex& operator=(const mutex&) = delete;//不允许move拷贝
    void
    lock()
    {
      int __e = __gthread_mutex_lock(&_M_mutex);
      // EINVAL, EAGAIN, EBUSY, EINVAL, EDEADLK(may)
      if (__e)
	__throw_system_error(__e);
    }
    bool
    try_lock() noexcept
    {
      // XXX EINVAL, EAGAIN, EBUSY
      return !__gthread_mutex_trylock(&_M_mutex);
    }
    void
    unlock()
    {
      // XXX EINVAL, EAGAIN, EPERM
      __gthread_mutex_unlock(&_M_mutex);
    }
    native_handle_type
    native_handle()
    { return &_M_mutex; }
  };

void lock()
void unlock()
bool try_lock()

mutex调用lock时，调用的线程将锁住该互斥量。这时候存在有三种情况：
1、如果该互斥量被当前的线程进行锁住了，则会产生死锁。
2、如果当前mutex被其他线程锁住了，则当前线程则会阻塞在这里。
3、如果当前的mutex没有被锁住的情况，则将当前mutex进行锁住，直到调用unlock为止。

mutex调用try_lock时，表示当前线程尝试锁住该mutex，如果mutex被其他线程持有，则当前线程不会阻塞在这里，这时候也会出现三种情况：
1、如果该互斥量被其他线程锁住了，则当前调用线程就返回false，并且不会阻塞。
2、如果当前mutex被当前线程锁住了，则会产生死锁的情况。
3、如果当前的mutex没有被其他线程锁住，则当前线程就锁住了mutex,直到调用unlock为止。

mutex调用un_lock时，解锁，当前线程释放对mutex的持有。

一般来说，当Mutex配合操作资源时，和下面两个搭配使用。

std::lock_guard，与 Mutex RAII 相关，方便线程对互斥量上锁。
std::unique_lock，与 Mutex RAII 相关，方便线程对互斥量上锁，但提供了更好的上锁和解锁控制。
具体的例子如下：


std::mutex g_mutex;
void task()
{
	for(int i = 0;i < 1000000;i++)
	{
		std::lock_guard<std::mutex> lock(g_mutex);
		g_count++;
	}
	std::cout << g_count << std::endl;
}

//示例4
std::mutex g_mutex;
static std::list<int> g_listMsgQueue;
void pushMsgRecvQueue()
{
	for (int i = 0;i < 10; i++)
	{
 		std::unique_lock<std::mutex> lck(g_mutex,std::try_to_lock);
		if(lck.owns_lock()) {
			g_listMsgQueue.push_back(i);
		}
	}
}

2、std::mutex使用示例

std::mutex使用示例如下：

/*************************************************************************
	> File Name: thread_mutex.cpp
	> Author: 小和尚敲木鱼
	> Mail:  
	> Created Time: Mon 20 Sep 2021 03:17:02 AM PDT
 ************************************************************************/
#include<iostream>
#include<thread>
#include<mutex>

using namespace std;
std::mutex g_mtx;
volatile int counter(0);

void function_1()
{
	std::cout << __func__<< " begin:" << counter << std::endl;
	
	for (int i = 0;i < 10;i++) {
		if (g_mtx.try_lock()) {
			counter = counter + 5;
			g_mtx.unlock();
		}
	}
	std::cout << __func__<< " end:" << counter << std::endl;
}

void function_2()
{
	std::cout << __func__<< " begin:" << counter << std::endl;
	for (int i = 0;i < 10;i++) {
		if (g_mtx.try_lock()) {
			counter = counter + 10;
			g_mtx.unlock();
		}
	}
	std::cout << __func__<< " end:" << counter << std::endl;
}

int main(int agc,char * agv[])
{
	std::thread thread1(function_1);
	std::thread thread2(function_2);

	if (thread1.joinable())
		thread1.join();
	
	if (thread2.joinable())
		thread2.join();

	return 0;
}
//OUT
//function_2 begin:0
//function_2 end:100
//function_1 begin:100
//function_1 end:150
/**************************end of file**********************************/

3、std::recursive_mutex 递归互斥量介绍

  /// The standard recursive mutex type.
  class recursive_mutex : private __recursive_mutex_base
  {
  public:
    typedef __native_type* 			native_handle_type;

    recursive_mutex() = default;
    ~recursive_mutex() = default;
    recursive_mutex(const recursive_mutex&) = delete;
    recursive_mutex& operator=(const recursive_mutex&) = delete;

    void
    lock()
    {
      int __e = __gthread_recursive_mutex_lock(&_M_mutex);

      // EINVAL, EAGAIN, EBUSY, EINVAL, EDEADLK(may)
      if (__e)
	__throw_system_error(__e);
    }
    bool
    try_lock() noexcept
    {
      // XXX EINVAL, EAGAIN, EBUSY
      return !__gthread_recursive_mutex_trylock(&_M_mutex);
    }
    void
    unlock()
    {
      // XXX EINVAL, EAGAIN, EBUSY
      __gthread_recursive_mutex_unlock(&_M_mutex);
    }
    native_handle_type
    native_handle()
    { return &_M_mutex; }
  };

由上面可知，std::recursive_mutex 支持的操作如下:

void lock()
void unlock()
bool try_lock()

其成员函数和std::mutex一样，其操作和mutex查不多。但是std::recursive_mutex 不同点在于，当前线程可以重复对互斥量进行上锁，即递归上锁，但是这个操作有一个前提就是，调用std::recursive_mutex 的lock和unlock次数得相同。当前线程持有std::recursive_mutex 时，可以重复调用std::recursive_mutex 不会阻塞。如果其他线程尝试持有std::recursive_mutex 的所有权，则会阻塞或者受到false的返回值。

4、std::time_mutex定时互斥量介绍

/// The standard timed mutex type.
  class timed_mutex
  : private __mutex_base, public __timed_mutex_impl<timed_mutex>
  {
  public:
    typedef __native_type* 		  	native_handle_type;

    timed_mutex() = default;
    ~timed_mutex() = default;

    timed_mutex(const timed_mutex&) = delete;
    timed_mutex& operator=(const timed_mutex&) = delete;

    void
    lock()
    {
      int __e = __gthread_mutex_lock(&_M_mutex);

      // EINVAL, EAGAIN, EBUSY, EINVAL, EDEADLK(may)
      if (__e)
	__throw_system_error(__e);
    }

    bool
    try_lock() noexcept
    {
      // XXX EINVAL, EAGAIN, EBUSY
      return !__gthread_mutex_trylock(&_M_mutex);
    }

    template <class _Rep, class _Period>
      bool
      try_lock_for(const chrono::duration<_Rep, _Period>& __rtime)
      { return _M_try_lock_for(__rtime); }

    template <class _Clock, class _Duration>
      bool
      try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime)
      { return _M_try_lock_until(__atime); }

    void
    unlock()
    {
      // XXX EINVAL, EAGAIN, EBUSY
      __gthread_mutex_unlock(&_M_mutex);
    }

    native_handle_type
    native_handle()
    { return &_M_mutex; }
  };

由上面可知，std::time_mutex支持的操作如下:

void lock()
void unlock()
bool try_lock()
bool try_lock_for(const chrono::duration<_Rep, _Period>& __rtime) //新增
bool try_lock_until(try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime) //新增

由上面可知，std::time_mutex比std::mutex多了两个操作。try_lock_for()，try_lock_until()。

下面就分别对这两个操作进行解释：
std::time_mutex::try_lock_for 成员函数
接受参数，表示在这段时间范围之内，如果当前线程没有获得锁则阻塞住。
std::time_mutex::try_lock_until成员函数
成员函数表示，接受一个参数，在这个时间点之前线程没有获得锁就阻塞住，如果在这段时间内，其他线程释放了锁，则当前线程可以获得std::time_mutex的锁，如果超过了这个时间点，则返回false。
具体使用示例如下：

/*************************************************************************
	> File Name: thread_time_mutex.cpp
	> Author: 小和尚敲木鱼
	> Mail:  
	> Created Time: Mon 20 Sep 2021 03:34:47 AM PDT
 ************************************************************************/

#include <iostream>       // std::cout
#include <chrono>         // std::chrono::milliseconds
#include <thread>         // std::thread
#include <mutex>          // std::timed_mutex
std::timed_mutex g_timerMtx;
using namespace std;
/*****************************文件说明***********************************
***********************************************************************/
/*
void function_1()
{
	while(!g_timerMtx.try_lock_for(std::chrono::milliseconds(200)))
	{
		std::cout << "function do something" <<std::endl;
	}
	std::this_thread::sleep_for(std::chrono::milliseconds(200));
	std::cout << "function exit..." << std::endl;
	g_timerMtx.unlock();
}

int main(int agc,char * agv[])
{
	std::thread threads[10];
	for (int i = 0; i < 10; i++) {
		threads[i] = std::thread(function_1);
	}
	
	for (auto & th : threads) {
		if (th.joinable())
		{
			th.join();
		}
	}
 
   return 0;
}
*/
//OUT
//function exit...
//function do something
//function do something
//function do something
//function do something
//function do something
//function do something
//function do something
//function do something
//function exit...
//function do something
//function do something
//function do something
//function do something
//function do something
//function do something
//function do something
//function exit...
//function do something
//function do something
//function do something
//function do something
//function do something
//function do something
//function do somethingfunction do something
//
//function do something
//function exit...
//function do something
//function do something
//function do something
//function exit...
//function do something
//function do something
//function do something
//function do something
//function exit...
//function do somethingfunction do something
//
//function do something
//function do something
//function exit...
//function do something
//function do something
//function do something
//function exit...
//function exit...
//function exit...
void function_1()
{
	while(!(g_timerMtx.try_lock_until(std::chrono::milliseconds(200))))
	{
		
		std::cout << "function do something" <<std::endl;
	}
	std::this_thread::sleep_for(std::chrono::milliseconds(200));
	std::cout << "function exit..." << std::endl;
	g_timerMtx.unlock();
}

int main(int agc,char * agv[])
{
	std::thread threads[10];
	for (int i = 0; i < 10; i++) {
		threads[i] = std::thread(function_1);
	}
	for (auto & th : threads) {
		if (th.joinable())
		{
			th.join();
		}
	}
   return 0;
}
/**************************end of file**********************************/

5、std::recursive_timed_mutex定时递归互斥量介绍

/// The standard recursive timed mutex type.
  class recursive_timed_mutex
  : private __recursive_mutex_base,
    public __timed_mutex_impl<recursive_timed_mutex>
  {
  public:
    typedef __native_type* 			native_handle_type;
    recursive_timed_mutex() = default;
    ~recursive_timed_mutex() = default;
    recursive_timed_mutex(const recursive_timed_mutex&) = delete;
    recursive_timed_mutex& operator=(const recursive_timed_mutex&) = delete;
    void
    lock()
    {
      int __e = __gthread_recursive_mutex_lock(&_M_mutex);

      // EINVAL, EAGAIN, EBUSY, EINVAL, EDEADLK(may)
      if (__e)
	__throw_system_error(__e);
    }
    bool
    try_lock() noexcept
    {
      // XXX EINVAL, EAGAIN, EBUSY
      return !__gthread_recursive_mutex_trylock(&_M_mutex);
    }
    template <class _Rep, class _Period>
      bool
      try_lock_for(const chrono::duration<_Rep, _Period>& __rtime)
      { return _M_try_lock_for(__rtime); }

    template <class _Clock, class _Duration>
      bool
      try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime)
      { return _M_try_lock_until(__atime); }
    void
    unlock()
    {
      // XXX EINVAL, EAGAIN, EBUSY
      __gthread_recursive_mutex_unlock(&_M_mutex);
    }
    native_handle_type
    native_handle()
    { return &_M_mutex; }
  };

可以看出std::recursive_timed_mutex和std::time_mutex的操作没有什么新增的函数，但是其具有std::recursive_mutex的特性，就是当前线程中，可以多次对std::recursive_timed_mutex进行上锁，不会阻塞线程本身。

void lock()
void unlock()
bool try_lock()
bool try_lock_for(const chrono::duration<_Rep, _Period>& __rtime)
bool try_lock_until(try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime)

6、总结

互斥量是C++11线程同步的基础，基本概念还是比较简单，配合lock_guard采用RALL的操作，进行资源操作时非常的方便。也非常的银杏。

给大佬递杯卡布奇诺
关注
  • 1
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++11 并发指南之std::mutex详解
12-20
上一篇《C++11 并发指南二(std::thread 详解) 》中主要讲到了 std::thread 的一些用法，并给出了两个小例子，本文将介绍 std::mutex 的用法。 Mutex 又称互斥量，C++ 11中与 Mutex 相关的类（包括锁类型）和函数都声明在 头文件中，所以如果你需要使用 std::mutex，就必须包含 头文件。 头文件介绍 Mutex 系列类(四种) std::mutex，最基本的 Mutex 类。 std::recursive_mutex，递归 Mutex 类。 std::time_mutex，定时
C++11 并发指南三(std::mutex 详解)
weixin_34362875的博客
08-04 2929
上一篇《C++11 并发指南二(std::thread 详解)》中主要讲到了 std::thread 的一些用法，并给出了两个小例子，本文将介绍 std::mutex 的用法。 Mutex 又称互斥量，C++ 11中与 Mutex 相关的类（包括锁类型）和函数都声明在 &lt;mutex&gt; 头文件中，所以如果你需要使用 std::mutex，就必须包含 &lt;mutex&gt; 头文件。...
浅谈互斥锁（std::mutex）
m0_75087854的博客
04-24 657
另外top()与pop()之间也存在竞争：新线程在top()与pop()之间进行top()操作，假设栈中有两个及以上的数据时，好像并没有太大的异常，我们仔细设想一下，其实出栈的元素可能是同一个，而这种错误，代码编译后并不会被发现。所谓互斥锁，实质上就是指当某一个线程拥有锁（即资源），在执行其线程任务时，其它的线程只能等待，只有当上一个线程完成自己的任务并且释放锁的资源后，其它的线程才能进行重新上锁（即获取资源），完成自己的任务。条件竞争一般是指两个及两个以上线程共享数据内存，并抢着完成各自的任务。
C++11——std::mutex
没差的博客
09-15 4448
互斥量 互斥量是一个可以处于两态之一的变量:解锁和加锁。这样，只需要一个二进制位表示它，不过实际上，常常使用一个整型量，0表示解锁，而其他所有的值则表示加锁。互斥量使用两个过程。当一个线程(或进程)需要访问临界区时，它调用mutex_lock。如果该互斥量当前是解锁的(即临界区可用)，此调用成功，调用线程可以自由进入该临界区。 #include <iostream> #inc...
C++ std::mutex互斥元/锁
龚建波
08-25 3042
0.前言 将多线程作为并行的关键优点之一，在于它们之间简单直接地共享数据的能力。但当多个线程修改同一数据时，就很容易因为竞争而导致错误的执行结果。若所有线程只是进行读取操作，就没有问题。 1.认识std::mutex 由C++标准提供的保护共享数据的最基本机制是互斥元/锁（mutex）（读缪特克斯）。在访问共享数据之前，锁定（lock）与该数据相关的互斥元，访问完成后，解锁（unlock）该...
C++互斥锁std::mutex
weixin_40355471的博客
04-02 1401
std::mutex 是C++11 中最基本的互斥量，lock(),unlock(),try_lock(),std::lock_guard, std::unique_lock ,std::mutex实测代码
我们使std :: shared_mutex快10倍
04-11
标题中的“我们使std::shared_mutex快10倍”揭示了一个关于C++多线程并发编程的优化案例，其中std::shared_mutex是C++11引入的一种互斥锁，用于支持读写锁，允许多个读取者同时访问共享资源而只允许一个写入者。...
线程安全的std :: map和无锁映射的速度
04-11
为了在多线程环境下使用std::map，开发者通常需要手动添加锁来保证同步，例如使用std::mutex或者C++11引入的std::shared_mutex。 2. **无锁编程**：无锁编程（Lock-free Programming）是一种优化多线程并发性能的...
C++并发编程实战:示例源源码
06-14
《C++并发编程实战》是一本深入探讨C++并发编程技术的书籍，其源码库名为Cpp-Concurrency-in-Action-master。并发编程是现代多核处理器环境下提高软件性能的关键技术，C++作为一门强大且灵活的编程语言，提供了丰富...
C++11互斥量mutex详解，再也不怕多线程的数据竞争！
Lion_Long的博客
02-07 5287
mutex又称互斥量，C++ 11中与 mutex相关的类（包括锁类型）和函数都声明在头文件中，所以如果你需要使用 std::mutex，就必须包含头文件。std::mutex，独占的互斥量，不能递归使用。std::time_mutex，带超时的独占互斥量，不能递归使用。std::recursive_mutex，递归互斥量，不带超时功能。std::recursive_timed_mutex，带超时的递归互斥量。
c++ std::mutex 多个线程同时访问的同步原语
qq_40788199的博客
08-07 1102
mutex 类是能用于保护共享数据免受从多个线程同时访问的同步原语。 mutex 提供排他性非递归所有权语义： 调用方线程从它成功调用 lock 或 try_lock 开始，到它调用 unlock 为止占有 mutex 。 线程占有 mutex 时，所有其他线程若试图要求 mutex 的所有权，则将阻塞（对于 lock 的调用）或收到 false 返回值（对于 try_lock ）. 调用方线程在调用 lock 或 try_lock 前必须不占有 mutex 。...
c++中std::mutex最全用法归纳
啥都生的博客
02-06 2453
篇介绍 C++中std::mutex的具体用法，并提供一些std::mutex范例代码
【C++】详解std::mutex
m0_61629312的博客
09-11 2398
std::mutex是C++标准库中提供的一种同步原语，用于保护共享资源的访问。std::mutex通过锁定互斥锁来实现对共享资源的保护。当一个线程获取了互斥锁后，其他线程必须等待该互斥锁被释放才能继续访问共享资源。这样可以确保在同一时刻只有一个线程能够访问共享资源，从而避免了多个线程同时访问同一资源而导致的数据竞争和不一致问题。
std::mutex和std::lock_guard
weixin_41440739的博客
04-27 8628
互斥锁是一种可锁定的对象，它被设计用来在关键代码段需要独占访问时发出信号，防止具有相同保护的其他线程并发执行并访问相同的内存位置。互斥对象提供独占性，不支持递归性(也就是说，一个线程不应该锁定它已经拥有的互斥对象，否则会导致死锁)。 构造函数：仅支持默认构造函数，不支持拷贝和移动构造函数。完成构造后，处于unlock状态。互斥锁的构造本身不是原子的:在构造时访问对象可能会引发数据竞争。 lock()：调用线程锁住互斥对象，必要时阻塞，互斥对象被作为原子操作访问/修改(不会导致数据竞争)。 ...
C++11中std::mutex的使用
热门推荐
网络资源是无限的
06-20 8万+
C++11中std::mutex的使用
【C++入门到精通】互斥锁 (Mutex) C++11 [ C++入门 ]
Yawesh的博客
12-22 7375
本文介绍了四种C++中常用的互斥锁类型，这些互斥锁类型用于控制多线程对共享资源的访问，避免数据竞争和不确定行为的发生。其中，std::mutex是最基本的互斥锁类型，std::recursive_mutex是可递归的互斥锁类型，std::timed_mutex是限时等待互斥锁类型，std::recursive_timed_mutex是限时等待递归互斥锁类型。使用互斥锁时需注意正确的加锁和解锁操作，选择合适的互斥锁类型应根据具体需求和场景来进行。通过合理使用互斥锁，可以提高多线程程序的性能和并发能力。
std::mutex 互斥锁
mankeywang的博客
10-20 210
std::mutex 是C++标准库中的互斥量，用于实现多线程编程时的互斥访问控制。它确保在任何给定时刻只有一个线程可以访问被锁定的临界区，从而防止竞态条件和数据竞争。2.提供互斥锁：通过在需要对共享资源进行访问或修改的代码块中使用 std::unique_lock 对 m_mutex 进行上锁，可以确保同一时刻只有一个线程能够执行该代码块。1.保护共享资源：m_mutex 用于保护 m_colors 这个共享资源，以确保多个线程不会同时访问或修改 m_colors，从而防止数据竞争。
C++11多线程之std::mutex互斥锁
十三阿哥的博客
08-11 765
【代码】C++11多线程之std::mutex互斥锁。
std::mutex 的使用总结
编程猿来如此
03-22 3125
std::mutex 的使用总结
std::mutex st1=new std::mutex；
最新发布
06-21
`std::mutex` 是C++标准库中的一个基本互斥量（mutex），用于保护共享资源免受并发访问。创建一个新的`std::mutex`对象如下： ```cpp std::mutex st1; // 创建一个新的std::mutex实例st1 ``` 当你需要在某个代码块...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

给大佬递杯卡布奇诺

你们的鼓励就是我传作的动力！

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值