生产者消费者问题使用信号量

生产者消费者问题是一个经典的多线程同步问题。使用信号量可以很好地解决这个问题。

信号量是一个计数器，用于控制多个线程的并发访问。当一个线程需要访问共享资源时，首先需要获取信号量。如果信号量的值为正，那么该线程可以继续访问共享资源，并将信号量的值减1。如果信号量的值为0，那么该线程就需要等待，直到其他线程释放了信号量。

在生产者消费者问题中，可以使用两个信号量来控制生产者和消费者的访问。一个信号量表示可以存放的物品数量，另一个信号量表示已经存放的物品数量。生产者线程在生产一个物品时，需要先获取可以存放的物品数量的信号量，如果该信号量的值为0，那么就需要等待。生产者线程将物品存放到共享缓冲区后，需要将已经存放的物品数量的信号量的值加1。消费者线程在消费一个物品时，需要先获取已经存放的物品数量的信号量，如果该信号量的值为0，那么就需要等待。消费者线程将物品从共享缓冲区中取出后，需要将可以存放的物品数量的信号量的值加1。

下面是一个使用信号量解决生产者消费者问题的示例代码：

import threading

class Buffer:
    def __init__(self, size):
        self.size = size
        self.buffer = [None] * size
        self.empty = threading.Semaphore(size)
        self.full = threading.Semaphore(0)
        self.mutex = threading.Lock()

    def put(self, item):
        self.empty.acquire()
        self.mutex.acquire()
        index = self.buffer.index(None)
        self.buffer[index] = item
        self.mutex.release()
        self.full.release()

    def get(self):
        self.full.acquire()
        self.mutex.acquire()
        index = self.buffer.index(None, 0, self.size)
        item = self.buffer[index-1]
        self.buffer[index-1] = None
        self.mutex.release()
        self.empty.release()
        return item

def producer(buffer, items):
    for item in items:
        buffer.put(item)

def consumer(buffer, count):
    for i in range(count):
        item = buffer.get()

if __name__ == '__main__':
    buffer = Buffer(5)
    producer_thread = threading.Thread(target=producer, args=(buffer, [1, 2, 3, 4, 5]))
    consumer_thread = threading.Thread(target=consumer, args=(buffer, 5))
    producer_thread.start()
    consumer_thread.start()
    producer_thread.join()
    consumer_thread.join()

在上面的代码中，Buffer类表示共享缓冲区，其中包含三个信号量：empty、full和mutex。empty表示可以存放的物品数量，full表示已经存放的物品数量，mutex用于保护共享缓冲区的访问。put方法用于往共享缓冲区中存放物品，get方法用于从共享缓冲区中取出物品。producer函数表示生产者线程，consumer函数表示消费者线程。在主函数中，创建了一个共享缓冲区对象和两个线程对象，分别表示生产者线程和消费者线程。生产者线程往共享缓冲区中存放5个物品，消费者线程从共享缓冲区中取出5个物品。程序最终输出：[1, 2, 3, 4, 5]。