桌子上有一个盘子，最多可容纳3个水果，每次只能放入或取出一个水果。爸爸专向盘子中放苹果（apple），妈妈专向盘子中放西瓜（Melon），2个儿子专等吃盘子中的西瓜，1个女儿专等吃盘子中的苹果。请用wait和signal原语来实现爸爸、妈妈、儿子们、女儿之间的同步与互斥关系。

这是一个典型的生产者-消费者问题，可以使用信号量（Semaphore）来解决同步和互斥。在这个场景中，我们可以创建四个信号量：

1. `plate_full`（盘子满）: 初始化为3，表示盘子最多能放3个水果。
2. `apple_produced` (苹果生产): 初始值为0，用于控制爸爸放苹果时的互斥。
3. `melon_produced` (西瓜生产): 初始值为0，用于控制妈妈放西瓜时的互斥。
4. `consumers_waiting` (等待消费者) : 初始化为4，表示同时等待吃水果的人数。

以下是使用Python的threading库模拟信号量的简单示例：

import threading

# 等待信号量
def wait(semaphore):
    semaphore.acquire()

# 发出信号
def signal(semaphore):
    semaphore.release()

class Parent(threading.Thread):
    def run(self):
        for _ in range(5):  # 爸爸放5个苹果
            with self.apple_produced:
                if plate_full.value > 0:
                    plate_full.value -= 1
                    print("爸爸放下了一个苹果")
                else:
                    signal(consumers_waiting)

class ParentOther(threading.Thread):
    def run(self):
        for _ in range(5):  # 妈妈放5个西瓜
            with self.melon_produced:
                if plate_full.value < 3:
                    plate_full.value += 1
                    print("妈妈放下了一个西瓜")
                else:
                    signal(consumers_waiting)

class Child(threading.Thread):
    def __init__(self, fruit_type):
        super().__init__()
        self.fruit_type = fruit_type
        self.wait_semaphore = getattr(self, f"{fruit_type}_produced")

    def run(self):
        while True:
            wait(self.wait_semaphore)
            if plate_full.value == 0:
                print(f"孩子们饿了，但是盘子里没有{self.fruit_type}")
                break
            print(f"{self.name}得到了一个{self.fruit_type}")

dad = Parent()
mom = ParentOther()
son1 = Child('melon')
son2 = Child('melon')
daughter = Child('apple')

[dad.start(), mom.start(), son1.start(), son2.start(), daughter.start()]

这个例子中，每个线程都会使用相应的信号量（如`apple_produced`）来保护其操作，当资源可用时才会进入，而`plate_full`信号量则控制谁可以继续添加水果。这样就实现了爸爸、妈妈和孩子们之间的同步与互斥关系。