C++多线程1.2-线程安全的保证——互斥量mutex(锁)和原子变量atomic

Posted C+++++++++++++++++++

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了C++多线程1.2-线程安全的保证——互斥量mutex(锁)和原子变量atomic相关的知识，希望对你有一定的参考价值。

文章目录

资源竞争引发的线程安全问题

有如下的代码：

#include<thread>
#include<iostream>
int globalVariable = 0;

void task()
    for (int i = 0; i < 1000000; ++i) 
        ++globalVariable;
    

int main()
    std::thread th1(task);
    std::thread th2(task);

    th1.join();
    th2.join();
    std::cout<<globalVariable;

我们开了两个线程，一共执行了两次 task ，按理来讲 globalVariable 变量应该被加到 2000000 。事实上，你可跑以上代码进行验证，肯定是达不到 2000000 的！

这又是怎么一回事呢？

  • 资源竞争的产生：
    在多线程中，由于类似于并行的逻辑存在，我们可以想象一下，到 th1 调用 task 函数，且正在为 globalVariable 变量做加法操作的时候，可能此时 th2 也正在为它做加法操作，线程中也是存在对应的工作内存，不是直接更改原内存的值，而是经过 读取->执行->写入 的过程。故此时如果两个线程同时进行读取并写入，那么实际上 globalVariable 只加了1，而不是2。

故由于资源竞争的存在，导致结果小于正确的结果！

如何解决资源竞争问题？

正如标题所示，如何解决资源竞争问题呢？

我们经过前面的分析，可知，资源竞争问题是因为并行逻辑的存在，扰乱了原本需要的有序逻辑。怎么理解呢，当多个线程同时处理同一个变量时是不安全的，我们只要让同时只有一个线程去处理这个变量即可。

上面所说的正是多线程的 原子性，执行一个操作的时候不会被其他的线程打断，或者说只能有一个线程在执行这个操作。而之前的代码中 ++globalVarible 这句正需要这样的原子性操作！

而C++里面也有两类方法去实现这样的效果。

法一：加互斥锁mutex（性能较低）

代码如下：

#include<thread>
#include<iostream>

int globalVariable = 0;
std::mutex mtx;
void task()
    for (int i = 0; i < 1000000; ++i) 
        mtx.lock(); //上锁
        ++globalVariable;
        mtx.unlock();//解锁
    

int main()
    std::thread th1(task);
    std::thread th2(task);

    th1.join();
    th2.join();
    std::cout<<globalVariable;

这下终于可以正确的得到 2000000 这个结果了。

我们来讲讲互斥量解锁和上锁的原理：

lock()：形象的描述就是，当调用这个方法的时候，会去互斥量里面拿取这把锁，如果这个锁已经被其他线程持有，则阻塞，直到其他线程把这把锁释放，每个互斥量都是一把相同的锁。

unlock()：字面意思，把我现在持有的锁给释放掉，这样就可以让其他因为没有拿到锁的线程停止阻塞，开始争抢这把锁，谁抢到了谁就能得到下一个CPU的时间片。

最终的结果就是哪个线程先拿下这把锁，那么其他线程再运行到这块代码的位置就会被阻塞，这就使得被上锁的区域是具有原子性的！这样就保证了线程的安全。

法二：转用原子变量（效率更高）

C++中可用模板类，把类型转为原子类型，原子变量的实现方式实际上和上锁的过程是类似，但可能由于不同编译器的实现方式，可能会调用计算机的硬件去优化这个加锁解锁的过程，所以效率会更高。

如下代码：(这时就不需要加解锁了，变量本身就是线程安全的)

#include<thread>
#include<iostream>

std::atomic<int> globalVariable = 0;
void task()
    for (int i = 0; i < 1000000; ++i) 
        ++globalVariable;
    

int main()
    std::thread th1(task);
    std::thread th2(task);

    th1.join();
    th2.join();
    std::cout<<globalVariable;

三个常用的互斥量装饰器

std::lock_guard (C++11)

这是一个最简单的互斥量装饰器，就是简单的利用C++构造函数和析构函数的RAII特性，在构造的时候上锁和析构的时候解锁，并不会维持传入的互斥器状态。

故前面的代码我们可以改作：

#include<thread>
#include<iostream>

int globalVariable = 0;
std::mutex mtx;
void task()
    for (int i = 0; i < 1000000; ++i) 
        std::lock_guard<std::mutex> lock(mtx);
        ++globalVariable;
    

int main()
    std::thread th1(task);
    std::thread th2(task);

    th1.join();
    th2.join();
    std::cout<<globalVariable;

