掌握死锁检测：策略和最佳实践

举报
Lion Long 发表于 2023/10/12 21:54:39 2023/10/12
【摘要】 "掌握死锁检测：策略和最佳实践"是一个关于死锁检测的重要主题。在这篇文章中，我们将深入探讨死锁检测的策略和最佳实践，帮助读者全面了解如何有效地检测和解决死锁问题。我们将介绍不同的死锁检测算法和技术，并提供实际案例和示例代码，以帮助读者更好地理解和应用这些策略和实践。无论您是初学者还是经验丰富的开发人员，本文都将为您提供宝贵的见解和实用的建议，让您能够掌握死锁检测并在实际项目中取得成功。

一、背景：死锁产生原因

死锁，是指多个线程或者进程在运行过程中因争夺资源而造成的一种僵局，当进程或者线程处于这种僵持状态，若无外力作用，它们将无法再向前推进。
如下图所示，线程 A 想获取线程 B 的锁，线程 B 想获取线程 C 的锁，线程 C 想获取线程 D 的锁，线程 D 想获取线程 A 的锁，从而构建了一个资源获取环。

如果有两个及以上的CPU占用率达到100%时，极可能是程序进入死锁状态。

死锁的存在是因为有资源获取环的存在，所以只要能检测出资源获取环，就等同于检测出死锁的存在。

1.1、构建一个死锁

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>


pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex3 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex4 = PTHREAD_MUTEX_INITIALIZER;

void *thread_funcA(void *arg)
{
	pthread_mutex_lock(&mutex1);
	sleep(1);
	pthread_mutex_lock(&mutex2);

	printf("funcA --> \n");

	pthread_mutex_unlock(&mutex2);
	pthread_mutex_unlock(&mutex1);
}

void *thread_funcB(void *arg)
{
	pthread_mutex_lock(&mutex2);
	sleep(1);
	pthread_mutex_lock(&mutex3);

	printf("funcB --> \n");

	pthread_mutex_unlock(&mutex3);
	pthread_mutex_unlock(&mutex2);
}

void *thread_funcC(void *arg)
{
	pthread_mutex_lock(&mutex3);
	sleep(1);
	pthread_mutex_lock(&mutex4);

	printf("funcC --> \n");

	pthread_mutex_unlock(&mutex4);
	pthread_mutex_unlock(&mutex3);
}

void *thread_funcD(void *arg)
{
	pthread_mutex_lock(&mutex4);
	sleep(1);
	pthread_mutex_lock(&mutex1);

	printf("funcD --> \n");

	pthread_mutex_unlock(&mutex1);
	pthread_mutex_unlock(&mutex4);
}


int main()
{
	pthread_t tid[4] = { 0 };
	
	pthread_create(&tid[0], NULL, thread_funcA, NULL);
	pthread_create(&tid[1], NULL, thread_funcB, NULL);
	pthread_create(&tid[2], NULL, thread_funcC, NULL);
	pthread_create(&tid[3], NULL, thread_funcD, NULL);

	pthread_join(tid[0], NULL);
	pthread_join(tid[1], NULL);
	pthread_join(tid[2], NULL);
	pthread_join(tid[3], NULL);

	return 0;
}

二、使用hook检测死锁

hook使用场景：
（1）实现自己的协议栈，通过hook posix api。

2.1、dlsym()函数

获取共享对象或可执行文件中符号的地址。
函数原型：

#include <dlfcn.h>

void *dlsym(void *handle, const char *symbol);

#define _GNU_SOURCE
#include <dlfcn.h>

void *dlvsym(void *handle, char *symbol, char *version);

// Link with -ldl.

描述：
函数dlsym()接受dlopen()返回的动态加载共享对象的“句柄”以及以空结尾的符号名，并返回该符号加载到内存中的地址。如果在指定对象或加载对象时dlopen()自动加载的任何共享对象中找不到该符号，dlsym()将返回NULL。（dlsym()执行的搜索是通过这些共享对象的依赖关系树进行的广度优先搜索。）

