1
#include <stdio.h>
2
#include <pthread.h>
3
#include <unistd.h>
4

5
// 定义两个互斥锁（相当于两把不同的钥匙）
6
pthread_mutex_t lock_documents;  // 证件锁
7
pthread_mutex_t lock_toolbox;    // 工具箱锁
8

9
void* homeowner_thread(void* arg) {
10
    printf("房主：我拿到了证件锁，现在需要工具箱锁来开箱子...\n");
11

12
    pthread_mutex_lock(&lock_documents);  // 房主先拿到证件锁
13
    sleep(1);  // 模拟一些处理时间
14

15
    printf("房主：尝试获取工具箱锁...\n");
16
    pthread_mutex_lock(&lock_toolbox);    // 这里会阻塞等待！
17

18
    printf("房主：成功拿到两把锁，可以开箱了！\n");
19

20
    // 工作完成后释放锁
21
    pthread_mutex_unlock(&lock_toolbox);
22
    pthread_mutex_unlock(&lock_documents);
23

24
    return NULL;
25
}
26

27
void* locksmith_thread(void* arg) {
28
    printf("开锁匠：我拿到了工具箱锁，现在需要查看证件...\n");
29

30
    pthread_mutex_lock(&lock_toolbox);    // 开锁匠先拿到工具箱锁
31
    sleep(1);  // 模拟一些处理时间
32

33
    printf("开锁匠：尝试获取证件锁来验证身份...\n");
34
    pthread_mutex_lock(&lock_documents);  // 这里也会阻塞等待！
35

36
    printf("开锁匠：成功拿到两把锁，可以验证身份了！\n");
37

38
    // 工作完成后释放锁
39
    pthread_mutex_unlock(&lock_documents);
40
    pthread_mutex_unlock(&lock_toolbox);
41

42
    return NULL;
43
}
44

45
int main() {
46
    pthread_t homeowner, locksmith;
47

48
    // 初始化互斥锁
49
    pthread_mutex_init(&lock_documents, NULL);
50
    pthread_mutex_init(&lock_toolbox, NULL);
51

52
    printf("=== 开始死锁演示 ===\n");
53

54
    // 创建两个线程
55
    pthread_create(&homeowner, NULL, homeowner_thread, NULL);
56
    pthread_create(&locksmith, NULL, locksmith_thread, NULL);
57

58
    // 等待线程结束（实际上会永远等待下去）
59
    pthread_join(homeowner, NULL);
60
    pthread_join(locksmith, NULL);
61

62
    printf("程序正常结束（这行永远不会执行到）\n");
63

64
    // 清理资源
65
    pthread_mutex_destroy(&lock_documents);
66
    pthread_mutex_destroy(&lock_toolbox);
67

68
    return 0;
69
}

1
#define _GNU_SOURCE
2
#include <stdio.h>
3
#include <pthread.h>
4
#include <unistd.h>
5
#include <sys/time.h>
6

7
pthread_mutex_t lock_documents = PTHREAD_MUTEX_INITIALIZER;
8
pthread_mutex_t lock_toolbox = PTHREAD_MUTEX_INITIALIZER;
9

10
// 清理处理函数
11
void cleanup_documents(void* arg) {
12
    printf("清理：释放证件锁\n");
13
    pthread_mutex_unlock(&lock_documents);
14
}
15

16
void cleanup_toolbox(void* arg) {
17
    printf("清理：释放工具箱锁\n");
18
    pthread_mutex_unlock(&lock_toolbox);
19
}
20

21
// 安全的锁获取函数（带超时和清理机制）
22
int safe_mutex_lock(pthread_mutex_t* lock, int timeout_sec) {
23
    struct timespec timeout;
24
    clock_gettime(CLOCK_REALTIME, &timeout);
25
    timeout.tv_sec += timeout_sec;
26

27
    return pthread_mutex_timedlock(lock, &timeout);
28
}
29

30
void* smart_homeowner_thread(void* arg) {
31
    printf("🏠 房主线程启动\n");
32

33
    // 设置清理处理函数
34
    pthread_cleanup_push(cleanup_documents, NULL);
35

36
    // 获取证件锁（带5秒超时）
37
    if (safe_mutex_lock(&lock_documents, 5) != 0) {
38
        printf("房主：获取证件锁超时！\n");
39
        pthread_cleanup_pop(0);
40
        return NULL;
41
    }
42

43
    printf("房主：已获得证件锁，正在尝试获取工具箱锁...\n");
44

45
    // 获取工具箱锁（带3秒超时）
46
    if (safe_mutex_lock(&lock_toolbox, 3) != 0) {
47
        printf("房主：获取工具箱锁超时，释放证件锁！\n");
48
        pthread_mutex_unlock(&lock_documents);
49
        pthread_cleanup_pop(0);
50
        return NULL;
51
    }
52

53
    printf("房主：🎉 成功获得两把锁，开始开箱工作！\n");
54
    sleep(2);  // 模拟工作
55
    printf("房主：工作完成！\n");
56

57
    // 释放锁
58
    pthread_mutex_unlock(&lock_toolbox);
59
    pthread_mutex_unlock(&lock_documents);
60

61
    pthread_cleanup_pop(0);  // 移除清理处理函数
62
    return NULL;
63
}
64

65
int main() {
66
    pthread_t thread1, thread2;
67

68
    printf("=== 智能死锁避免演示 ===\n");
69

70
    // 创建两个线程
71
    pthread_create(&thread1, NULL, smart_homeowner_thread, NULL);
72
    pthread_create(&thread2, NULL, smart_homeowner_thread, NULL);
73

74
    // 等待线程结束
75
    pthread_join(thread1, NULL);
76
    pthread_join(thread2, NULL);
77

78
    printf("=== 程序正常结束 ===\n");
79
    return 0;
80
}