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

一、互斥量

1.1 互斥量的基本概念

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

1.2 互斥量的用法

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

头文件 ：#include <mutex>

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

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

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

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

#include <iostream>
#include <mutex>
using namespace std;
int num = 0;
mutex my_mutex;
void print1()
{
    for (int i = 0; i < 50; i++)
    {
        lock_guard<mutex> myguard(my_mutex);
        cout << "thread_1:" << num++ << endl;
    }
}
void print2()
{
    for (int i = 0; i < 50; 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 0;
}

二、死锁

仅在存在两个互斥量以上才会出现死锁的现象。例如线程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 = 0;
mutex my_mutex1;    
mutex my_mutex2;
void print1()
{
    for (int i = 0; i < 500; i++)
    {
        my_mutex1.lock();
        /*这里同通常有一段代码，也是用来操作共享数据*/
        my_mutex2.lock();
        cout << "thread_1:" << num++ << endl;
        my_mutex1.unlock();
        my_mutex2.unlock();
    }
}
void print2()
{
    for (int i = 0; i < 500; 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 0;
}

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

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