std::lock_guard 还有第二个可选参数用于告知它此传入的互斥器已经被锁上，你无需再次上锁，这种主要用在上锁过程自己完成的情况下。例如很多情况我们为了防止产生死锁，需要调用 std::lock() 函数进行统一的上锁。

死锁的产生

如下代码：

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

int globalVariable = 0;
std::mutex mtx1;
std::mutex mtx2;
void task1()
    mtx1.lock();
    for (int i = 0; i < 10; ++i) 
        std::cout<<"test2"<<'\\n';
    
    mtx2.lock();

    mtx1.unlock();
    mtx2.unlock();

void task2()
    mtx2.lock();
    mtx1.lock();

    mtx2.unlock();
    mtx1.unlock();

int main()
    std::thread th1(task1);
    std::thread th2(task2);

    th1.join();
    th2.join();
    std::cout<<globalVariable;

以上代码的运行结果大概率是由于死锁产生的程序阻塞。

你想想一个过程：如果 mtx1 在 th1 线程先被上锁，而与此同时 mtx2 在 th2 线程被上锁，在 th1 线程运行完 for 循环代码后，遇到将 mtx2 上锁的代码后，由于此时 th2 线程正持有此锁，而 th1 也正持有 mtx1 这样的互相持有对方所需的锁的时候，将会发生死锁现象，即两个线程都被永远的阻塞了！

利用std::lock批量上锁防止死锁发生

以上的死锁发生的原因就是因为上锁的顺序所导致的，我们可以采取多个线程上多个锁时采用相同的顺序，便可防止死锁的发生，当然也可以直接调用标准库提供的 std::lock 函数批量上锁，来防止上锁顺序导致的死锁！

如下代码：（lock函数批量上锁是具有原子性的，不会被其他线程打断）

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

std::mutex mtx1;
std::mutex mtx2;
void task1()
    std::lock(mtx1,mtx2);
    std::lock_guard<std::mutex> _1(mtx1,std::adopt_lock); //adopt_lock代表一个标志，表示已经被上锁了，别再调用lock方法了
    std::lock_guard<std::mutex> _2(mtx2,std::adopt_lock);
    for (int i = 0; i < 5; ++i) 
        std::cout<<"test1\\n";
    

void task2()
    std::lock(mtx1,mtx2);
    std::lock_guard<std::mutex> _1(mtx1,std::adopt_lock); //adopt_lock代表一个标志，表示已经被上锁了，别再调用lock方法了
    std::lock_guard<std::mutex> _2(mtx2,std::adopt_lock);
    for (int i = 0; i < 5; ++i) 
        std::cout<<"test2\\n";
    

int main()
    std::thread th1(task1);
    std::thread th2(task2);

    th1.join();
    th2.join();

代码执行结果：

std::unique_lock (C++11)

和 lock_guard 类似，也是用的 RAII 手法进行上锁和解锁。但它还会维持互斥量的状态，你可以通过传入第二个参数告诉它状态。且它是支持无参构造的。

注意：这三个装饰器只有 unique_lock 含有移动构造函数，所以你可以写一个函数简化初始化过程。他们都没有复制构造器！

如：

std::unique_lock<std::mutex> lock(mtx2,std::defer_lock);

传入的 defer_lock 表示上锁过程暂时不调用，将在后面由我自己上锁。统样也支持 adopt_lock 选项表示已经上了锁。

std::scoped_lock（C++17）

这个装饰器，支持同时装饰多个互斥量，且也是通过 RAII 手法进行解锁和上锁过程。

创建 scoped_lock 对象时，它试图取得给定互斥的所有权。控制离开创建 scoped_lock 对象的作用域时，析构 scoped_lock 并以逆序释放互斥。若给出数个互斥，则使用免死锁算法，如同以 std::lock 。

scoped_lock 类不可复制。

如下代码：

std::scoped_lock lock(e1.m, e2.m);

// 等价代码 1 （用 std::lock 和 std::lock_guard ）
// std::lock(e1.m, e2.m);
// std::lock_guard<std::mutex> lk1(e1.m, std::adopt_lock);
// std::lock_guard<std::mutex> lk2(e2.m, std::adopt_lock);

// 等价代码 2 （若需要 unique_lock ，例如对于条件变量）
// std::unique_lock<std::mutex> lk1(e1.m, std::defer_lock);
// std::unique_lock<std::mutex> lk2(e2.m, std::defer_lock);
// std::lock(lk1, lk2);

以上是关于C++多线程1.2-线程安全的保证——互斥量mutex(锁)和原子变量atomic的主要内容，如果未能解决你的问题，请参考以下文章

C++多线程

如何创建线程？如何保证线程安全？

Linux___线程互斥与同步

Linux多线程——互斥和同步

linux多线程

linux多线程