Linux下POSIX线程：实现等待任意线程终止的方法

方案1：条件变量+共享状态表（POSIX标准，可移植性强） #

核心思路是让线程退出前主动通知主线程，主线程在条件变量上等待，收到通知后立刻回收已退出的线程：

• 维护一个共享的线程状态结构，记录每个线程的pthread_t和退出标记，用互斥锁保证线程安全访问。
• 每个线程完成任务后，先加锁标记自己为已退出，再通过条件变量唤醒主线程。
• 主线程循环检查状态表，找到已退出的线程就调用pthread_join()回收；如果没有，就阻塞在条件变量上等待通知，直到所有线程都被回收。

示例代码：

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

#define THREAD_COUNT 5

typedef struct {
    pthread_t tid;
    int has_exited;
} ThreadState;

ThreadState thread_states[THREAD_COUNT];
pthread_mutex_t state_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t exit_cond = PTHREAD_COND_INITIALIZER;

void* worker_thread(void* arg) {
    int thread_idx = *(int*)arg;
    free(arg);

    // 模拟随机时长的工作任务
    sleep(rand() % 4);

    // 退出前更新状态并通知主线程
    pthread_mutex_lock(&state_mutex);
    thread_states[thread_idx].has_exited = 1;
    pthread_cond_signal(&exit_cond);
    pthread_mutex_unlock(&state_mutex);

    return NULL;
}

int main() {
    srand(time(NULL));
    int i;

    // 创建线程并初始化状态
    for (i = 0; i < THREAD_COUNT; i++) {
        int* idx_ptr = malloc(sizeof(int));
        *idx_ptr = i;
        pthread_create(&thread_states[i].tid, NULL, worker_thread, idx_ptr);
        thread_states[i].has_exited = 0;
    }

    int remaining_threads = THREAD_COUNT;
    while (remaining_threads > 0) {
        pthread_mutex_lock(&state_mutex);

        // 检查是否有已退出的线程，没有则等待通知
        while (1) {
            int found_exited = 0;
            for (i = 0; i < THREAD_COUNT; i++) {
                if (thread_states[i].has_exited) {
                    pthread_join(thread_states[i].tid, NULL);
                    thread_states[i].has_exited = 0;
                    remaining_threads--;
                    found_exited = 1;
                    printf("已回收线程，剩余%d个未回收\n", remaining_threads);
                    break;
                }
            }
            if (found_exited) break;
            pthread_cond_wait(&exit_cond, &state_mutex);
        }

        pthread_mutex_unlock(&state_mutex);
    }

    pthread_mutex_destroy(&state_mutex);
    pthread_cond_destroy(&exit_cond);
    return 0;
}

方案2：信号量+非阻塞join（Linux专属，实现更简洁） #

利用Linux GNU扩展的pthread_tryjoin_np()（非阻塞版pthread_join），配合信号量实现：

• 初始化一个值为0的信号量，每个线程退出前调用sem_post()增加信号量计数。
• 主线程每次sem_wait()被唤醒后，遍历所有未回收的线程，用pthread_tryjoin_np()尝试回收（非阻塞，不会卡住）。
• 重复直到所有线程都被回收。

注意：pthread_tryjoin_np()是GNU扩展，需要定义_GNU_SOURCE才能编译。

示例代码：

#define _GNU_SOURCE
#include <pthread.h>
#include <semaphore.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>

#define THREAD_COUNT 5

pthread_t threads[THREAD_COUNT];
sem_t exit_sem;
int is_joined[THREAD_COUNT] = {0};
pthread_mutex_t join_mutex = PTHREAD_MUTEX_INITIALIZER;

void* worker_thread(void* arg) {
    int thread_idx = *(int*)arg;
    free(arg);

    sleep(rand() % 4);

    sem_post(&exit_sem);
    return NULL;
}

int main() {
    srand(time(NULL));
    sem_init(&exit_sem, 0, 0);
    int i;

    for (i = 0; i < THREAD_COUNT; i++) {
        int* idx_ptr = malloc(sizeof(int));
        *idx_ptr = i;
        pthread_create(&threads[i], NULL, worker_thread, idx_ptr);
    }

    int remaining_threads = THREAD_COUNT;
    while (remaining_threads > 0) {
        sem_wait(&exit_sem); // 等待任意线程退出的信号

        pthread_mutex_lock(&join_mutex);
        for (i = 0; i < THREAD_COUNT; i++) {
            if (!is_joined[i]) {
                int ret = pthread_tryjoin_np(threads[i], NULL);
                if (ret == 0) {
                    is_joined[i] = 1;
                    remaining_threads--;
                    printf("已回收线程%d，剩余%d个未回收\n", i, remaining_threads);
                    break;
                }
            }
        }
        pthread_mutex_unlock(&join_mutex);
    }

    sem_destroy(&exit_sem);
    pthread_mutex_destroy(&join_mutex);
    return 0;
}

关键注意点 #

• 两种方案都能避免主线程阻塞在某个未结束的线程上，实现“有线程退出就立刻回收”的需求。
• 方案1基于标准POSIX接口，可移植到所有支持POSIX线程的系统；方案2依赖GNU扩展，仅适用于Linux环境。
• 所有共享变量的访问必须用互斥锁保护，防止出现竞态条件。

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