1
#include <pthread.h>  // 线程相关函数
2
#include <stdio.h>    // 标准输入输出
3
#include <unistd.h>   // Unix标准函数（如sleep）

1
pthread_cond_t cond;      // 条件变量
2
pthread_mutex_t mutex;    // 互斥锁

1
// 初始化
2
pthread_mutex_init(&mutex, NULL);
3
pthread_cond_init(&cond, NULL);
4

5
// 使用后销毁
6
pthread_mutex_destroy(&mutex);
7
pthread_cond_destroy(&cond);

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

5
// 全局变量
6
pthread_cond_t friend_arrived;  // 朋友到达的条件变量
7
pthread_mutex_t lock;           // 互斥锁
8
int is_friend_here = 0;         // 朋友是否到达的标志
9

10
// 等待朋友的线程函数
11
void* wait_for_friend(void* arg) {
12
    pthread_mutex_lock(&lock);  // 获取锁
13

14
    printf("👦 我在餐厅等待朋友...\n");
15

16
    // 等待朋友到达的条件
17
    while (!is_friend_here) {
18
        printf("⏳ 朋友还没到，继续等待...\n");
19
        pthread_cond_wait(&friend_arrived, &lock);  // 等待条件成立
20
    }
21

22
    printf("🎉 朋友到了！可以开始吃饭了！\n");
23

24
    pthread_mutex_unlock(&lock);  // 释放锁
25
    return NULL;
26
}
27

28
// 朋友到达的线程函数
29
void* friend_arrive(void* arg) {
30
    sleep(3);  // 模拟朋友在路上花费的时间
31

32
    pthread_mutex_lock(&lock);
33

34
    printf("🚗 朋友到达餐厅了！\n");
35
    is_friend_here = 1;  // 设置朋友已到达的标志
36

37
    pthread_cond_signal(&friend_arrived);  // 通知等待的线程
38
    printf("📞 通知朋友：我到了！\n");
39

40
    pthread_mutex_unlock(&lock);
41
    return NULL;
42
}
43

44
int main() {
45
    // 初始化
46
    pthread_mutex_init(&lock, NULL);
47
    pthread_cond_init(&friend_arrived, NULL);
48

49
    pthread_t waiter, arriver;
50

51
    // 创建等待线程和朋友线程
52
    pthread_create(&waiter, NULL, wait_for_friend, NULL);
53
    pthread_create(&arriver, NULL, friend_arrive, NULL);
54

55
    // 等待线程结束
56
    pthread_join(waiter, NULL);
57
    pthread_join(arriver, NULL);
58

59
    // 清理资源
60
    pthread_mutex_destroy(&lock);
61
    pthread_cond_destroy(&friend_arrived);
62

63
    return 0;
64
}

1
// 创建5个等待线程
2
pthread_t threads[5];
3
for (int i = 0; i < 5; i++) {
4
    pthread_create(&threads[i], NULL, worker_thread, (void*)(long)i);
5
}
6

7
// 主线程控制唤醒
8
while (1) {
9
    printf("选择唤醒方式：\n");
10
    printf("1 - 唤醒一个线程\n");
11
    printf("2 - 唤醒所有线程\n");
12
    printf("0 - 退出\n");
13

14
    int choice;
15
    scanf("%d", &choice);
16

17
    pthread_mutex_lock(&lock);
18

19
    switch (choice) {
20
        case 1:
21
            // 唤醒一个等待的线程
22
            pthread_cond_signal(&cond);
23
            printf("🔔 唤醒了一个线程\n");
24
            break;
25

26
        case 2:
27
            // 唤醒所有等待的线程
28
            pthread_cond_broadcast(&cond);
29
            printf("📢 唤醒了所有线程\n");
30
            break;
31

32
        case 0:
33
            should_exit = 1;
34
            pthread_cond_broadcast(&cond);  // 唤醒所有线程以便退出
35
            break;
36
    }
37

38
    pthread_mutex_unlock(&lock);
39

40
    if (choice == 0) break;
41
}

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

6
pthread_cond_t cond;
7
pthread_mutex_t mutex;
8

9
void* timed_waiter(void* arg) {
10
    pthread_mutex_lock(&mutex);
11

12
    // 设置超时时间：5秒后
13
    struct timespec ts;
14
    clock_gettime(CLOCK_REALTIME, &ts);  // 获取当前时间
15
    ts.tv_sec += 5;                      // 增加5秒
16

17
    printf("⏰ 开始等待，最多等待5秒...\n");
18

19
    // 定时等待
20
    int result = pthread_cond_timedwait(&cond, &mutex, &ts);
21

22
    if (result == ETIMEDOUT) {
23
        printf("❌ 等待超时！没有人来唤醒我\n");
24
    } else {
25
        printf("✅ 被成功唤醒！\n");
26
    }
27

28
    pthread_mutex_unlock(&mutex);
29
    return NULL;
30
}
31

32
void* wakeup_thread(void* arg) {
33
    int wait_time = *(int*)arg;
34

35
    sleep(wait_time);  // 等待一段时间后再唤醒
36

37
    pthread_mutex_lock(&mutex);
38
    printf("🔔 唤醒线程！\n");
39
    pthread_cond_signal(&cond);
40
    pthread_mutex_unlock(&mutex);
41

42
    return NULL;
43
}
44

45
int main() {
46
    pthread_mutex_init(&mutex, NULL);
47
    pthread_cond_init(&cond, NULL);
48

49
    printf("测试1：3秒后唤醒（在超时前）\n");
50

51
    pthread_t waiter, waker;
52
    int wake_time = 3;
53

54
    pthread_create(&waiter, NULL, timed_waiter, NULL);
55
    pthread_create(&waker, NULL, wakeup_thread, &wake_time);
56

57
    pthread_join(waiter, NULL);
58
    pthread_join(waker, NULL);
59

60
    printf("\n测试2：7秒后唤醒（已超时）\n");
61

62
    wake_time = 7;
63
    pthread_create(&waiter, NULL, timed_waiter, NULL);
64
    pthread_create(&waker, NULL, wakeup_thread, &wake_time);
65

66
    pthread_join(waiter, NULL);
67
    pthread_join(waker, NULL);
68

69
    pthread_mutex_destroy(&mutex);
70
    pthread_cond_destroy(&cond);
71

72
    return 0;
73
}

1
// 错误：没有用while循环检查条件
2
if (count == 0) {  // 应该用 while (count == 0)
3
    pthread_cond_wait(&cond, &mutex);
4
}

1
// 正确：使用while循环防止虚假唤醒
2
while (count == 0) {
3
    pthread_cond_wait(&cond, &mutex);
4
}

1
// 添加调试信息
2
printf("线程 %lu: 等待条件，当前count=%d\n", pthread_self(), count);
3
pthread_cond_wait(&cond, &mutex);
4
printf("线程 %lu: 被唤醒，当前count=%d\n", pthread_self(), count);