c语言：有一个师傅进程和三个学徒进程，每个学徒连续不断地组装产品，做一个产品需要A、B、C三种零件，这三个学徒分别掌握有A零件、B零件、C零件多个。 要求完成以下功能： （1）师傅源源不断地供应上述三种零件，但他每次只将其中的两种零件放在桌子上(所放零件由rand % 3函数生成的0-2之间的随机数决定)。 （2）具有另一零件的学徒就可以组装产品，且做完后给师傅发信号，然后师傅再拿出两种零件放在桌上。 （3）每次只能有一个进程放入或取出零件。 （4）利用同步与互斥的相关知识编写仿真系统实现以上过程，要能够清晰表达产品生产的全过程。

下面是一个基于信号量的C语言实现，实现师傅和三个学徒的进程同步和互斥：

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

// 定义信号量
sem_t sem_a;
sem_t sem_b;
sem_t sem_c;
sem_t sem_f;

// 定义全局变量
int a_count = 0;
int b_count = 0;
int c_count = 0;

// 生产零件的师傅线程
void *producer(void *arg) {
    while (1) {
        // 生成随机数，决定放置哪两种零件
        int i = rand() % 3;
        int j = rand() % 3;
        while (i == j) {
            j = rand() % 3;
        }
        // 放置零件
        if (i == 0 && j == 1) {
            sem_post(&sem_a);
            sem_post(&sem_b);
            printf("Producer: Put A and B on the table.\n");
        } else if (i == 0 && j == 2) {
            sem_post(&sem_a);
            sem_post(&sem_c);
            printf("Producer: Put A and C on the table.\n");
        } else if (i == 1 && j == 0) {
            sem_post(&sem_b);
            sem_post(&sem_a);
            printf("Producer: Put B and A on the table.\n");
        } else if (i == 1 && j == 2) {
            sem_post(&sem_b);
            sem_post(&sem_c);
            printf("Producer: Put B and C on the table.\n");
        } else if (i == 2 && j == 0) {
            sem_post(&sem_c);
            sem_post(&sem_a);
            printf("Producer: Put C and A on the table.\n");
        } else if (i == 2 && j == 1) {
            sem_post(&sem_c);
            sem_post(&sem_b);
            printf("Producer: Put C and B on the table.\n");
        }
        // 等待学徒取走零件
        sem_wait(&sem_f);
    }
    return NULL;
}

// 组装A零件的学徒线程
void *worker_a(void *arg) {
    while (1) {
        // 等待A零件
        sem_wait(&sem_a);
        // 组装A零件
        a_count++;
        printf("Worker A: Assemble A, now have %d A parts.\n", a_count);
        // 如果有足够的零件，通知师傅继续放置零件
        if (a_count >= 1 && b_count >= 1 && c_count >= 1) {
            sem_post(&sem_f);
        }
    }
    return NULL;
}

// 组装B零件的学徒线程
void *worker_b(void *arg) {
    while (1) {
        // 等待B零件
        sem_wait(&sem_b);
        // 组装B零件
        b_count++;
        printf("Worker B: Assemble B, now have %d B parts.\n", b_count);
        // 如果有足够的零件，通知师傅继续放置零件
        if (a_count >= 1 && b_count >= 1 && c_count >= 1) {
            sem_post(&sem_f);
        }
    }
    return NULL;
}

// 组装C零件的学徒线程
void *worker_c(void *arg) {
    while (1) {
        // 等待C零件
        sem_wait(&sem_c);
        // 组装C零件
        c_count++;
        printf("Worker C: Assemble C, now have %d C parts.\n", c_count);
        // 如果有足够的零件，通知师傅继续放置零件
        if (a_count >= 1 && b_count >= 1 && c_count >= 1) {
            sem_post(&sem_f);
        }
    }
    return NULL;
}

int main() {
    // 初始化信号量
    sem_init(&sem_a, 0, 0);
    sem_init(&sem_b, 0, 0);
    sem_init(&sem_c, 0, 0);
    sem_init(&sem_f, 0, 0);

    // 创建线程
    pthread_t t1, t2, t3, t4;
    pthread_create(&t1, NULL, producer, NULL);
    pthread_create(&t2, NULL, worker_a, NULL);
    pthread_create(&t3, NULL, worker_b, NULL);
    pthread_create(&t4, NULL, worker_c, NULL);

    // 等待线程结束
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    pthread_join(t3, NULL);
    pthread_join(t4, NULL);

    // 销毁信号量
    sem_destroy(&sem_a);
    sem_destroy(&sem_b);
    sem_destroy(&sem_c);
    sem_destroy(&sem_f);

    return 0;
}

以上代码实现了一个师傅和三个学徒之间的同步和互斥，师傅负责生产零件，学徒负责组装零件，每次放置两种零件，等待学徒取走后再继续放置。当有足够的A、B、C三种零件时，学徒可以组装产品，并通知师傅继续放置零件。