死锁的发生是由于线程间资源争夺引起的，这里不对线程的死锁的概念和原理解释。主要介绍死锁的检测和具体实现，检测我们可以使用一个有向图来表示， 线程 A 获取线程 B 已占用的锁，则为线程 A 指向线程 B。 如何为线程 B 已占用的锁？运行过程线程 B 获取成功的锁。检测的原理采用另一个线程定时对图进程检测是否有环的存在。
数据结构定义:
typedef enum { PROCESS, RESOURCE} Type; // 定义资源的类型
typedef struct source_type_t { // 资源的数据结构
uint64 id;
Type type;
uint64 lock_id; //mutex的id
int degress; //加锁的次数
}source_type;
typedef struct vertex_t { // 图的一个节点
source_type s;
struct vertex_t *next; //指向下个图
}vertex;
typedef struct task_graph_t { // 图的数据结构
vertex list[MAX]; // 以一个链表的形式来存储
int num; // 图节点的个数
source_type locklist[MAX];
int lockidx; // 加锁成功后++
pthread_mutex_t mutex; //互斥锁
}task_graph;
图算法，检测是否有成环:
task_graph *tg = NULL; //全局图变量
int path[MAX+1]; // 把第几个图的type 的序号记录到path里面
int visited[MAX]; // 记录DFS 访问过的路径
int k = 0; // 记录path的个数
int deadlock = 0; //有环为1， 无为0
vertex *create_vertex(source_type type) { //分配vertex的空间
vertex *tex = (vertex*)malloc(sizeof(struct vertex_t));
tex->s = type;
tex->next = NULL;
return tex;
}
int search_vertex(source_type type) { // 搜索图，找到就返回序号
int i = 0;
for (i = 0; i<tg->num; i++) {
if (tg->list[i].s.type == type.type && tg->list[i].s.id == type.id)
return i;
}
return -1;
}
void add_vertex(source_type type) { // 添加vertex
if (search_vertex(type) == -1) {
tg->list[tg->num].s = type;
tg->list[tg->num].next = NULL;
tg->num++;
}
}
int add_edge(source_type from, source_type to) { //增加边
//add_vertex(from);
//add_vertex(to);
vertex *v = &(tg->list[search_vertex(from)]);
while( v->next != NULL) {
v = v->next;
}
v->next = create_vertex(to);
}
int verify_edge(source_type i, source_type j) { // 验证边
if (tg->num == 0) return 0;
int idx = search_vertex(i);
if (idx == -1) return 0;
vertex *v = &(tg->list[idx]);
while(v!=NULL) {
if (v->s.id == j.id) return 1;
v = v->next;
}
return 0;
}
int remove_edge(source_type from, source_type to) { //移除边
int idxi = search_vertex(from);
int idxj = search_vertex(to);
if (idxi != -1 && idxj != -1) {
vertex *v = &tg->list[idxi];
vertex *remove;
while (v->next != NULL) {
if (v->next->s.id == to.id) {
remove = v->next;
v->next = v->next->next;
free(remove);
break;
}
v = v->next;
}
}
}
void print_deadlock(void) { //打印
int i = 0;
printf("deadlock: ");
for ( i = 0; i<k-1; i++) {
printf("%ld --> ", tg->list[path[i]].s.id);
}
printf("%ld\n", tg->list[path[i]].s.id);
}
int DFS(int idx) {
vertex *ver = &tg->list[idx];
if (visited[idx] == 1) { // 找过了
path[k++] = idx;
print_deadlock();
deadlock = 1;
return 0;
}
visited[idx] = 1; //标记找过
path[k++] = idx;
while (ver->next != NULL) {
DFS(search_vertex(ver->next->s));
k --;
ver = ver->next;
}
return 1;
}
int search_for_cycle(int idx) { //搜索是否有成环
vertex *ver = &tg->list[idx];
visited[idx] = 1;
k = 0;
path[k++] = idx;
while (ver->next != NULL) {
int i = 0;
for (i = 0;i < tg->num;i ++) {
if (i == idx) continue;
visited[i] = 0;
}
for (i = 1;i <= MAX;i ++) {
path[i] = -1;
}
k = 1;
DFS(search_vertex(ver->next->s));
ver = ver->next;
}
}
int main() {
tg = (struct task_graph*)malloc(sizeof(struct task_graph_t));
tg->num = 0;
struct source_type v1;
v1.id = 1;
v1.type = PROCESS;
add_vertex(v1);
struct source_type v2;
v2.id = 2;
v2.type = PROCESS;
add_vertex(v2);
struct source_type v3;
v3.id = 3;
v3.type = PROCESS;
add_vertex(v3);
struct source_type v4;
v4.id = 4;
v4.type = PROCESS;
add_vertex(v4);
struct source_type v5;
v5.id = 5;
v5.type = PROCESS;
add_vertex(v5);
add_edge(v1, v2);
add_edge(v2, v3);
add_edge(v3, v4);
add_edge(v4, v5);
add_edge(v3, v1);
search_for_cycle(search_vertex(v1));
}
图算法的测试入口函数 :增加了线程
void check_dead_lock(void) {
int i = 0;
deadlock = 0;
for (i = 0; i < tg->num; i++) {
if (deadlock == 1) break;
search_for_cycle(i);
}
if (deadlock == 0)
printf("no deadlock\n");
}
static void *thread_routine(void *args) {
while (1) {
sleep(5);
check_dead_lock();
}
}
void start_check(void) {
tg = (task_graph *)malloc(sizeof(struct task_graph_t));
tg->num = 0;
tg->lockidx = 0;
pthread_t tid;
pthread_create(&tid, NULL, thread_routine, NULL);
}
int search_lock(uint64 lock) {
int i = 0;
for (i = 0;i < tg->lockidx;i ++) {
if (tg->locklist[i].lock_id == lock) {
return i;
}
}
return -1;
}
int search_empty_lock(uint64 lock) {
int i = 0;
for (i = 0;i < tg->lockidx;i ++) {
if (tg->locklist[i].lock_id == 0) {
return i;
}
}
return tg->lockidx;
}
int inc(int *value, int add) { // 原子操作
int old;
__asm__ volatile(
"lock;xaddl %2, %1;"
: "=a"(old)
: "m"(*value), "a" (add)
: "cc", "memory"
);
return old;
}
void print_locklist(void) {
int i = 0;
printf("print_locklist: \n");
printf("---------------------\n");
for (i = 0;i < tg->lockidx;i ++) {
printf("threadid : %ld, lockid: %ld\n", tg->locklist[i].id, tg->locklist[i].lock_id);
}
printf("---------------------\n\n\n");
}
void lock_before(uint64 thread_id, uint64 lockaddr) {
int idx = 0;
// list<threadid, toThreadid>
for(idx = 0;idx < tg->lockidx;idx ++) {
if ((tg->locklist[idx].lock_id == lockaddr)) {
source_type from;
from.id = thread_id;
from.type = PROCESS;
add_vertex(from);
source_type to;
to.id = tg->locklist[idx].id;
tg->locklist[idx].degress++;
to.type = PROCESS;
add_vertex(to);
if (!verify_edge(from, to)) {
add_edge(from, to);
}
}
}
}
void lock_after(uint64 thread_id, uint64 lockaddr) {
int idx = 0;
if (-1 == (idx = search_lock(lockaddr))) { // lock list opera
int eidx = search_empty_lock(lockaddr);
tg->locklist[eidx].id = thread_id;
tg->locklist[eidx].lock_id = lockaddr;
inc(&tg->lockidx, 1);
} else {
source_type from;
from.id = thread_id;
from.type = PROCESS;
source_type to;
to.id = tg->locklist[idx].id;
tg->locklist[idx].degress --;
to.type = PROCESS;
if (verify_edge(from, to))
remove_edge(from, to);
tg->locklist[idx].id = thread_id;
}
}
void unlock_after(uint64 thread_id, uint64 lockaddr) {
int idx = search_lock(lockaddr);
if (tg->locklist[idx].degress == 0) {
tg->locklist[idx].id = 0;
tg->locklist[idx].lock_id = 0;
//inc(&tg->lockidx, -1);
}
}
int pthread_mutex_lock(pthread_mutex_t *mutex) {
pthread_t selfid = pthread_self(); //
lock_before(selfid, (uint64)mutex);
pthread_mutex_lock_f(mutex);
lock_after(selfid, (uint64)mutex);
}
int pthread_mutex_unlock(pthread_mutex_t *mutex) {
pthread_t selfid = pthread_self();
pthread_mutex_unlock_f(mutex);
unlock_after(selfid, (uint64)mutex);
}
static int init_hook() { //使用hook 重定向lock, unlock函数
pthread_mutex_lock_f = dlsym(RTLD_NEXT, "pthread_mutex_lock");
pthread_mutex_unlock_f = dlsym(RTLD_NEXT, "pthread_mutex_unlock");
}
pthread_mutex_t mutex_1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex_2 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex_3 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex_4 = PTHREAD_MUTEX_INITIALIZER;
void *thread_rountine_1(void *args)
{
pthread_t selfid = pthread_self(); //
pthread_mutex_lock(&mutex_1);
sleep(1);
pthread_mutex_lock(&mutex_2);
pthread_mutex_unlock(&mutex_2);
pthread_mutex_unlock(&mutex_1);
return (void *)(0);
}
void *thread_rountine_2(void *args)
{
pthread_t selfid = pthread_self(); //
pthread_mutex_lock(&mutex_2);
sleep(1);
pthread_mutex_lock(&mutex_3);
pthread_mutex_unlock(&mutex_3);
pthread_mutex_unlock(&mutex_2);
return (void *)(0);
}
void *thread_rountine_3(void *args)
{
pthread_t selfid = pthread_self(); //
pthread_mutex_lock(&mutex_3);
sleep(1);
pthread_mutex_lock(&mutex_4);
pthread_mutex_unlock(&mutex_4);
pthread_mutex_unlock(&mutex_3);
return (void *)(0);
}
void *thread_rountine_4(void *args)
{
pthread_t selfid = pthread_self(); //
pthread_mutex_lock(&mutex_4);
sleep(1);
pthread_mutex_lock(&mutex_3);
pthread_mutex_unlock(&mutex_3);
pthread_mutex_unlock(&mutex_4);
return (void *)(0);
}
int main()
{
init_hook();
start_check();
pthread_t tid1, tid2, tid3, tid4;
pthread_create(&tid1, NULL, thread_rountine_1, NULL);
pthread_create(&tid2, NULL, thread_rountine_2, NULL);
pthread_create(&tid3, NULL, thread_rountine_3, NULL);
pthread_create(&tid4, NULL, thread_rountine_4, NULL);
pthread_join(tid1, NULL);
pthread_join(tid2, NULL);
pthread_join(tid3, NULL);
pthread_join(tid4, NULL);
return 0;
}
代码比较简单，就不详细解释了。
编译:
gcc -o deadlock deadlock.c -ldl -lpthread
完整的代码见:
扫一扫
692
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
