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

在这个场景中，我们可以使用条件变量（Condition Variable）和互斥锁（Mutex）来实现爸爸、儿子和女儿这三个并发进程的同步。以下是使用Python模拟的一个简单版本，使用了`threading`库中的`Lock`和`Condition`：

import threading

class Fruit:
    def __init__(self):
        self.lock = threading.Lock()
        self.fruit_type = None
        self.condition = threading.Condition(self.lock)

    def put_fruit(self, fruit):
        with self.lock:
            if not self.fruit_type:
                self.fruit_type = fruit
                self.signal_apple_consumer()
            else:
                # 爸爸已经放置了一种水果，不允许同时放入另一种
                pass

    def signal_apple_consumer(self):
        self.condition.notify()

    def eat_fruit(self):
        with self.lock:
            while True:
                if self.fruit_type == 'apple':
                    self.eat('apple')
                    self.fruit_type = None
                    self.signal_fruit_producer()
                    break
                elif self.fruit_type == 'orange':
                    self.wait_orange_consumer()
                else:
                    break
        print(f"Son ate {self.fruit_type}")

    def wait_orange_consumer(self):
        self.condition.wait()

    def eat(self, fruit):
        print(f"{fruit} eaten by the {self.name}")

# 创建水果对象
fruits = Fruit()

# 启动爸爸、儿子和女儿的线程
def dad():
    fruits.put_fruit('apple')  # 放置苹果
    fruits.put_fruit('orange')  # 再次放置桔子

dad_thread = threading.Thread(target=dad)
son_thread = threading.Thread(target=fruits.eat_fruit)
daughter_thread = threading.Thread(target=fruits.eat_fruit)

dad_thread.start()
son_thread.start()
daughter_thread.start()

dad_thread.join()  # 等待所有线程结束

这个例子中，`Fruit`类包含了放置水果和等待消费者的方法。当爸爸将水果放入盘子后，会通知对应的消费者（儿子或女儿），并释放互斥锁。消费者（儿子或女儿）在获取到信号后检查盘子里的水果类型，并按照规则食用。如果水果已被其他消费掉，它们会进入等待状态直到新的水果出现。