在此c语言代码中，桌上有一个能盛得下5个水果的空盘子。爸爸不停地向盘中放苹果和橘子，苹果和橘子要表示出来，儿子不停地从盘中取出橘子享用，女儿不停地从盘中取出苹果享用。规定3人不能同时向（从)盘子中放(取）水果。试用信号量机制来实现爸爸、儿子和女儿这3个“循环进程”之间的同步。

下面是使用信号量机制实现爸爸、儿子和女儿之间同步的 C 语言代码：

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

#define MAX_FRUIT 5

sem_t empty;         // 空盘子信号量
sem_t full;          // 满盘子信号量
sem_t mutex;         // 互斥信号量

int fruit[MAX_FRUIT]; // 水果数组
int in = 0;           // 当前放入水果位置
int out = 0;          // 当前取出水果位置

void* father(void* arg) {
    while (1) {
        int f = rand() % 2;  // 随机放入苹果或橘子
        sem_wait(&empty);    // 等待空盘子
        sem_wait(&mutex);    // 互斥访问水果数组
        fruit[in] = f;
        in = (in + 1) % MAX_FRUIT;
        printf("Father puts a %s into the dish.\n", (f == 0) ? "apple" : "orange");
        sem_post(&mutex);    // 释放互斥信号量
        sem_post(&full);     // 增加满盘子数量
    }
}

void* son(void* arg) {
    while (1) {
        sem_wait(&full);     // 等待满盘子
        sem_wait(&mutex);    // 互斥访问水果数组
        int f = fruit[out];
        out = (out + 1) % MAX_FRUIT;
        printf("Son takes an orange from the dish.\n");
        sem_post(&mutex);    // 释放互斥信号量
        sem_post(&empty);    // 增加空盘子数量
        sleep(1);            // 儿子享用橘子
    }
}

void* daughter(void* arg) {
    while (1) {
        sem_wait(&full);     // 等待满盘子
        sem_wait(&mutex);    // 互斥访问水果数组
        int f = fruit[out];
        out = (out + 1) % MAX_FRUIT;
        printf("Daughter takes an apple from the dish.\n");
        sem_post(&mutex);    // 释放互斥信号量
        sem_post(&empty);    // 增加空盘子数量
        sleep(1);            // 女儿享用苹果
    }
}

int main() {
    sem_init(&empty, 0, MAX_FRUIT);  // 初始化空盘子信号量
    sem_init(&full, 0, 0);           // 初始化满盘子信号量
    sem_init(&mutex, 0, 1);          // 初始化互斥信号量

    pthread_t father_thread, son_thread, daughter_thread;
    pthread_create(&father_thread, NULL, father, NULL);
    pthread_create(&son_thread, NULL, son, NULL);
    pthread_create(&daughter_thread, NULL, daughter, NULL);

    pthread_join(father_thread, NULL);
    pthread_join(son_thread, NULL);
    pthread_join(daughter_thread, NULL);

    sem_destroy(&empty);
    sem_destroy(&full);
    sem_destroy(&mutex);

    return 0;
}

在这个代码中，父进程（father）随机放入苹果或橘子，放入前需要等待空盘子信号量，放入后需要增加满盘子信号量。儿子进程（son）从盘子中取出橘子，并且在取出后暂停 1 秒钟来“享用”橘子，取出前需要等待满盘子信号量，取出后需要增加空盘子信号量。女儿进程（daughter）从盘子中取出苹果，并且在取出后暂停 1 秒钟来“享用”苹果，和儿子进程类似。

互斥信号量（mutex）用于保证同时只有一个进程访问水果数组，避免多个进程同时修改数组导致数据不一致的问题。