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

news2025/1/12 20:47:48

走近锁的世界

什么是锁
常用的锁
- 互斥量
- - 基本用法
- 无锁 CAS
死锁和避免死锁
- 死锁
- 避免死锁

什么是锁

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

小黑板：

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

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

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

在不上锁的情况下，这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时将会出现死锁，这称为嵌套锁。再比如本身有个锁还相互望着对方的锁的时候。
在这里插入图片描述

产生死锁的四个条件

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