写一段生产者消费者问题模拟的代码

下面是一个简单的生产者消费者问题模拟的代码，使用Python语言实现：

import threading
import time

# 缓冲区的大小
buf_size = 10

# 生产者线程
class Producer(threading.Thread):
    def __init__(self, buf):
        threading.Thread.__init__(self)
        self.buf = buf

    def run(self):
        for i in range(20):
            # 生产者每隔1秒生产一个产品
            time.sleep(1)
            self.buf.put(i)
            print("Producer produces: ", i)

# 消费者线程
class Consumer(threading.Thread):
    def __init__(self, buf):
        threading.Thread.__init__(self)
        self.buf = buf

    def run(self):
        for i in range(20):
            # 消费者每隔2秒消费一个产品
            time.sleep(2)
            item = self.buf.get()
            print("Consumer consumes: ", item)

# 缓冲区类
class Buffer():
    def __init__(self):
        self.items = []
        self.mutex = threading.Lock()
        self.empty = threading.Semaphore(buf_size)
        self.full = threading.Semaphore(0)

    # 往缓冲区中放入一个产品
    def put(self, item):
        self.empty.acquire()
        self.mutex.acquire()
        self.items.append(item)
        self.mutex.release()
        self.full.release()

    # 从缓冲区中取出一个产品
    def get(self):
        self.full.acquire()
        self.mutex.acquire()
        item = self.items.pop(0)
        self.mutex.release()
        self.empty.release()
        return item

# 创建一个缓冲区对象
buf = Buffer()

# 创建生产者和消费者线程
producer = Producer(buf)
consumer = Consumer(buf)

# 启动线程
producer.start()
consumer.start()

# 等待线程结束
producer.join()
consumer.join()

以上代码实现了一个简单的生产者消费者问题模拟，其中Buffer类是缓冲区类，使用了Python语言中的锁和信号量机制来保证线程同步和避免死锁。生产者线程每隔1秒生产一个产品放入缓冲区中，消费者线程每隔2秒从缓冲区中取出一个产品进行消费。运行该代码可以看到生产者和消费者线程交替执行，符合生产者消费者问题的解决方案。