参考教材中的生产者消费者算法,创建5个进程,其中两个进程为生产者进程,3个进程为

消费者进程。假设有一个缓冲区可以存储10个物品，生产者进程可以生产物品并将其放入缓冲区中，消费者进程可以从缓冲区中取出物品进行消费。如果缓冲区已满，则生产者进程需要等待，直到有空间可以生产物品。如果缓冲区为空，则消费者进程需要等待，直到有物品可以消费。

下面是一个简单的实现代码：

import threading
import time
import random

# 设置缓冲区大小为10
BUFFER_SIZE = 10

# 初始化缓冲区为空列表
buffer = []

# 创建条件变量
not_full = threading.Condition()
not_empty = threading.Condition()

# 生产者线程
class Producer(threading.Thread):
    def run(self):
        global buffer
        while True:
            # 获取锁
            not_full.acquire()
            # 如果缓冲区已满，则等待
            while len(buffer) == BUFFER_SIZE:
                print("Buffer is full, producer is waiting...")
                not_full.wait()
            # 生产物品
            item = random.randint(1, 100)
            buffer.append(item)
            print("Producer produced", item)
            # 发送通知，告诉消费者可以消费了
            not_empty.notify()
            # 释放锁
            not_full.release()
            # 等待一段时间
            time.sleep(random.random())

# 消费者线程
class Consumer(threading.Thread):
    def run(self):
        global buffer
        while True:
            # 获取锁
            not_empty.acquire()
            # 如果缓冲区为空，则等待
            while not buffer:
                print("Buffer is empty, consumer is waiting...")
                not_empty.wait()
            # 消费物品
            item = buffer.pop(0)
            print("Consumer consumed", item)
            # 发送通知，告诉生产者可以生产了
            not_full.notify()
            # 释放锁
            not_empty.release()
            # 等待一段时间
            time.sleep(random.random())

# 创建生产者进程
for i in range(2):
    p = Producer()
    p.start()

# 创建消费者进程
for i in range(3):
    c = Consumer()
    c.start()

上述代码中，生产者进程和消费者进程继承自 threading.Thread 类，并通过实现 run() 方法来实现线程的逻辑。在生产者进程中，如果缓冲区已满，则通过调用 not_full.wait() 方法来等待通知；如果成功生产一个物品，则通过调用 not_empty.notify() 方法发送通知给消费者进程。在消费者进程中，如果缓冲区为空，则通过调用 not_empty.wait() 方法来等待通知；如果成功消费一个物品，则通过调用 not_full.notify() 方法发送通知给生产者进程。

在 main 函数中，我们创建了两个生产者进程和三个消费者进程，并启动了它们。由于生产者进程和消费者进程都是无限循环的，因此它们会一直运行下去，直到程序被手动终止。