编程实现消费者生产者问题

消费者生产者问题是一个著名的并发编程问题，它描述了多个线程之间共享有限数量的资源的场景。其中，生产者线程负责生产资源，消费者线程负责消费资源，两者之间需要协调，以避免资源的竞争和浪费。以下是一个简单的生产者消费者问题的实现示例：

import threading
import time

# 一个共享的资源列表
resource_list = []
# 最大容量为5
MAX_CAPACITY = 5
# 一个信号量锁，用于控制生产者和消费者的访问
semaphore = threading.Semaphore(1)

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

    def run(self):
        global resource_list
        global MAX_CAPACITY
        global semaphore
        while True:
            # 获取信号量锁
            semaphore.acquire()
            # 如果资源数量达到最大容量，等待
            if len(resource_list) == MAX_CAPACITY:
                print("生产者 %s：资源数量已达到最大容量，等待消费者消费" % self.name)
                semaphore.release()
                time.sleep(1)
            else:
                # 生产资源
                resource = time.time()
                print("生产者 %s：生产了资源 %s" % (self.name, resource))
                resource_list.append(resource)
                semaphore.release()
                time.sleep(1)

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

    def run(self):
        global resource_list
        global semaphore
        while True:
            # 获取信号量锁
            semaphore.acquire()
            # 如果资源列表为空，等待
            if len(resource_list) == 0:
                print("消费者 %s：资源列表为空，等待生产者生产" % self.name)
                semaphore.release()
                time.sleep(1)
            else:
                # 消费资源
                resource = resource_list.pop()
                print("消费者 %s：消费了资源 %s" % (self.name, resource))
                semaphore.release()
                time.sleep(1)

if __name__ == '__main__':
    # 创建两个生产者和两个消费者线程
    producer1 = Producer("P1")
    producer2 = Producer("P2")
    consumer1 = Consumer("C1")
    consumer2 = Consumer("C2")

    # 启动线程
    producer1.start()
    producer2.start()
    consumer1.start()
    consumer2.start()

在这个实现中，我们使用了一个共享的资源列表来模拟资源的生产和消费，同时使用了信号量锁来控制生产者和消费者的访问。生产者线程使用`acquire()`方法获取信号量锁，如果资源数量达到最大容量，就使用`release()`方法释放锁，并等待一段时间后重试，否则就生产一个新的资源，并将其添加到资源列表中。消费者线程也使用`acquire()`方法获取信号量锁，如果资源列表为空，就使用`release()`方法释放锁，并等待一段时间后重试，否则就消费一个资源，并将其从资源列表中删除。通过这种方式，我们可以保证生产者和消费者之间的协调，避免资源的竞争和浪费。