多线程、mutex互斥量-CSDN博客

本文链接：https://blog.csdn.net/2301_78933228/article/details/138456168

std::lock_guard()的std::adopt_lock参数

多线程数据共享问题

同一个进程中多个线程之间可以共享一部分资源数据。这些对多个线程都大开后门的数据，有些时常会被各个个线程访问。这些不受限制的共享数据，实际上是有一定的风险的。因为多个线程对同一数据的操作往往是不同的，有的读取数据，有的改写数据。这些对数据的改写操作实际上都是分步完成的，也就是说有可能对访问数据改写操作还未完成（已经修改了部分内容），就切换到了另一个线程对其进行读取。这样就会产生数据不一致，数据竞争等问题。

互斥量

为了保护共享数据，避免多个线程同时访问和修改数据导致的数据竞争等问题，就出现了互斥量的概念。互斥量是一把特殊的锁，同一时刻它只能被一个线程持有，其他线程必须等待该线程释放锁后才能获得锁。互斥量（mutex）实际上是个类对象，在使用时应该用include<mutex>将头文件包含进来。线程可以使用lock()函数获取锁，操作完成后再使用unlock()释放锁，这样其他等待锁的线程就可以使用lock(获取锁了，但只有一条线程会获取成功，其他线程将继续等待。

lock()和unlock()

使用互斥量需要手动的调用lock()、unlock()函数确定要保护的代码块。应尽量将保护范围与使用共享数据的范围相吻合。如果保护的范围过广，那么单一执行的代码增多，就会很影响执行效率。如果保护的范围过窄，有些对共享数据的访问未被包含，就不足以保护共享的数据，产生一系列的问题。lock()和unlock()也应确保每一条执行路径都有其对应关系，不要出现lock()后却不unlock()的情况。

以下为示例代码，用于从队列中不断的输入和取出数据：

#include<iostream>
#include<thread>
#include<mutex>
#include<list>
using namespace std;
class A
{
public:
    void inmydata()//线程入口
    {
        for (int i = 0; i < 10000; i++)
        {
            cout << "插入" << i << "数据" << endl;
            mymut.lock();
            mydata.push_back(i);
            mymut.unlock();
        }
    }

    bool func(int& a)
    {
        mymut.lock();
        if (!mydata.empty())//判断是否为空
        {
            a = mydata.front();//读取首元素
            mydata.pop_front();//删除首元素
            mymut.unlock();
            return true;
        }
        mymut.unlock();
        return false;
    }

    void outmydate()//输出线程入口
    {
        int command = 0;
        for (int i = 0; i < 10000; i++)
        {
            bool result = func(command);
            if (result == true) cout << "取出了" << command << "数据" << endl;
            else cout << "取出失败" << endl;
        }
    }


private:
    list<int> mydata;
    mutex mymut;
};
int main()
{
    A a;
    thread newdozer2(&A::outmydate,&a);
    thread newdozer1(&A::inmydata,&a);
   
    newdozer1.join();
    newdozer2.join();
}

std::lock_guard

`std::lock_guard`是C++11中引入的一个模板类，它是用于管理互斥锁（mutex）的RAII（Resource Acquisition Is Initialization）包装器。`std::lock_guard`的主要目的是在多线程环境中自动管理锁的生命周期，避免了手动上锁和解锁。

`std::lock_guard`的使用非常简单，通常在需要保护的代码段前创建一个`std::lock_guard`对象，并将要保护的互斥锁作为参数传递给构造函数。这样，在`std::lock_guard`对象的生命周期内，互斥锁将一直保持锁定状态，确保对共享资源的独占访问。当`std::lock_guard`对象销毁时，互斥锁将被自动解锁，允许其他线程访问共享资源。

mutex my_mytex;
std::lock_guard<std::mutex> myguardlock(my_mutex);

死锁

死锁是并发编程中一种常见现象，通常是由于对资源的竞争，造成了多线程或进程阻塞。这种由于资源竞争造成的僵局，就好像没有钥匙的锁一样，如过没有外力干涉，程序都将停滞不前。例如两条线程同时访问被两个互斥量保护的共享数据，两条线程都分别获得了一把锁，但都因为缺少另一把锁而无法访问共享数据，它们都等待着另一条线程释放锁。这时死锁就发生了。这样的一种矛盾状态导致了两条线程都无法执行。

为了避免死锁，应尽量保证互斥量上锁的顺序一致，这样就能简单有效的避免死锁。

std::lock()

std::lock()用于解决多个互斥量锁头同时锁住的顺序问题。它可以锁住多个互斥量，并确保它们可以同时一起别锁住，从而减少死锁的风险。std::lock()并不管理锁的生命周期，因此还是需要使用互斥量的unlock()成员函数手动释放锁。

#include<iostream>
#include<thread>
#include<list>
#include<mutex>
using namespace std;

std::mutex mymutex1;
std::mutex mymutex2;
list<int> mydata;

void newthread()
    {
        std::lock(mymutex1,mymutex2);
        for(int i=0;i<10000;i++)
            {
                mydata.push_back(i);
            }
        mymutex1.unlock();
        mymutex2.unlock();
    }

int main()
{
    thread mythread1(newthread);
    thread mythread2(newthread);
    mythread1.join();
    mythread2.join();
}

std::lock_guard的std::adopt_lock参数

std::lock()虽然可以避免锁的顺序问题，但仍需要手动的调用互斥量的unlock()解锁。我们可以将std::lock()与std::lock_guand结合使用，先使用std::lock()避免死锁问题，再用std::lock_guard()对象接管std::lock()的锁定状态。为了告诉系统此std::lock_guard是接管锁定状态，而不需要再次锁定互斥量，需要额外该std::lock_guard传递一个参数，就是std::adopt_lock。

现在使用std::lock_guard()和std::adopt_lock()改造上面代码：

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

using namespace std;

std::mutex mymutex1;
std::mutex mymutex2;
list<int> mydata;

void newthread()
{
    std::lock(mymutex1, mymutex2);
    std::lock_guard<std::mutex>(mymutex1, std::adopt_lock);
    std::lock_guard<std::mutex>(mymutex2, std::adopt_lock);
    for (int i = 0; i < 10000; i++)
    {
        mydata.push_back(i);
    }
}

int main()
{
    thread mythread1(newthread);
    thread mythread2(newthread);
    mythread1.join();
    mythread2.join();
}