如何用pthreads实现调度线程与工作线程的顺序交替执行？

针对你的嵌入式操作系统模拟器需求，互斥锁+条件变量+共享状态变量是完全可行的方案，足以实现严格的串行循环执行逻辑，屏障并不适用（屏障是同步所有线程到达同一节点后继续，不符合你线性依次执行的要求）。以下是具体实现思路和代码示例：

核心逻辑 #

1. 定义3个全局同步对象：

   • pthread_mutex_t mutex：保护共享状态的互斥锁
   • pthread_cond_t cond：用于线程间唤醒通知的条件变量
   • 两个共享变量：int current_thread（标记当前可执行的线程标识，0=调度线程，1-4=对应工作线程）、int next_worker（记录调度线程下次要唤醒的工作线程，初始为1，循环1→2→3→4→1）

2. 每个线程的执行逻辑：

   • 加锁后循环检查current_thread是否等于自身标识，不满足则调用pthread_cond_wait进入等待（自动释放锁，被唤醒后重新获取锁）
   • 满足条件时执行自身业务逻辑
   • 更新current_thread为下一个要执行的线程标识，调用pthread_cond_broadcast唤醒所有等待的线程（避免信号丢失，确保目标线程能被唤醒）
   • 解锁

完整代码示例 #

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

// 全局同步对象
pthread_mutex_t mutex;
pthread_cond_t cond;

// 共享状态
int current_thread = 0;  // 0=SchThread, 1=Thread1, 2=Thread2, 3=Thread3, 4=Thread4
int next_worker = 1;     // 调度线程下次要唤醒的工作线程

// 调度线程函数
void* SchThread(void* arg) {
    while (1) {
        pthread_mutex_lock(&mutex);
        // 等待轮到自己执行
        while (current_thread != 0) {
            pthread_cond_wait(&cond, &mutex);
        }

        // 执行调度逻辑
        printf("执行调度线程逻辑\n");
        sleep(1);  // 模拟业务耗时

        // 设置下一个要执行的工作线程
        current_thread = next_worker;
        // 更新下一次的工作线程（循环1→2→3→4→1）
        next_worker = (next_worker % 4) + 1;

        // 唤醒所有等待的线程
        pthread_cond_broadcast(&cond);
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

// 工作线程通用函数（通过参数区分线程1-4）
void* WorkerThread(void* arg) {
    int thread_id = *(int*)arg;
    free(arg);  // 释放传入的动态内存

    while (1) {
        pthread_mutex_lock(&mutex);
        // 等待轮到自己执行
        while (current_thread != thread_id) {
            pthread_cond_wait(&cond, &mutex);
        }

        // 执行工作线程逻辑
        printf("执行工作线程%d逻辑\n", thread_id);
        sleep(1);  // 模拟业务耗时

        // 执行完成后交回调度线程
        current_thread = 0;

        // 唤醒调度线程
        pthread_cond_broadcast(&cond);
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

int main() {
    pthread_t sch_tid, t1_tid, t2_tid, t3_tid, t4_tid;

    // 初始化互斥锁和条件变量
    pthread_mutex_init(&mutex, NULL);
    pthread_cond_init(&cond, NULL);

    // 创建调度线程
    pthread_create(&sch_tid, NULL, SchThread, NULL);

    // 创建工作线程，传入线程ID
    int* tid1 = malloc(sizeof(int)); *tid1 = 1;
    pthread_create(&t1_tid, NULL, WorkerThread, tid1);

    int* tid2 = malloc(sizeof(int)); *tid2 = 2;
    pthread_create(&t2_tid, NULL, WorkerThread, tid2);

    int* tid3 = malloc(sizeof(int)); *tid3 = 3;
    pthread_create(&t3_tid, NULL, WorkerThread, tid3);

    int* tid4 = malloc(sizeof(int)); *tid4 = 4;
    pthread_create(&t4_tid, NULL, WorkerThread, tid4);

    // 等待线程结束（这里是无限循环，实际可根据模拟器退出逻辑调整）
    pthread_join(sch_tid, NULL);
    pthread_join(t1_tid, NULL);
    pthread_join(t2_tid, NULL);
    pthread_join(t3_tid, NULL);
    pthread_join(t4_tid, NULL);

    // 销毁同步对象
    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);

    return 0;
}

关键注意事项 #

1. 必须用while循环等待条件：不能用if判断，因为线程可能被虚假唤醒（spurious wakeup），while循环能确保只有条件真正满足时才继续执行。
2. 使用broadcast而非signal：因为多个线程在等待条件变量，signal可能只唤醒一个非目标线程，broadcast能确保所有等待线程都被唤醒，检查条件后只有目标线程继续执行。
3. 共享变量必须在锁保护下访问：所有对current_thread和next_worker的读写操作都要在互斥锁锁定的范围内，避免竞态条件。

对你疑问的补充说明 #

• 仅用互斥锁无法实现顺序控制：互斥锁只能保证临界区互斥，无法让线程按指定顺序等待执行，必须配合条件变量实现等待/唤醒逻辑。
• 屏障不适用：屏障的作用是让所有线程到达同步点后同时继续，完全不符合你严格串行的执行需求。
• pthread_cond系列接口是正确方向：你之前的尝试失败大概率是因为没有正确处理锁的范围、虚假唤醒，或者唤醒方式错误，上述方案能解决这些问题。

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