常用的锁和死锁以及避免死锁

什么是锁

  在并发编程中，为了保护多线程同时访问的共享数据，以及避免出现意向不到的结果，锁（应运而生）
 简单讲下为什么数据结果有时候会与设想不一致。那就要先了解下原子性、临界区

小黑板：

• 原子性：
  指事务的不可分割性，一个事务的所有操作要么不间断地全部被执行，要么一个也没有执行。概括起来就是，执行了就执行完，不能被打断
• 临界区：
  一个访问共用资源（例如：共用设备或是共用存储器）的程序片段，而这些共用资源又无法同时被多个线程访问的特性。

 以++i为例，指对变量i做+1的操作。看起来是一句话，实际上在汇编运行中会变成如下三个步骤

1. 把i加载到寄存器
2. 对i进行+1操作
3. 把计算结果放回内存

 在不上锁的情况下，这3个步骤在并发编程中是会被打断的，也就是创建了10个线程，每个线程跑1000次的话最后结果不一定为10000。故为了保证一体，我们将把它锁死。

常用的锁

名称	说明	使用场景
互斥量 mutex	获取不到锁的时候就休眠，让出CPU。等待锁被唤醒	适用于临界区正常的情况，以下两种不适应的情况
自旋锁 spinlock	获取不到锁的时候，继续检测，空耗CPU	适用于并发度不是特别高的场景，以及临界区比较短小的情况，利用避免线程切换来提高效率
无锁CAS	依赖于CPU的原子性指令实现，在硬件上、寄存器上进行阻塞	比较和交换，适用于队列放入和读取非常频繁时

互斥量

基本用法

以下代码通过lock和unlock去上锁和解锁

#include <iostream>
#include <mutex>
#include <thread>
#include <chrono>

using namespace std;

std::mutex g_lock;	// 声明一个锁	

void func()
{
	g_lock.lock();
	std::out << "entered thread " << std::this_thread::get_id() << std::endl;
	std::this_thread::sleep_for(std::chrono::seconds(1);
	std::out << "entered thread " << std::this_thread::get_id() << std::endl;
	std::this_thread::sleep_for(std::chrono::seconds(1);
	std::out << "entered thread " << std::this_thread::get_id() << std::endl;
	g_lock.unlock();
}

int main()
{
thread t1(func);
thread t2(func);
thread t3(func);

t1.join();
t2.join();
t3.join();

return 0;
}

 当然我们可以使用lock_guard来简化写法，该写法可以在作用区间内自动锁定互斥量，并在退出作用域自动释放。避免忘记了unlock操作。
 demo如下:

void func()
{
	std::lock_guard<std::mutex> lock(g_lock);
	std::out << "entered thread " << std::this_thread::get_id() << std::endl;
	std::this_thread::sleep_for(std::chrono::seconds(1);
	std::out << "entered thread " << std::this_thread::get_id() << std::endl;
	std::this_thread::sleep_for(std::chrono::seconds(1);
	std::out << "entered thread " << std::this_thread::get_id() << std::endl;
}

无锁 CAS

CAS（compare and swap）：比较和交换，

• 原型

bool __sync_bool_compare_and_swap(int *paddr, int nExpected, int new);

• 描述
  通过比较paddr所指向内存的值是否与期望值（nExpected）是否一致，从而决定是否替换为new值；一致则替换成new值。

• demo

int oldNum = 2;
do
{
oldNum ++;
}while(! __sync_bool_compare_and_swap(&oldNum, 3, 2))

死锁和避免死锁

死锁

 死锁不是锁的一种，死锁指的是两个或多个进程（线程）在执行过程中，因争夺资源或彼此通信而导致的一种互相等待的现象。
 比如同一个线程中使用多个锁的时候，例如

#include <iostream>
#include <mutex>

using namespace std;

std::mutex mutex;
int max(int a, int b)
{
	lock_guard<mutex> lock(mutex);
	return a > b ? a : b;
}

void testMax()
{
	lock_guard<mutex> lock(mutex);
	max(5, 6);
	return 0;
}

void main()
{
	testMax();
}

以上，在调用testMax时将会出现死锁，这称为嵌套锁。再比如本身有个锁还相互望着对方的锁的时候。

产生死锁的四个条件

• 互斥条件：在一段时间内某资源只由一个进程占用
• 请求与保持条件：一个线程因请求资源而阻塞时，对已获得的资源保持不放。
• 不剥夺条件：线程已获得的资源在未使用完之前不能被其他线程强行剥夺，只有自己使用完毕后才释放资源。
• 循环等待条件：在发生死锁时，必然存在一个进程——资源的环形链，在循环的等待资源

避免死锁

如何预防和避免线程死锁?

• 破坏请求与保持条件 ：一次性申请所有的资源。
• 破坏不剥夺条件 ：占用部分资源的线程进一步申请其他资源时，如果申请不到，可以主动释放它占有的资源。
• 破坏循环等待条件 ：靠按序申请资源来预防。按某一顺序申请资源，释放资源则反序释放。

避免死锁的实际方法包括但不限于以下几种

1. 避免使用共享资源，定期释放锁。
2. 线程按照一定的顺序来申请多个资源，按照固定的顺序申请和释放锁。
3. 避免嵌套锁，即避免在一个已经持有锁的代码块中再次获取锁。
4. 使用锁的分级策略，先申请低级别的锁，再申请高级别的锁。
5. 使用死锁检测和恢复机制，检测是否发生死锁，如果发生，则采取措施恢复程序的执行，例如释放不必要的锁或重新调度线程等。