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

以下是用C语言实现上述功能的代码：

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

#define NUM_THREADS 4
#define BUFFER_SIZE 2

int buffer[BUFFER_SIZE];
int in = 0, out = 0;

sem_t sem_mutex, sem_full, sem_empty, sem_product;
int sem_value;

void *producer(void *arg);
void *consumer(void *arg);

int main(int argc, char *argv[]) {
    pthread_t threads[NUM_THREADS];
    int rc;
    long t;

    // 初始化信号量
    sem_init(&sem_mutex, 0, 1);
    sem_init(&sem_full, 0, 0);
    sem_init(&sem_empty, 0, BUFFER_SIZE);
    sem_init(&sem_product, 0, 0);

    // 创建线程
    for(t = 0; t < NUM_THREADS; t++) {
        if(t == 0) {
            rc = pthread_create(&threads[t], NULL, producer, (void *)t);
        } else {
            rc = pthread_create(&threads[t], NULL, consumer, (void *)t);
        }
        if(rc) {
            printf("Error: return code from pthread_create() is %d\n", rc);
            exit(-1);
        }
    }

    // 等待线程结束
    for(t = 0; t < NUM_THREADS; t++) {
        rc = pthread_join(threads[t], NULL);
        if(rc) {
            printf("Error: return code from pthread_join() is %d\n", rc);
            exit(-1);
        }
    }

    // 销毁信号量
    sem_destroy(&sem_mutex);
    sem_destroy(&sem_full);
    sem_destroy(&sem_empty);
    sem_destroy(&sem_product);

    pthread_exit(NULL);
}

void *producer(void *arg) {
    long tid = (long)arg;
    int item;

    while(1) {
        // 生产两种零件
        sem_wait(&sem_empty);
        sem_wait(&sem_mutex);
        item = rand() % 3;
        buffer[in] = item;
        in = (in + 1) % BUFFER_SIZE;
        printf("Producer %ld produces part %d\n", tid, item);
        sem_post(&sem_mutex);
        sem_post(&sem_full);

        sem_wait(&sem_empty);
        sem_wait(&sem_mutex);
        item = rand() % 3;
        buffer[in] = item;
        in = (in + 1) % BUFFER_SIZE;
        printf("Producer %ld produces part %d\n", tid, item);
        sem_post(&sem_mutex);
        sem_post(&sem_full);

        // 等待学徒组装产品
        sem_wait(&sem_product);
    }

    pthread_exit(NULL);
}

void *consumer(void *arg) {
    long tid = (long)arg;
    int item;

    while(1) {
        // 获取一种零件
        sem_wait(&sem_full);
        sem_wait(&sem_mutex);
        item = buffer[out];
        out = (out + 1) % BUFFER_SIZE;
        printf("Consumer %ld gets part %d\n", tid, item);
        sem_post(&sem_mutex);
        sem_post(&sem_empty);

        // 判断是否有另一种零件
        sem_getvalue(&sem_full, &sem_value);
        if(sem_value > 0) {
            sem_wait(&sem_mutex);
            item = buffer[out];
            out = (out + 1) % BUFFER_SIZE;
            printf("Consumer %ld gets part %d\n", tid, item);
            sem_post(&sem_mutex);
            sem_post(&sem_empty);

            // 组装产品
            printf("Consumer %ld assembles product with parts %d and %d\n", tid, item, buffer[(out-1+BUFFER_SIZE)%BUFFER_SIZE]);

            // 通知师傅放入新的两种零件
            sem_post(&sem_product);
        }
    }

    pthread_exit(NULL);
}

以上代码中，使用了4个线程，其中一个线程为师傅进程，另外三个线程为学徒进程。师傅进程不断生产两种零件，放入缓冲区中，等待学徒进程组装产品，并通知师傅进程放入新的两种零件。学徒进程从缓冲区中获取一种零件，判断是否有另一种零件，如果有，则组装产品，并通知师傅进程放入新的两种零件。使用信号量控制缓冲区的访问，实现同步与互斥。