将线程和锁构建图（后续通过检测环路以检测死锁）
流程
- 劫持pthread_mutex_lock/unlock，在加锁/解锁前后插入自定义逻辑。
- 分配并记录每个线程和互斥锁的ID，并映射到数组，方便查找。
- 构建有向图表示线程和锁的关系，持有：锁-->线程，请求：线程-->锁。
- 解锁时，清除图中关系并释放资源。
- 主线程创建4个线程，互相持有锁，进入死锁状态。
代码细节
- 函数劫持：用dlsym获取原版pthread_mutex_lock地址，并包装为函数，插入自定义内容。
- 映射数组：用两个数组分别记录锁和线程指针，下标即分配的ID。
- 创建节点：节点字段为ID（数组映射），next（下个节点的指针），flags（区分线程和锁）。
- 加锁：通过查看锁是否空闲判断应该是持有状态还是请求状态。
- 状态转换：通过该函数让锁从请求状态变为持有状态。
- 释放：额外维护节点数组，将从图中释放的节点回收到数组里，避免频繁malloc&free。
代码
#define _GNU_SOURCE #include <stdio.h> #include <unistd.h> #include <pthread.h> #include <dlfcn.h> #include <stdlib.h> #define MAX 100 struct lock_node_s; struct pthread_node_s; // 节点 struct node_s { size_t id; // 线程/锁ID struct node_s *next; // 锁指向下一个表示锁被线程持有，线程指向下一个表示线程请求锁 int flag; // 0--线程，1--锁 }; // 创建数组，专门用来记录线程/锁和它对应的ID--即下标 pthread_mutex_t *rlocks[MAX] = {NULL}; pthread_t rthreads[MAX] = {0}; // 存储节点数组 struct node_s *nodes[200] = {NULL}; // 创建数组，检查锁是否已经被占有 size_t lockarr[MAX] = {0}; struct Graph { struct node_s *nodearr[200]; // 前100是线程指向锁，后100是锁指向线程 }; struct Graph graph; // 线程请求锁，线程同时只能请求一个锁（等待被其他线程占有的锁释放） void Request(size_t pid, size_t lid) { if (nodes[pid] == NULL) { struct node_s *nodep = (struct node_s *)malloc(sizeof(struct node_s)); nodep->id = pid; nodep->next = NULL; nodep->flag = 0; nodes[pid] = nodep; } if (nodes[lid] == NULL) { struct node_s *nodel = (struct node_s *)malloc(sizeof(struct node_s)); nodel->id = lid; nodel->next = NULL; nodel->flag = 1; nodes[lid + 100] = nodel; } if (lockarr[lid] == 0) // 如果为0，表示锁没有被持有，那么线程就可以持有锁，即锁指向线程 { graph.nodearr[lid + 100] = nodes[lid + 100]; graph.nodearr[lid + 100]->next = nodes[pid]; nodes[lid + 100] = NULL; nodes[pid] = NULL; } else // 如果不为0，表示锁被持有，那么线程只能请求锁，即线程指向锁 { graph.nodearr[pid] = nodes[pid]; graph.nodearr[pid]->next = nodes[lid + 100]; nodes[lid + 100] = NULL; nodes[pid] = NULL; } } // 记录锁和线程对应的ID，并将他们添加到图里 void Record(pthread_t thid, pthread_mutex_t *mtx) { // 先判断是否存在，如果不存在则查找空余创建，index和flag记录第一个空白位置 int exist = 0, index = 0, flag = 1; int lid = 0; for (lid = 0; lid < MAX; lid++) { if (rlocks[lid] == mtx) { exist = 1; break; } if (flag && rlocks[lid] == NULL) { index = lid; flag = 0; } } if (!exist) { lid = index; rlocks[lid] = mtx; } exist = 0, flag = 1; int pid = 0; for (pid = 0; pid < MAX; pid++) { if (rthreads[pid] == thid) { exist = 1; break; } if (flag && rthreads[pid] == 0) { index = pid; flag = 0; } } if (!exist) { pid = index; rthreads[pid] = thid; } // 线程去请求锁 Request(pid, lid); } // 线程持有锁，锁只能被一个线程持有 void Hold(pthread_t thid, pthread_mutex_t *mtx) { int tid = 0; for (tid = 0; tid < MAX; tid++) { if (rthreads[tid] == thid) { break; } } int lid = 0; for (lid = 0; lid < MAX; lid++) { if (rlocks[lid] == mtx) { break; } } // 本来是线程指向锁，现在线程持有锁了，改为锁指向线程 graph.nodearr[lid + 100] = graph.nodearr[tid]->next; graph.nodearr[lid + 100]->next = graph.nodearr[tid]; graph.nodearr[tid]->next = NULL; graph.nodearr[tid] = NULL; lockarr[lid] = 1; } void Release(pthread_t thid, pthread_mutex_t *mtx) { int tid = 0; for (tid = 0; tid < MAX; tid++) { if (rthreads[tid] == thid) { break; } } int lid = 0; for (lid = 0; lid < MAX; lid++) { if (rlocks[lid] == mtx) { break; } } // 回收锁和其指向的节点 int index = graph.nodearr[lid + 100]->id; nodes[index + 100] = graph.nodearr[lid + 100]; if (graph.nodearr[lid + 100]->next != NULL) { index = graph.nodearr[lid + 100]->next->id; nodes[index] = graph.nodearr[lid + 100]->next; // 将图中节点置空 graph.nodearr[lid + 100]->next = NULL; } graph.nodearr[lid + 100] = NULL; } // 构建函数指针 typedef int (*pthread_mutex_lock_t)(pthread_mutex_t *mtx); pthread_mutex_lock_t pthread_mutex_lock_f; typedef int (*pthread_mutex_unlock_t)(pthread_mutex_t *mtx); pthread_mutex_unlock_t pthread_mutex_unlock_f; // 劫持函数 void init_hook(void) { if (!pthread_mutex_lock_f) { pthread_mutex_lock_f = dlsym(RTLD_DEFAULT, "pthread_mutex_lock"); } if (!pthread_mutex_unlock_f) { pthread_mutex_unlock_f = dlsym(RTLD_DEFAULT, "pthread_mutex_unlock"); } } // 用我们自己的锁函数，再通过劫持，就可以把原版锁函数添上我们自己的一些东西 void my_lock(pthread_mutex_t *mtx) { printf("加锁 %ld, %p\n", pthread_self(), mtx); Record(pthread_self(), mtx); pthread_mutex_lock_f(mtx); printf("持有\n"); Hold(pthread_self(), mtx); } void my_unlock(pthread_mutex_t *mtx) { printf("解锁 %ld, %p\n", pthread_self(), mtx); pthread_mutex_unlock_f(mtx); printf("释放\n"); Release(pthread_self(), mtx); } // 初始化锁 pthread_mutex_t mtx1 = PTHREAD_MUTEX_INITIALIZER; pthread_mutex_t mtx2 = PTHREAD_MUTEX_INITIALIZER; pthread_mutex_t mtx3 = PTHREAD_MUTEX_INITIALIZER; pthread_mutex_t mtx4 = PTHREAD_MUTEX_INITIALIZER; void *tb1(void *arg) { my_lock(&mtx1); sleep(1); my_lock(&mtx2); my_unlock(&mtx2); my_unlock(&mtx1); return NULL; } void *tb2(void *arg) { my_lock(&mtx2); sleep(1); my_lock(&mtx3); my_unlock(&mtx3); my_unlock(&mtx2); return NULL; } void *tb3(void *arg) { my_lock(&mtx3); sleep(1); my_lock(&mtx4); my_unlock(&mtx4); my_unlock(&mtx3); return NULL; } void *tb4(void *arg) { my_lock(&mtx4); sleep(1); my_lock(&mtx1); my_unlock(&mtx1); my_unlock(&mtx4); return NULL; } int main(int argc, char const *argv[]) { init_hook(); // 创建线程ID pthread_t t1, t2, t3, t4; // 创建线程 pthread_create(&t1, NULL, tb1, NULL); pthread_create(&t2, NULL, tb2, NULL); pthread_create(&t3, NULL, tb3, NULL); pthread_create(&t4, NULL, tb4, NULL); // 第二个函数表示线程那个函数的返回值 pthread_join(t1, NULL); pthread_join(t2, NULL); pthread_join(t3, NULL); pthread_join(t4, NULL); printf("complete\n"); return 0; }https://github.com/0voice