pthread_yield线程调度异常及线程按序交替执行需求咨询

咱们先拆解你的问题：首先得明白为什么pthread_yield()没实现你要的顺序，然后解答你的两个疑问，最后给出能完美按序执行的方案。

为什么pthread_yield()无法保证预期顺序？ #

pthread_yield()的作用只是告诉操作系统调度器：“我现在可以让出CPU，你可以去调度其他线程了”——但它完全没法决定接下来哪个线程会被选中执行。调度器会根据自己的策略（比如优先级、线程队列状态等）挑选下一个线程，这完全是操作系统自主决定的，所以你不能依赖它来实现严格的顺序控制。

你的两个疑问解答 #

1. 不使用pthread_yield()时，最后创建的线程先执行完毕，原因是什么？ #

这其实是Linux等系统调度器的常见行为，但不是绝对的规则。当你调用pthread_create()创建新线程后，新线程会立即进入“可运行”状态。很多调度器为了减少上下文切换的开销，会优先调度刚创建的线程（毕竟当前主线程刚完成创建操作，切换到新线程的成本更低）。所以最后创建的C线程会先被调度，然后是B，最后是A——但注意，这只是调度器的一种偏好，不同系统、不同负载下结果可能不一样，绝对不能把这个当成固定逻辑来依赖。

2. 使用pthread_yield()时，先交替执行B、C再执行A，原因是什么？ #

还是调度器的策略在起作用。当C线程调用pthread_yield()让出CPU后，调度器的可运行队列里，B线程是刚创建的、调度器更倾向于优先调度它，所以会先选B；B执行完yield()后，调度器又选回C，直到B和C都完成所有迭代，可运行队列里只剩下A了，才会轮到A执行。这依然是调度器的自主选择，pthread_yield()只能让出CPU，不能指定下一个执行的线程。

如何实现A、B、C完美按序交替执行？ #

要实现严格的线程执行顺序，必须用同步原语（比如互斥锁+条件变量，或者信号量）来手动控制线程的执行时机。这里给你一个基于互斥锁和条件变量的实现方案：

完整代码示例 #

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

// 全局同步变量：互斥锁+三个条件变量，标记当前该执行的线程
pthread_mutex_t mutex;
pthread_cond_t conds[3];
int current_thread = 0; // 0=A, 1=B, 2=C

void *A(void *arg){
    int i = 0;
    for (i=0; i < 3; i++){
        pthread_mutex_lock(&mutex);
        // 等待直到轮到A执行
        while (current_thread != 0) {
            pthread_cond_wait(&conds[0], &mutex);
        }
        // 执行打印逻辑
        printf("Hello A%d\n", i);
        // 更新状态为下一个线程（B），并唤醒B
        current_thread = 1;
        pthread_cond_signal(&conds[1]);
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

void *B(void *arg){
    int i = 0;
    for(i=0; i < 3; i++){
        pthread_mutex_lock(&mutex);
        while (current_thread != 1) {
            pthread_cond_wait(&conds[1], &mutex);
        }
        printf("Hello B%d\n", i);
        // 更新状态为C，唤醒C
        current_thread = 2;
        pthread_cond_signal(&conds[2]);
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

void *C(void *arg){
    int i = 0;
    for(i=0; i < 3; i++){
        pthread_mutex_lock(&mutex);
        while (current_thread != 2) {
            pthread_cond_wait(&conds[2], &mutex);
        }
        printf("Hello C%d\n", i);
        // 更新状态为A，唤醒A
        current_thread = 0;
        pthread_cond_signal(&conds[0]);
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

int main(){
    pthread_t threadId_1, threadId_2, threadId_3;
    printf("Before Thread\n");

    // 初始化同步变量
    pthread_mutex_init(&mutex, NULL);
    for (int i=0; i<3; i++) {
        pthread_cond_init(&conds[i], NULL);
    }

    pthread_create(&threadId_1, NULL, A, NULL);
    pthread_create(&threadId_2, NULL, B, NULL);
    pthread_create(&threadId_3, NULL, C, NULL);

    // 等待所有线程执行完毕（别用sleep，不可靠）
    pthread_join(threadId_1, NULL);
    pthread_join(threadId_2, NULL);
    pthread_join(threadId_3, NULL);

    // 清理同步资源
    pthread_mutex_destroy(&mutex);
    for (int i=0; i<3; i++) {
        pthread_cond_destroy(&conds[i]);
    }

    printf("After Thread\n");
    return 0;
}

方案原理 #

1. 互斥锁mutex：保护共享变量current_thread的访问，避免多个线程同时修改或读取它导致的竞争。
2. 条件变量conds：每个线程对应一个条件变量，用来等待“轮到自己执行”的信号。
3. current_thread：标记当前应该执行的线程编号，线程必须等到这个值等于自己的编号时，才能执行打印逻辑。
4. 执行流程：每个线程执行完自己的迭代后，会更新current_thread为下一个线程的编号，并唤醒对应的条件变量，让下一个线程可以执行。

这样就能严格保证A0→B0→C0→A1→B1→C1→A2→B2→C2的执行顺序，完全不受调度器策略的影响。

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