桌上有一个空盘，允许存放一只水果。爸爸可向盘中放苹果，也可向盘中放桔子，儿子专等吃盘中的桔子，女儿专等吃盘中的苹果。规定当盘空时一次只能放一只水果供吃者取用，请用p、v原语实现爸爸、儿子、女儿三个并发

### 回答1：
这是一个桌子上有一块空盘的问题，只允许放一个水果。爷爷可向盘中放苹果，也可向盘中放蜜桃，孩子专等吃盘中的桔子，女孩专等吃盘中的苹果。规定当盘空时一次只能放一个水果供吃者取用，请用P、V原语实现爷爷、孩子、女孩三个并发进程。

### 回答2：
首先，需要定义三个共享变量：fruit（水果类型）、mutex（互斥锁，保证同时只有一个人放水果）、father（父亲是否已经放了水果）。

其中，mutex的初始值为1，father的初始值为0。

父亲的实现可以使用P操作，当mutex的值为1时，表示盘子空闲，可以放水果。此时父亲对mutex进行P操作，将其锁住，然后放入想要的水果类型并将father设置为1。最后对mutex进行V操作，释放锁，并等待一段时间。

儿子和女儿的实现类似。当mutex的值为1且father为1时，表示盘子中有水果，可以取用。此时儿子或女儿对mutex进行P操作，将其锁住，判断盘子中的水果类型，如果是自己想要的水果，则取用，否则继续等待。最后对mutex进行V操作，释放锁，并等待一段时间。

具体实现如下：

var fruit = 0 // 0表示没放水果，1表示放了苹果，2表示放了桔子
var mutex = 1 // 互斥锁
var father = 0 // 0表示没放水果，1表示已经放了水果

func father() {
    while true {
        P(mutex)
        if father == 0 {
            fruit = rand(1, 2) // 随机生成1或2，表示放入苹果或桔子
            father = 1
            print("父亲放入了", if fruit == 1 then "苹果" else "桔子")
        }
        V(mutex)
        sleep(rand(1, 2))
    }
}

func son() {
    while true {
        P(mutex)
        if father == 1 && fruit == 2 {
            fruit = 0
            father = 0
            print("儿子取出了桔子")
        }
        V(mutex)
        sleep(rand(1, 2))
    }
}

func daughter() {
    while true {
        P(mutex)
        if father == 1 && fruit == 1 {
            fruit = 0
            father = 0
            print("女儿取出了苹果")
        }
        V(mutex)
        sleep(rand(1, 2))
    }
}

这样，父亲、儿子、女儿就可以并发地进行，通过互斥锁和共享变量实现了对盘子中水果的同步访问。当然，上述代码未考虑死锁等问题，实际使用时需要注意细节。

### 回答3：
题目要求我们使用P、V原语来实现爸爸、儿子、女儿三个并发，我们需要先简单介绍一下P、V原语的作用。

P原语：用于获取资源，即进入一个关键区，当可用资源为0时，该原语被阻塞，等待可用的资源。当有其他进程释放资源时，该进程被唤醒并拥有该资源。
V原语：用于释放资源，即退出一个关键区，将所持有资源的数目加一。

根据题目要求，我们可以将“盘中可以放一个苹果或桔子”的状态视为一种资源，而读取水果的操作可以视为进入一个关键区。所以我们可以分别为爸爸、儿子、女儿三个进程设置一个互斥信号量，来保证同时只有一个进程可以操作盘中的水果。

由于儿子和女儿对应的是不同的水果，我们可以为他们设置两个信号量，来分别控制苹果和桔子的取用。

下面是具体代码实现：

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/wait.h>
#include<sys/sem.h>

#define APPLE 0
#define ORANGE 1

//定义信号量
int empty; //盘中可以放置水果的数量，初始值为1
int mutex; //盘中水果的互斥信号量
int apple; //盘中苹果的数量，初始值为0
int orange; //盘中桔子的数量，初始值为0

