如何让多线程程序中的输出线程被动等待全局变量变更？

咱们直接切入核心——你想要让输出线程完全被动等待，只有当计算线程修改全局变量时才被唤醒执行打印，彻底避免轮询消耗CPU。原代码里用信号量控制并发线程数的思路没问题，但缺少唤醒输出线程的关键机制，而**POSIX条件变量（pthread_cond_t）**配合互斥锁，正好是解决这类“等待-唤醒”场景的最优方案。

核心实现思路 #

1. 用互斥锁保护所有共享全局变量（val1、val2、active、finish），彻底避免竞态条件。
2. 让输出线程在条件变量上休眠，直到计算线程更新全局变量后主动唤醒它。
3. 主线程最后需要通知输出线程退出，防止它无限等待。

修改后的完整可运行代码 #

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

// 全局变量与同步原语
sem_t sem;
int val1 = 0;
int val2 = 0;
int active = 0;
int finish = 0;
int total_calc_threads = 0; // 记录总计算线程数，用于判断是否全部完成
pthread_mutex_t data_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t update_cond = PTHREAD_COND_INITIALIZER;
int output_thread_running = 1; // 控制输出线程的运行状态

// 模拟你的计算逻辑，替换成实际业务代码即可
void calculate(void* arg) {
    int input = *(int*)arg;
    // 示例：更新全局计算结果
    pthread_mutex_lock(&data_mutex);
    val1 += input;
    val2 += input * 2;
    pthread_mutex_unlock(&data_mutex);
}

void* calc(void* arg) {
    sem_wait(&sem); // 获取并发许可，控制同时运行的线程数

    pthread_mutex_lock(&data_mutex);
    active++; // 运行中线程数+1
    pthread_mutex_unlock(&data_mutex);

    calculate(arg); // 执行计算任务

    pthread_mutex_lock(&data_mutex);
    finish++; // 已完成线程数+1
    active--; // 运行中线程数-1
    pthread_cond_signal(&update_cond); // 唤醒输出线程：全局变量已更新
    pthread_mutex_unlock(&data_mutex);

    sem_post(&sem); // 释放并发许可
    free(arg); // 释放传入的堆内存（避免内存泄漏）
    return NULL;
}

void* out(void* arg) {
    while (output_thread_running) {
        pthread_mutex_lock(&data_mutex);
        // 被动等待：要么全局变量更新，要么收到退出信号
        pthread_cond_wait(&update_cond, &data_mutex);
        
        // 检查是否需要退出
        if (!output_thread_running) {
            pthread_mutex_unlock(&data_mutex);
            break;
        }

        // 打印当前状态，可根据需求调整输出内容
        printf("实时状态：val1=%d, val2=%d, 运行中线程=%d, 已完成线程=%d\n",
               val1, val2, active, finish);
        pthread_mutex_unlock(&data_mutex);
    }
    printf("输出线程已退出\n");
    return NULL;
}

int main(int argc, char* argv[]) {
    if (argc < 3) {
        fprintf(stderr, "用法：%s <最大并发线程数> <计算参数1> <计算参数2> ...\n", argv[0]);
        exit(EXIT_FAILURE);
    }

    int max_concurrent = atoi(argv[1]);
    total_calc_threads = argc - 2;
    pthread_t output_thread;
    pthread_t calc_thread;

    // 初始化同步原语
    sem_init(&sem, 0, max_concurrent);
    pthread_mutex_init(&data_mutex, NULL);
    pthread_cond_init(&update_cond, NULL);

    // 创建并分离输出线程
    pthread_create(&output_thread, NULL, out, NULL);
    pthread_detach(output_thread);

    // 创建计算线程（注意：不能传递栈变量，必须用堆内存避免数据覆盖）
    for (int i = 2; i < argc; i++) {
        int* input_val = malloc(sizeof(int));
        *input_val = atoi(argv[i]);
        pthread_create(&calc_thread, NULL, calc, input_val);
        pthread_detach(calc_thread);
    }

    // 等待所有计算线程完成（因为线程是分离状态，无法用pthread_join）
    while (1) {
        pthread_mutex_lock(&data_mutex);
        if (finish == total_calc_threads) {
            pthread_mutex_unlock(&data_mutex);
            break;
        }
        pthread_mutex_unlock(&data_mutex);
        usleep(10000); // 10毫秒休眠，减少锁竞争消耗
    }

    // 通知输出线程退出
    pthread_mutex_lock(&data_mutex);
    output_thread_running = 0;
    pthread_cond_signal(&update_cond); // 唤醒输出线程让它退出循环
    pthread_mutex_unlock(&data_mutex);

    // 销毁同步原语，释放资源
    sem_destroy(&sem);
    pthread_mutex_destroy(&data_mutex);
    pthread_cond_destroy(&update_cond);

    return 0;
}

关键细节说明 #

• 互斥锁的必要性：所有读写共享全局变量的操作必须在锁的保护下，否则多个线程同时修改会导致数据错乱（比如active或finish的计数错误）。
• 条件变量的工作逻辑：pthread_cond_wait会自动释放互斥锁并让线程进入休眠状态，直到被pthread_cond_signal唤醒；唤醒后会重新自动获取锁，保证后续访问共享变量的安全性。
• 避免栈变量陷阱：原代码中直接传递栈变量somevalue给计算线程是错误的——循环会覆盖这个变量的值，所以必须用malloc分配堆内存，计算线程完成后再释放。
• 主线程的等待逻辑：因为计算线程是分离状态，无法用pthread_join等待，所以用了一个轻量的循环检查完成状态，搭配短暂休眠减少CPU消耗。

为什么这比轮询好？ #

轮询会让输出线程持续占用CPU资源空转，而条件变量让线程在没有事件时完全休眠，只有当需要处理时才被唤醒，不仅节省资源，也完全符合你“被动等待”的需求。

内容的提问来源于stack exchange，提问作者iwanttocommitdie1234