由于符号的值实际上可能是NULL（因此，dlsym()的NULL返回值不必指示错误），因此测试错误的正确方法是调用dlerror()以清除任何旧的错误条件，然后调用dlsym。

handle中可以指定两个特殊的伪句柄：

代码 含义
RTLD_DEFAULT 使用默认共享对象搜索顺序查找所需符号的第一个匹配项。搜索将包括可执行文件及其依赖项中的全局符号，以及使用RTLD_GLOBAL标志动态加载的共享对象中的符号。
RTLD_NEXT 在当前对象之后，按搜索顺序查找所需符号的下一个匹配项。这允许在另一个共享对象中为函数提供包装，例如，预加载共享对象中的函数定义可以查找并调用另一共享对象中提供的“真实”函数（或者在预加载有多层的情况下，函数的“下一个”定义）。

函数dlvsym（）的作用与dlsym（）相同，但使用版本字符串作为附加参数。

返回值：
成功时，这些函数返回与符号关联的地址。
失败时，返回NULL；可以使用dlerror()诊断错误的原因。

2.2、pthread_self()函数

获取调用线程的ID。
函数原型：

#include <pthread.h>

pthread_t pthread_self(void);

// Compile and link with -pthread.

说明：
函数的作用是返回调用线程的ID。这与创建此线程的pthread_create()调用中*thread中返回的值相同。

返回值：

此函数始终成功，返回调用线程的ID。

2.3、实现步骤

（1）构建函数指针
（2）定义与目标函数一样的类型

typedef int(*pthread_mutex_lock_t)(pthread_mutex_t *mutex);
typedef int(*pthread_mutex_unlock_t)(pthread_mutex_t *mutex);

pthread_mutex_lock_t	pthread_mutex_lock_f;
pthread_mutex_unlock_t	pthread_mutex_unlock_f;

（3）具体函数实现，函数名与目标函数名一致

int pthread_mutex_lock(pthread_mutex_t *mutex)
{
	pthread_t selfid = pthread_self();

	printf("pthread_mutex_lock: %ld, %p\n", selfid, mutex);
	// ...
	return 0;
}

int pthread_mutex_unlock(pthread_mutex_t *mutex)
{
	pthread_t selfid = pthread_self();

	printf("pthread_mutex_unlock: %ld, %p\n", selfid, mutex);
	// ...
	return 0;
}

（4）调用dlsym()函数，即钩子。

int init_hook()
{
	pthread_mutex_lock_f = dlsym(RTLD_NEXT, "pthread_mutex_lock");
	pthread_mutex_unlock_f = dlsym(RTLD_NEXT, "pthread_mutex_unlock");
	// ...
	return 0;
}

2.4、示例代码

#define _GNU_SOURCE
#include <dlfcn.h>


#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>


typedef int(*pthread_mutex_lock_t)(pthread_mutex_t *mutex);
typedef int(*pthread_mutex_unlock_t)(pthread_mutex_t *mutex);

pthread_mutex_lock_t	pthread_mutex_lock_f;
pthread_mutex_unlock_t	pthread_mutex_unlock_f;

int pthread_mutex_lock(pthread_mutex_t *mutex)
{
	pthread_t selfid = pthread_self();

	pthread_mutex_lock_f(mutex);
	printf("pthread_mutex_lock: %ld, %p\n", selfid, mutex);
	
	return 0;
}

int pthread_mutex_unlock(pthread_mutex_t *mutex)
{
	pthread_t selfid = pthread_self();

	pthread_mutex_unlock_f(mutex);
	printf("pthread_mutex_unlock: %ld, %p\n", selfid, mutex);

	return 0;
}

int init_hook()
{
	pthread_mutex_lock_f = dlsym(RTLD_NEXT, "pthread_mutex_lock");
	pthread_mutex_unlock_f = dlsym(RTLD_NEXT, "pthread_mutex_unlock");
	return 0;
}

#if 1 // debug

pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex3 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex4 = PTHREAD_MUTEX_INITIALIZER;

void *thread_funcA(void *arg)
{
	pthread_mutex_lock(&mutex1);
	sleep(1);
	pthread_mutex_lock(&mutex2);

	printf("funcA --> \n");

	pthread_mutex_unlock(&mutex2);
	pthread_mutex_unlock(&mutex1);
}