int sem_create(int value) //创建信号量
{
    int semid = semget(IPC_PRIVATE, 1, IPC_CREAT|0666);
    union semun sem_val;
    sem_val.val = value;
    semctl(semid, 0, SETVAL, sem_val);
    return semid;
}

void sem_p(int semid) //P操作
{
    struct sembuf sem_p = {0, -1, SEM_UNDO};
    semop(semid, &sem_p, 1);
}

void sem_v(int semid) //V操作
{
    struct sembuf sem_v = {0, 1, SEM_UNDO};
    semop(semid, &sem_v, 1);
}

void father() //爸爸进程
{
    while(1)
    {
        //向盘中放置水果，随机放一个苹果或桔子
        sem_p(empty); //P操作
        sem_p(mutex); //P操作
        int fruit = rand() % 2; //0表示放置苹果，1表示放置桔子
        if(fruit == APPLE)
        {
            printf("爸爸向盘中放置了一个苹果\n");
            sem_p(apple); //P操作
        }
        else if(fruit == ORANGE)
        {
            printf("爸爸向盘中放置了一个桔子\n");
            sem_p(orange); //P操作
        }
        //释放互斥锁和空盘信号量，让其他进程进入关键区
        sem_v(mutex); //V操作
        sem_v(empty); //V操作
    }
}

void son() //儿子进程
{
    while(1)
    {
        //等待盘中放置桔子
        sem_p(orange); //P操作
        //进入关键区，读取桔子
        sem_p(mutex); //P操作
        printf("儿子拿到了一个桔子\n");
        //释放互斥锁和空盘信号量，让其他进程进入关键区
        sem_v(mutex); //V操作
        sem_v(empty); //V操作
        //吃桔子
        sleep(1);
    }
}

void daughter() //女儿进程
{
    while(1)
    {
        //等待盘中放置苹果
        sem_p(apple); //P操作
        //进入关键区，读取苹果
        sem_p(mutex); //P操作
        printf("女儿拿到了一个苹果\n");
        //释放互斥锁和空盘信号量，让其他进程进入关键区
        sem_v(mutex); //V操作
        sem_v(empty); //V操作
        //吃苹果
        sleep(1);
    }
}

int main()
{
    empty = sem_create(1);
    mutex = sem_create(1);
    apple = sem_create(0);
    orange = sem_create(0);

    pid_t pid_father = fork();
    if(pid_father < 0)
    {
        printf("父进程fork()子进程失败\n");
        exit(1);
    }
    else if(pid_father == 0)
    {
        father();
    }
    else
    {
        pid_t pid_son = fork();
        if(pid_son < 0)
        {
            printf("父进程fork()子进程失败\n");
            exit(1);
        }
        else if(pid_son == 0)
        {
            son();
        }
        else
        {
            pid_t pid_daughter = fork();
            if(pid_daughter < 0)
            {
                printf("父进程fork()子进程失败\n");
                exit(1);
            }
            else if(pid_daughter == 0)
            {
                daughter();
            }
            else
            {
                //等待父进程退出执行
                wait(0);
            }
        }
    }

    return 0;
}

代码实现中，我们首先定义了四个信号量，分别表示空盘、互斥锁、苹果和桔子。然后使用`fork()`函数创建了父进程和三个子进程。父进程不做任何操作，只是等待子进程退出。父进程的操作和子进程不是并发的，所以我们可以先让父进程退出执行，不影响后续的程序执行。

在子进程中，我们使用`rand()`函数来随机放置苹果或桔子，然后使用不同的信号量来控制儿子或女儿的读取操作。读取操作需要进入一个关键区，所以在读取前进入互斥锁信号量的关键区，等到读取完成，再释放互斥锁和空盘信号量，让其他进程进入关键区。

最后，我们可以用`sleep()`函数来模拟吃水果的操作，以便更好地演示进程交替执行的效果。