C++多线程基础学习笔记（五）

一、互斥量

1.1 互斥量的基本概念

简单来说，一个锁就是一个互斥量，既然是锁，就有两种状态：加锁和解锁，通过加锁>>>操作共享数据>>>解锁的方式，实现保护共享数据。

1.2 互斥量的用法

作用：在给某段代码加锁后，如果其他其他线程需要先等带该段代码执行完，然后解锁后才能继续执行。

头文件 ：#include <mutex>

成员函数：lock()   //加锁，unlock()  //解锁

注意点：lock()与unlock()的使用必须成对存在。

 #include <iostream>
 #include <mutex>
 using namespace std;
 int num = ;
 mutex my_mutex;         //创建一个互斥量
 void print1()
 {
     for (int i = ; i < ; i++)
     {
         my_mutex.lock();
         cout << "thread_1:" << num++ << endl;
         my_mutex.unlock();
     }
 }
 void print2()
 {
     for (int i = ; i < ; i++)
     {
         my_mutex.lock();
         cout << "thread_2:" << num++ << endl;
         my_mutex.unlock();
     }
 }

 int main()
 {
     thread thread_1(print1);      //打印0-49
     thread thread_2(print2);      //打印49-99
     thread_1.join();
     thread_2.join();
     system("pause");
     return ;
 }

还有一种方法，可实现加锁和解锁两个步骤，即用std::lock_guard<mutex> myguard (my_mutex)来代替lock()和unlock(),其原理是，在std::lock_guard构造函数里执行了lock(),在析构函数里执行了unlock()。

 #include <iostream>
 #include <mutex>
 using namespace std;
 int num = ;
 mutex my_mutex;
 void print1()
 {
     for (int i = ; i < ; i++)
     {
         lock_guard<mutex> myguard(my_mutex);
         cout << "thread_1:" << num++ << endl;
     }
 }
 void print2()
 {
     for (int i = ; i < ; i++)
     {
         lock_guard<mutex> myguard(my_mutex);
         cout << "thread_2:" << num++ << endl;
     }
 }

 int main()
 {
     thread thread_1(print1);      //打印0-49
     thread thread_2(print2);      //打印49-99
     thread_1.join();
     thread_2.join();
     system("pause");
     return ;
 }

二、死锁

仅在存在两个互斥量以上才会出现死锁的现象。例如线程A获得了锁1，线程B获得了锁2，这时线程A调用lock试图获得锁2，结果是需要挂起等待线程B释放锁2，而这时线程B也调用lock试图获得锁1，结果是需要挂起等待线程A释放锁1，于是线程A和B都永远处于挂起状态了。通俗来讲，就是我在等你解锁我才能解锁，你在等我解锁你才能解锁。

 #include <iostream>
 #include <mutex>
 using namespace std;
 int num = ;
 mutex my_mutex1;
 mutex my_mutex2;
 void print1()
 {
     for (int i = ; i < ; i++)
     {
         my_mutex1.lock();
         /*这里同通常有一段代码，也是用来操作共享数据*/
         my_mutex2.lock();
         cout << "thread_1:" << num++ << endl;
         my_mutex1.unlock();
         my_mutex2.unlock();
     }
 }
 void print2()
 {
     for (int i = ; i < ; i++)
     {
         my_mutex2.lock();
         my_mutex1.lock();
         cout << "thread_2:" << num++ << endl;
         my_mutex1.unlock();
         my_mutex2.unlock();
     }
 }

 int main()
 {
     thread thread_1(print1);      //打印0-49
     thread thread_2(print2);      //打印49-99
     thread_1.join();
     thread_2.join();
     system("pause");
     return ;
 }

运行结果发现也不会出现任何奔溃出错现象，但是就一直卡在那里，不会继续运行下去了。

解决死锁的方法其实也很简单，只要保证互斥量加锁的顺序一致就可以了。或者使用std::lock(mutex1,mutex2)，意思是给这两个互斥量同时上锁。