(20)一组生产者进程和一组消费者进程共享9个缓冲区，每个缓冲区可以存放一个整数。生产者进程每次一次性地向三个缓冲区中写入整数，消费者进程每次从缓冲区取出一个整数。请用：①信号量和PV操作；②管程，写出能够正确执行的程序。

① 信号量和PV操作实现：

# 生产者和消费者进程共享的缓冲区
buffer = [0] * 9

# 定义信号量
empty = Semaphore(9)  # 初始值为9，表示缓冲区中的空闲空间为9
full = Semaphore(0)  # 初始值为0，表示缓冲区中的数据数量为0
mutex = Semaphore(1)  # 互斥信号量，用于保护对缓冲区的访问

# 生产者进程
def producer():
    while True:
        empty.acquire()  # P操作，申请空闲空间
        mutex.acquire()  # P操作，申请对缓冲区的访问权
        
        # 生产者向三个缓冲区写入整数
        for i in range(3):
            buffer[(i+index)%9] = i+1
        
        index = (index + 3) % 9  # 更新缓冲区的起始位置
        
        mutex.release()  # V操作，释放对缓冲区的访问权
        full.release(3)  # V操作，通知消费者缓冲区中有3个数据可用

# 消费者进程
def consumer():
    while True:
        full.acquire()  # P操作，申请可用数据
        mutex.acquire()  # P操作，申请对缓冲区的访问权
        
        # 消费者从缓冲区中取出一个整数
        item = buffer[index]
        index = (index + 1) % 9  # 更新缓冲区的起始位置
        
        mutex.release()  # V操作，释放对缓冲区的访问权
        empty.release()  # V操作，通知生产者缓冲区中有一个空闲空间可用

# 创建生产者进程和消费者进程
for i in range(3):
    Thread(target=producer).start()
    Thread(target=consumer).start()

② 管程实现：

# 生产者和消费者进程共享的缓冲区
buffer = [0] * 9

# 定义管程
class Monitor():
    def __init__(self):
        self.empty = 9  # 缓冲区中的空闲空间数量
        self.full = 0  # 缓冲区中的数据数量
        self.mutex = Condition()  # 互斥条件变量，用于保护对缓冲区的访问
        self.producer_cond = Condition()  # 生产者条件变量，用于通知生产者缓冲区中有空闲空间可用
        self.consumer_cond = Condition()  # 消费者条件变量，用于通知消费者缓冲区中有数据可用
        
    # 生产者向缓冲区写入整数
    def put(self, item):
        self.mutex.acquire()  # 申请对缓冲区的访问权
        
        while self.empty < 3:  # 缓冲区中的空闲空间小于3，等待
            self.producer_cond.wait()
        
        # 生产者向三个缓冲区写入整数
        for i in range(3):
            buffer[(i+index)%9] = i+1
        
        index = (index + 3) % 9  # 更新缓冲区的起始位置
        self.empty -= 3  # 更新缓冲区中的空闲空间数量
        self.full += 3  # 更新缓冲区中的数据数量
        
        self.consumer_cond.notify_all()  # 通知消费者缓冲区中有数据可用
        self.mutex.release()  # 释放对缓冲区的访问权
        
    # 消费者从缓冲区读取整数
    def get(self):
        self.mutex.acquire()  # 申请对缓冲区的访问权
        
        while self.full < 1:  # 缓冲区中的数据数量为0，等待
            self.consumer_cond.wait()
        
        # 消费者从缓冲区中取出一个整数
        item = buffer[index]
        index = (index + 1) % 9  # 更新缓冲区的起始位置
        self.empty += 1  # 更新缓冲区中的空闲空间数量
        self.full -= 1  # 更新缓冲区中的数据数量
        
        self.producer_cond.notify_all()  # 通知生产者缓冲区中有空闲空间可用
        self.mutex.release()  # 释放对缓冲区的访问权

# 生产者进程
def producer(monitor):
    while True:
        item = random.randint(1, 100)  # 随机生成一个整数
        monitor.put(item)  # 将整数写入缓冲区

# 消费者进程
def consumer(monitor):
    while True:
        item = monitor.get()  # 从缓冲区中读取一个整数
        print(item)  # 输出整数

# 创建管程和进程
monitor = Monitor()
for i in range(3):
    Thread(target=producer, args=(monitor,)).start()
    Thread(target=consumer, args=(monitor,)).start()