void *thread_funcB(void *arg)
{
	pthread_mutex_lock(&mutex2);
	sleep(1);
	pthread_mutex_lock(&mutex3);

	printf("funcB --> \n");

	pthread_mutex_unlock(&mutex3);
	pthread_mutex_unlock(&mutex2);
}

void *thread_funcC(void *arg)
{
	pthread_mutex_lock(&mutex3);
	sleep(1);
	pthread_mutex_lock(&mutex4);

	printf("funcC --> \n");

	pthread_mutex_unlock(&mutex4);
	pthread_mutex_unlock(&mutex3);
}

void *thread_funcD(void *arg)
{
	pthread_mutex_lock(&mutex4);
	sleep(1);
	pthread_mutex_lock(&mutex1);

	printf("funcD --> \n");

	pthread_mutex_unlock(&mutex1);
	pthread_mutex_unlock(&mutex4);
}


int main()
{

	init_hook();

	pthread_t tid[4] = { 0 };
	
	pthread_create(&tid[0], NULL, thread_funcA, NULL);
	pthread_create(&tid[1], NULL, thread_funcB, NULL);
	pthread_create(&tid[2], NULL, thread_funcC, NULL);
	pthread_create(&tid[3], NULL, thread_funcD, NULL);

	pthread_join(tid[0], NULL);
	pthread_join(tid[1], NULL);
	pthread_join(tid[2], NULL);
	pthread_join(tid[3], NULL);

	return 0;
}

#endif

缺点：这种方式在少量锁情况下还可以分析，在大量锁使用的情况，分析过程极为困难。

三、使用图算法检测死锁

死锁检测可以利用图算法，检测有向图是否有环。

3.1、图的构建

（1）矩阵

指向 1 指向 2 指向 3 指向 …
节点 1
节点 2
节点 3
节点 …

（2）邻接表
数据结构原理示意图：


“图”连接：

3.2、图的使用

先新增节点再新增边。
（1）每创建一个线程，新增一个节点；注意，不是线程创建的时候就要加节点（有些线程不会用到锁），而是线程调用锁（以互斥锁为例，pthread_mutex_lock() ）的时候才添加节点。
（2）线程加锁（以互斥锁为例，pthread_mutex_lock() ）的时候，并且检测到锁已经占用，则新增一条边。
（3）移除边，调用锁（以互斥锁为例，pthread_mutex_lock() ）前，如果此时锁没有被占用，并且该边存在，则移除边。
（4）移除节点是在解锁之后。

三个原语操作：
（1）加锁之前的操作，lock_before()；
（2）加锁之后的操作，lock_after()；
（3）解锁之后的操作，unlock_after()；

3.3、示例代码

代码比较长，为了避免篇幅较长，不利于阅读，这里没有贴上。如果需要，可以联系博主，或者关注微信公众号 《Lion 莱恩呀》 获取。

总结

死锁的产生是因为多线程之间存在交叉申请锁的情况，因争夺资源而造成的一种僵局。
hook使用：
（1）定义与目标函数一样的类型；
（2）具体函数实现，函数名与目标函数名一致；
（3）调用dlsym()函数，初始化hook。

死锁检测可以使用图算法，通过检测有向图是否有环判断是否有死锁。

欢迎关注公众号《Lion 莱恩呀》学习技术，每日推送文章。在这里插入图片描述

【版权声明】本文为华为云社区用户原创内容，未经允许不得转载，如需转载请自行联系原作者进行授权。如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱： cloudbbs@huaweicloud.com
C++ Linux 任务调度 数据结构 管理检测与响应
  • 点赞
  • 收藏
  • 关注作者

评论（0）

0/1000
抱歉，系统识别当前为高风险访问，暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称，即可参与社区互动！

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

确认 取消

加入云驻计划，成为创作者

  • 华为云周边好礼
  • 免费体验产品
  • 特殊身份标识
  • 线下官方门票
  • 内部专家零距离
  • 与10000+优质创作者共同成长
立即加入