C++ 11并发指南(std::mutex详解)

2021/12/2 11:06:43

本文主要是介绍C++ 11并发指南(std::mutex详解),对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

Mutex又称互斥量,C++11中与Mutex相关的类(包括锁类型)和函数都声明在<mutex>头文件中,所以使用std::mutex就必须包含<mutex>头文件。

<mutex>头文件介绍

Mutex系列类(四种)

  1. std::mutex, 最基本的Mutex类。
  2. std::recursive_mutex,递归Mutex类。
  3. std::time_mutex,定时Mutex类。
  4. std::recursive_timed_mutex,定时递归Mutex类。

Lock类(两种)

  1. std::lock_guard, 与Mutex RAII相关,方便线程对互斥量上锁。
  2. std::unique_lock,与Mutex RAII相关,方便线程对互斥量上锁,但提供了更好的上锁和解锁控制。

其他类型

  1. std::once_flag
  2. std::adopt_lock_t
  3. std::defer_lock_t
  4. std::try_to_lock_t

函数:

  1. std::try_lock,尝试同时对多个互斥量上锁。
  2. std::lock,可以同时对多个互斥量上锁。
  3. std::call_once,如果多个线程需要同时调用某个函数,call_once可以保证多个线程对该函数只调用一次。

std::mutex 介绍

下面以 std::mutex 为例介绍 C++11 中的互斥量用法。

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

std::mutex 的成员函数

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

#include <iostream>                 // std::cout

#include <thread>                   // std::thread

#include <mutex>                   // std::mutex

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

std::mutex mtx;                     // locks access to counter

void attempt_10k_increases()

 {

for (int i=0; i<10000; ++i)

{

  if (mtx.try_lock())             // only increase if currently not locked:

{  

            ++counter;

            mtx.unlock();

        }

    }

}

int main (int argc, const char* argv[])

{

    std::thread threads[10];

    for (int i=0; i<10; ++i)

        threads[i] = std::thread(attempt_10k_increases);

    for (auto& th : threads) th.join();

    std::cout << counter << " successful increases of the counter.\n";

    return 0;

}

下面给出一个与 std::mutex 的小例子

C++11中std::unique_lock的使用

std::unique_lock为锁管理模板类,是对通用mutex的封装。std::unique_lock对象以独占所有权的方式管理mutex对象的上锁和解锁操作,即在unique_lock对象的声明周期内,它所管理的锁对象会一直保持上锁状态;而unique_lock的生命周期结束之后,它所管理的锁对象会被解锁。unique_lock具有lock_guard的所有功能,而且更为灵活。虽然二者的对象都不能复制,但是unique_lock可以移动,因此用unique_lock管理互斥对象,可以作为函数的返回值,也可以放到STL的容器中。

std::unique_lock还支持同时锁定多个mutex,这避免了多道加锁时的资源”死锁”问题。在使用std::condition_variable时需要使用std::unique_lock而不应该使用std::lock_guard。

std::unique_lock类成员函数介绍:

  • (1). unique_lock构造函数:禁止拷贝构造,允许移动构造;
  • (2). operator =:赋值操作符,允许移动赋值,禁止拷贝赋值;
  • (3). operator bool:返回当前std::unique_lock对象是否获得了锁;
  • (4). lock函数:调用所管理的mutex对象的lock函数;
  • (5). try_lock函数:调用所管理的mutex对象的try_lock函数;
  • (6).try_lock_for函数:调用所管理的mutex对象的try_lock_for函数;
  • (7).try_lock_until函数:调用所管理的mutex对象的try_lock_until函数;
  • (8). unlock函数:调用所管理的mutex对象的unlock函数;
  • (9). release函数:返回所管理的mutex对象的指针,并释放所有权,但不改变mutex对象的状态;
  • (10). owns_lock函数:返回当前std::unique_lock对象是否获得了锁;
  • (11). mutex函数:返回当前std::unique_lock对象所管理的mutex对象的指针;
  • (12). swap函数:交换两个unique_lock对象。


这篇关于C++ 11并发指南(std::mutex详解)的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!


扫一扫关注最新编程教程