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

### 回答1：
程的同步问题。

爸爸进程：

repeat
P(empty); //等待盘子空
//放入苹果或桔子
if (rand() % 2 == ) {
put_apple();
print("爸爸放入苹果");
} else {
put_orange();
print("爸爸放入桔子");
}
V(full); //通知盘子已满
until false;

儿子进程：

repeat
P(full); //等待盘子满
//取出桔子
if (get_orange()) {
print("儿子吃桔子");
}
V(empty); //通知盘子已空
until false;

女儿进程：

repeat
P(full); //等待盘子满
//取出苹果
if (get_apple()) {
print("女儿吃苹果");
}
V(empty); //通知盘子已空
until false;

其中，empty和full是两个信号量，初始值分别为1和，表示盘子初始为空。put_apple、put_orange、get_apple、get_orange是对盘子的操作，需要使用互斥锁来保证同一时刻只有一个进程对盘子进行操作。

### 回答2：
这是一个经典的生产者-消费者问题，可以通过使用P、V原语来实现三个进程的同步和互斥。

具体实现如下：

首先，在程序中定义三个信号量s1、s2、s3分别表示盘子中可以放入水果的数量、儿子等待的桔子数量、女儿等待的苹果数量。

然后，启动三个进程分别代表爸爸、儿子、女儿，每个进程都执行无限循环，模拟不断放入水果、等待取出水果的过程。

爸爸进程代码如下：

while (1) {
    P(s1); //等待盘子有空位置
    if (rand() % 2) { //随机选择放入苹果或桔子
        printf("爸爸向盘中放了一个苹果\n");
        V(s3); //通知女儿可以取苹果了
    } else {
        printf("爸爸向盘中放了一个桔子\n");
        V(s2); //通知儿子可以取桔子了
    }
}

儿子进程代码如下：

while (1) {
    P(s2); //等待盘子中有桔子
    printf("儿子取走了一个桔子\n");
    V(s1); //通知盘子中有空位置
}

女儿进程代码如下：

while (1) {
    P(s3); //等待盘子中有苹果
    printf("女儿取走了一个苹果\n");
    V(s1); //通知盘子中有空位置
}

这样，三个进程就可以并发运行，爸爸不断放入水果到盘子中，儿子等待盘子中出现桔子并取走它，女儿等待盘子中出现苹果并取走它，而且它们之间的操作都是互斥的，保证不会出现竞争和死锁情况。

### 回答3：
首先需要定义两个变量：一个表示盘中水果的种类 fruit，另一个表示盘中是否有水果 exists。初始状态下，fruit = None，exists = False。

接下来，我们定义三个进程函数：father_process，son_process，daughter_process。它们分别代表爸爸、儿子和女儿。

father_process 函数中，我们使用 p 操作来判断盘中是否有水果。如果没有，就向盘中放入苹果。如果已经有水果了，就等待直到儿子或女儿取走水果后再放入水果。

son_process 和 daughter_process 函数中，我们使用 p 操作来判断盘中是否有自己想要吃的水果。如果盘中没有自己想要吃的水果，就等待直到爸爸放入自己想要吃的水果。

当进程需要取出水果时，我们使用 v 操作来将 exists 标记为 False，表示盘中没有水果了。注意，操作 fruit 变量不用 v 操作，因为我们不需要改变水果种类，在整个过程中都是苹果和桔子交替放入的。

完整代码如下：

from multiprocessing import Process, Semaphore, Lock

fruit = None
exists = False

father_sem = Semaphore(1)
son_sem = Semaphore(0)
daughter_sem = Semaphore(0)
lock = Lock()

def father_process():
    global fruit, exists
    
    while True:
        if not exists:
            fruit = 'apple'
            exists = True
            print('Father put an apple in the plate.')
            son_sem.release()
            daughter_sem.release()
        else:
            print('Father waits for son or daughter to take the fruit.')
            with lock:
                pass
            
def son_process():
    global exists
    
    while True:
        son_sem.acquire()
        if fruit == 'orange':
            print('Son takes an orange from the plate.')
            exists = False
            father_sem.release()
        else:
            print('Son waits for father to put an orange in the plate.')
            daughter_sem.release()
            
def daughter_process():
    global exists
    
    while True:
        daughter_sem.acquire()
        if fruit == 'apple':
            print('Daughter takes an apple from the plate.')
            exists = False
            father_sem.release()
        else:
            print('Daughter waits for father to put an apple in the plate.')
            son_sem.release()
            
if __name__ == '__main__':
    father = Process(target=father_process)
    son = Process(target=son_process)
    daughter = Process(target=daughter_process)
    
    father.start()
    son.start()
    daughter.start()
    
    father.join()
    son.join()
    daughter.join()

上述代码中，我们使用了 Semaphore 和 Lock 来实现进程间的同步和互斥。father_sem 用于父进程和子女进程之间的同步，son_sem 和 daughter_sem 用于子女进程和父进程之间的同步，lock 用于父进程中使用 while 循环等待的互斥。在父进程中，如果盘子中已经有水果了，则使用 with lock 上锁等待。如果不加锁，在子女进程的 p 操作消耗信号量时，可能出现误判导致死锁的情况。