前言

本节课的主要内容是解决线程中数据共享的问题

提示：以下是本篇文章正文内容，下面案例可供参考

一、数据共享的定义以及示例问题

数据共享的定义：在多个线程中读/写一个变量。

那我们首先要知道：变量能同时读取一个数据但不能同时写和读或者一起写同一个数据。

数据我们可以定义为全局变量或类中的一个成员。

二、解决方案_互斥量、lock()、unlock()

引导

功能为：myin()加数据到list中，myou()输出myin加入的数据

myin()功能为写，myou为读

大家可以试一下自己实现：

1、mutex互斥量

互斥量是上什么：如果不需要信号量的计数能力，有时可以使用信号量的一个简化版本，称为互斥量（mutex）

简单来说就是用来锁住一段代码，其他线程再次锁时就需要等待线程解锁

他在C++中头文件为:#include <mutex>

他是一个类

他的定义为:mutex m;

2、mutex::lock()锁

作用：用来锁住一段代码，其他线程使用时就需要等待解锁。

可以有效的缓解同时读/又读又写的线程

mutex m;
m.lock();//如果没有及时解锁，则：锁到程序结束，并且其他人拿不到锁
........
cout<<"hello world"<<endl;

3、mutex::unlock()解锁

作用：用来解锁一段代码，其他线程可以在次锁这个互斥量。

锁的意义：不让变量同时读写

4、范例演示

讲解：我们有2个线程，他们又读又写，所以我们需要锁住变量以保证数据安全。

我们使用完数据后也需要解锁，要不然其他线程会卡到lock()永远执行不到

class A
{
public:
  //功能为：myin()加数据到li中，myou()输出myin加入的数据
  void myin()
  {
    for (int i = 0; i < 100000; i++)
    {
      cout << "插入数据:" << i << endl;
      m.lock();//加锁保护数据安全
      li.push_back(i);
      m.unlock();//使用完后需要及时解锁
    }
  }
  void myou()
  {
    for (int i = 0; i < 100000; i++)
    {
      m.lock();//加锁保护数据安全
      if (!li.empty())//不为空时输出数据并删除他
      {
        //输出数据
        cout << "数据输出:" << li.front() << endl;
        li.pop_front();
      }
      else//为空则取不到
        cout << "队列为空" << endl;
      m.unlock();//使用完后需要及时解锁
    }
  }
  //定义一个list队列
  list<int> li;
  //定义一个互斥量
  mutex m;
};
int main()
{
  A a;
  //创建2个线程
  thread t(&A::myin);
  thread th(&A::myou);
  //让主线程等待
  t.join();
  th.join();
  return 0;
}

现在就可以稳定地跑起来了。

三、lock_gurad类模板、死锁及解决方案

1、为什么要使用lock_gurad

我相信，有些人lock()后总会忘记unlock()导致其他线程执行不到，卡在lock()那

怎么办呢？系统/C++给我们提供了一个类模板，使用他就不用unlock()了

2、lock_gurad的使用

他其实就是一个类模板

他的作用是不用unlock锁了，他自动unlock()

改一下刚刚的范例：

void myin()
  {
    for (int i = 0; i < 100000; i++)
    {
      cout << "插入数据:" << i << endl;
      lock_guard<mutex> lo(m);
      li.push_back(i);
    }
  }
  void myou()
  {
    for (int i = 0; i < 100000; i++)
    {
      lock_guard<mutex> lo(m);
      if (!li.empty())//不为空时输出数据并删除他
      {
        //输出数据
        cout << "数据输出:" << li.front() << endl;
        li.pop_front();
      }
      else
        cout << "队列为空" << endl;
    }
  }

他还是能正常运行，所以我们写的没有问题

他还有一个功能：变成unlock()

在lock_gurad构造函数参数2写adopt_lock

拓展知识std::lock：一次锁住多个mutex互斥量：

实际：类模板

mutex _1;
mutex _2;
std::lock<mutex>(_1,_2);

3、死锁情况的演示

大概情况讲解：线程A拿到mu1锁,在拿mu2锁，然后解锁mu2，解锁mu1 线程B呢：拿mu2锁，再拿mu1，然后解锁mu1，解锁mu2。这就导致有可能A，B都不解锁。卡在那：

解决方案：锁和解锁两个线程顺序要一样

四、unique_lock lock_gurad加强版

1、与lock_gurad的对比

为什么说unique_lock是 lock_gurad的加强版呢？

答：unique_lock用法更灵活，更多的参数，更高的效率

2、使用

unique_lock也是一个类模板

基本功能和lock_gurad一样一样的，那他灵活在哪呢？

成员函数，和构造函数的参数1多种多样:

构造函数参数1：

1).try_to_lock

没有拿到锁立马返回，立马unlock

怎么看自己有没有拿到锁呢

使用owns_lock函数

unique_lock<mutex> uni(m);
if(uni.owns_lock)
{
  cout<<"拿到了锁"<<endl;
  //干其他的事情
}
else
  cout<<"没有拿到锁"

2).defer_lock

初始化一个mutex

前提：此mutex没有加锁

成员函数：

1).lock()

手动lock()

2).unlock()

手动unlock()

unique_lock可以自己加解锁

3).release()放弃mutex的所以权，并返回mutex的指针

所有权指的是：放弃他的操作，简单的说：调用了release函数就不能操作那个绑定的mutex