生产者和消费者python实验代码

很抱歉，由于引用内容中提到的是C或C++语言实现生产者-消费者问题的并发控制，而非Python语言，因此无法提供Python实验代码。但是，我可以为您提供一个Python实现的生产者-消费者问题的示例代码，供您参考：

import threading
import time

# 缓冲区大小
BUFFER_SIZE = 10

# 生产者线程类
class ProducerThread(threading.Thread):
    def __init__(self, thread_id, buffer):
        threading.Thread.__init__(self)
        self.thread_id = thread_id
        self.buffer = buffer

    def run(self):
        while True:
            # 获取锁
            self.buffer.lock.acquire()
            # 如果缓冲区已满，等待消费者消费
            while self.buffer.full():
                self.buffer.full_cond.wait()
            # 生产一个物品
            item = self.thread_id
            self.buffer.put(item)
            print("Producer %d produced item %d" % (self.thread_id, item))
            # 通知消费者可以消费了
            self.buffer.empty_cond.notify()
            # 释放锁
            self.buffer.lock.release()
            # 等待一段时间
            time.sleep(1)

# 消费者线程类
class ConsumerThread(threading.Thread):
    def __init__(self, thread_id, buffer):
        threading.Thread.__init__(self)
        self.thread_id = thread_id
        self.buffer = buffer

    def run(self):
        while True:
            # 获取锁
            self.buffer.lock.acquire()
            # 如果缓冲区为空，等待生产者生产
            while self.buffer.empty():
                self.buffer.empty_cond.wait()
            # 消费一个物品
            item = self.buffer.get()
            print("Consumer %d consumed item %d" % (self.thread_id, item))
            # 通知生产者可以生产了
            self.buffer.full_cond.notify()
            # 释放锁
            self.buffer.lock.release()
            # 等待一段时间
            time.sleep(1)

# 缓冲区类
class Buffer:
    def __init__(self):
        self.buffer = []
        self.lock = threading.Lock()
        self.full_cond = threading.Condition(self.lock)
        self.empty_cond = threading.Condition(self.lock)

    # 判断缓冲区是否已满
    def full(self):
        return len(self.buffer) == BUFFER_SIZE

    # 判断缓冲区是否为空
    def empty(self):
        return len(self.buffer) == 0

    # 向缓冲区中添加一个物品
    def put(self, item):
        self.buffer.append(item)

    # 从缓冲区中取出一个物品
    def get(self):
        return self.buffer.pop()

# 创建缓冲区对象
buffer = Buffer()

# 创建生产者线程和消费者线程
producer_threads = [ProducerThread(i, buffer) for i in range(3)]
consumer_threads = [ConsumerThread(i, buffer) for i in range(2)]

# 启动线程
for thread in producer_threads + consumer_threads:
    thread.start()

# 等待线程结束
for thread in producer_threads + consumer_threads:
    thread.join()