Linux环境下父线程初始化子pthread后等待子线程信号的最优方案

方案1：使用条件变量（推荐） #

条件变量是POSIX线程库中专门用于线程间同步等待的机制，配合互斥锁可以安全解决你的需求，完全避免竞态和无用的CPU消耗。

实现逻辑：

• 主线程初始化互斥锁和条件变量，创建子线程后，加锁并等待条件变量触发。
• 子线程完成初始化后，修改状态标记并触发条件变量，通知主线程继续执行。

代码示例：

#include <pthread.h>

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int init_finished = 0;

void *childProcess(void *arg) {
    // 执行关键初始化操作
    // ...

    // 通知主线程初始化完成
    pthread_mutex_lock(&mutex);
    init_finished = 1;
    pthread_cond_signal(&cond);
    pthread_mutex_unlock(&mutex);

    // 后续并行处理逻辑
    // ...
    return NULL;
}

int main() {
    pthread_t childThread;
    pthread_create(&childThread, NULL, childProcess, NULL);

    // 等待子线程初始化完成
    pthread_mutex_lock(&mutex);
    while (!init_finished) {
        pthread_cond_wait(&cond, &mutex);
    }
    pthread_mutex_unlock(&mutex);

    // 主线程并行处理逻辑
    // ...

    pthread_join(childThread, NULL);
    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);
    return 0;
}

这里用while循环而非if判断，是为了规避Linux下条件变量可能出现的虚假唤醒问题，确保只有子线程真的完成初始化后，主线程才会继续执行。

方案2：使用线程屏障（pthread_barrier_t） #

线程屏障适用于多个线程等待彼此到达同步点的场景，双线程同步的场景下使用也非常简洁。

实现逻辑：

• 初始化屏障时设置需要等待的线程数为2（主线程+子线程）。
• 子线程完成初始化后调用屏障等待，主线程创建子线程后也调用屏障等待，两者都到达同步点后，会同时继续执行。

代码示例：

#include <pthread.h>

pthread_barrier_t barrier;

void *childProcess(void *arg) {
    // 执行关键初始化操作
    // ...

    // 等待同步屏障
    pthread_barrier_wait(&barrier);

    // 后续并行处理逻辑
    // ...
    return NULL;
}

int main() {
    // 初始化屏障，要求2个线程到达后放行
    pthread_barrier_init(&barrier, NULL, 2);

    pthread_t childThread;
    pthread_create(&childThread, NULL, childProcess, NULL);

    // 等待子线程完成初始化
    pthread_barrier_wait(&barrier);

    // 主线程并行处理逻辑
    // ...

    pthread_join(childThread, NULL);
    pthread_barrier_destroy(&barrier);
    return 0;
}

这个方案不需要额外的状态变量，代码更简洁，适合这种双线程同步的场景。

方案3：使用信号量（sem_t） #

POSIX信号量也是可靠的同步机制，用初始值为0的信号量可以实现主线程的阻塞等待。

实现逻辑：

• 初始化信号量为0，主线程调用sem_wait会阻塞。
• 子线程完成初始化后调用sem_post释放信号量，主线程被唤醒继续执行。

代码示例：

#include <semaphore.h>
#include <pthread.h>

sem_t init_sem;

void *childProcess(void *arg) {
    // 执行关键初始化操作
    // ...

    // 释放信号量，通知主线程
    sem_post(&init_sem);

    // 后续并行处理逻辑
    // ...
    return NULL;
}

int main() {
    // 初始化信号量，初始值为0
    sem_init(&init_sem, 0, 0);

    pthread_t childThread;
    pthread_create(&childThread, NULL, childProcess, NULL);

    // 等待子线程初始化完成
    sem_wait(&init_sem);

    // 主线程并行处理逻辑
    // ...

    pthread_join(childThread, NULL);
    sem_destroy(&init_sem);
    return 0;
}

信号量的逻辑直观，无需互斥锁配合，适合简单的单向同步场景。

关于你提到的“互斥锁所有权转移”：POSIX互斥锁没有所有权转移的机制，互斥锁只能由加锁的线程解锁，强行让其他线程解锁会触发未定义行为，这个思路不可行。

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