C++新特性33_死锁产生的原因及避免（线程在等待一个永远都不能成功的条件成立，从而进入到陷入休眠，永远不能被唤醒的状态；通过调整锁的使用顺序解决死锁问题）

上篇：C++新特性32_C++中mutex与lock_guard的使用（采用上篇类似方法封装至C++的标准库中）讲了在C++标准库中实现线程锁的方法，本篇主要介绍在使用多线程的过程中常遇到的死锁问题。

1. 死锁及产生原因

线程（程序）在等待一个永远都不能成功的条件成立，从而进入到陷入休眠，永远不能被唤醒的状态。

举例1：两个线程互相等待
原理：线程A获取锁1，只有锁2被线程B释放才可以获取锁2，线程B获取锁2，只有锁1被线程A释放才可以获取锁1，双方不断的在等待对方释放锁，但一直等不到对方释放。

线程A： 
    获取锁1，等待锁2
线程B：
    获取锁2，等待锁1

实例：使用sleep_for实现线程的切换运行，是的AB线程分别获得锁1和2，sleep_for相当于C++中的sleep()

// TestC11.cpp : 定义控制台应用程序的入口点。
//

//#include "stdafx.h"
#include <iostream>           // std::cout
#include <thread>             // std::thread
#include <mutex>              // std::mutex, std::unique_lock
#include <Windows.h>
#include <tchar.h>

// 锁资源1
std::mutex mtx1;

// 锁资源2
std::mutex mtx2;

// 线程A的回调函数
void taskA()
{
	// 保证线程A先获取锁1
	std::lock_guard<std::mutex> lockA(mtx1);
	std::cout << "线程A获取锁1" << std::endl;

	// 线程A睡眠2s再获取锁2，保证锁2先被线程B获取，模拟死锁问题的发生
	//等价于sleep(2000)，等待过程中操作系统会选择合适的线程去跑
	std::this_thread::sleep_for(std::chrono::seconds(2));

	// 线程A尝试获取锁2，此时线程B已被锁2占有
	std::lock_guard<std::mutex> lockB(mtx2);
	std::cout << "线程A获取锁2" << std::endl;

	std::cout << "线程A释放所有锁资源，结束运行！" << std::endl;
}

// 线程B的回调函数
void taskB()
{
	// 线程B先睡眠1s保证线程A先获取锁1
	std::this_thread::sleep_for(std::chrono::seconds(1));
	std::lock_guard<std::mutex> lockB(mtx2);
	std::cout << "线程B获取锁2" << std::endl;

	// 线程B尝试获取锁1，此时线程A已被锁2占有
	std::lock_guard<std::mutex> lockA(mtx1);
	std::cout << "线程B获取锁1" << std::endl;

	std::cout << "线程B释放所有锁资源，结束运行！" << std::endl;
}

int _tmain(int argc, _TCHAR* argv[])
{

	std::thread t1(taskA);
	std::thread t2(taskB);

	// main主线程等待所有子线程执行完
	t1.join();
	t2.join();

	return 0;
}

运行结果：程序不能正常退出，卡在下图界面中，陷入死锁状态

以上便是编程中可能出现的情况。

2. 死锁的解决办法

注意使用锁的顺序

线程A： 
    获取锁1，等待锁2
线程B：
    获取锁1，等待锁2

线程A获得锁1，线程B想要再获得锁1只能等到线程A运行完释放锁1，同理线程A也是，这样就实现了解锁的目的。

// TestC11.cpp : 定义控制台应用程序的入口点。
//

//#include "stdafx.h"
#include <iostream>           // std::cout
#include <thread>             // std::thread
#include <mutex>              // std::mutex, std::unique_lock
#include <Windows.h>
#include <tchar.h>

// 锁资源1
std::mutex mtx1;

// 锁资源2
std::mutex mtx2;

// 线程A的回调函数
void taskA()
{
	// 保证线程A先获取锁1
	std::lock_guard<std::mutex> lockA(mtx1);
	std::cout << "线程A获取锁1" << std::endl;

	// 线程A睡眠2s再获取锁2，保证锁2先被线程B获取，模拟死锁问题的发生
	std::this_thread::sleep_for(std::chrono::seconds(2));

	// 线程A先获取锁2
	std::lock_guard<std::mutex> lockB(mtx2);
	std::cout << "线程A获取锁2" << std::endl;

	std::cout << "线程A释放所有锁资源，结束运行！" << std::endl;
}

// 线程B的回调函数
void taskB()
{
	// 线程B先睡眠1s保证线程A先获取锁1
	std::this_thread::sleep_for(std::chrono::seconds(1));
	std::lock_guard<std::mutex> lockB(mtx1);
	std::cout << "线程B获取锁2" << std::endl;

	// 线程B尝试获取锁1
	std::lock_guard<std::mutex> lockA(mtx2);
	std::cout << "线程B获取锁1" << std::endl;

	std::cout << "线程B释放所有锁资源，结束运行！" << std::endl;
}

int _tmain(int argc, _TCHAR* argv[])
{

	std::thread t1(taskA);
	std::thread t2(taskB);

	// main主线程等待所有子线程执行完
	t1.join();
	t2.join();

	return 0;
}

运行结果：线程A运行结束再运行线程B

实际编码时很难注意到这种顺序，碰到时需要进行调试，也有第三方工具帮助检查。

3. 学习视频地址： 死锁产生的原因及避免

4.问题

请你介绍一下死锁，产生的必要条件，产生的原因，怎么预防死锁？
得分点
争夺共享资源、相互等待、互斥条件、请求和保持条件、不剥夺条件、环路等待条件、竞争资源、进程间推进顺序非法、有序资源分配法、银行家算法

标准回答

1. 死锁 两个或两个以上的进程在执行过程中，因争夺共享资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁。这些永远在互相等待的进程称为死锁进程。
2. 产生死锁的必要条件 虽然进程在运行过程中，可能发生死锁，但死锁的发生也必须具备一定的条件，死锁的发生必须具备以下四个必要条件： - 互斥条件：指进程对所分配到的资源进行排它性使用，即在一段时间内某资源只由一个进程占用。如果此时还有其它进程请求资源，则请求者只能等待，直至占有资源的进程用毕释放； - 请求和保持条件：指进程已经保持至少一个资源，但又提出了新的资源请求，而该资源已被其它进程占有，此时请求进程阻塞，但又对自己已获得的其它资源保持不放； - 不剥夺条件：指进程已获得的资源，在未使用完之前，不能被剥夺，只能在使用完时由自己释放； - 环路等待条件：指在发生死锁时，必然存在一个进程——资源的环形链，即进程集合 {P0，P1，P2，···，Pn} 中的 P0 正在等待一个 P1 占用的资源；P1 正在等待 P2 占用的资源，……，Pn 正在等待已被 P0 占用的资源。
3. 产生死锁的原因 - 竞争资源 - 进程间推进顺序非法
4. 预防死锁 - 有序资源分配法 - 银行家算法