目录
多线程数据共享问题
互斥量
lock()和unlock()
std::lock_guard
死锁
std::lock()
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();
}
