使用Python实现生产者消费者问题

之前用C++写过一篇生产者消费者的实现。

生产者和消费者主要是处理互斥和同步的问题：

队列作为缓冲区，需要互斥操作

队列中没有产品，消费者需要等待，直到生产者放入产品并通知它。队列慢的情况类似。

这里我使用list模拟Python标准库的Queue，这里我设置一个大小限制为5：

SyncQueue.py

from threading import Lock

from threading import Condition

class Queue():

    def __init__(self):

        self.mutex = Lock()

        self.full = Condition(self.mutex)

        self.empty = Condition(self.mutex)

        self.data = []



    def push(self, element):

        self.mutex.acquire()

        while len(self.data) >= 5:

            self.empty.wait()

            

        self.data.append(element)

        self.full.notify()    

        self.mutex.release()





    def pop(self):

        self.mutex.acquire()

        while len(self.data) == 0:

            self.full.wait()

        data = self.data[0]

        self.data.pop(0)

        self.empty.notify()

        self.mutex.release()



        return data



if __name__ == '__main__':

    q = Queue()

    q.push(10)

    q.push(2)

    q.push(13)



    print q.pop()

    print q.pop()

    print q.pop()

这是最核心的代码，注意里面判断条件要使用while循环。

接下来是生产者进程，producer.py

from threading import Thread

from random import randrange

from time import sleep

from SyncQueue import Queue



class ProducerThread(Thread):

    def __init__(self, queue):

        Thread.__init__(self)

        self.queue = queue

    def run(self):

        while True:

            data = randrange(0, 100)

            self.queue.push(data)

            print 'push %d' % (data)

            sleep(1)



if __name__ == '__main__':

    q = Queue()

    t = ProducerThread(q)

    t.start()

    t.join()

消费者,Condumer.py

from threading import Thread

from time import sleep

from SyncQueue import Queue



class ConsumerThread(Thread):

    def __init__(self, queue):

        Thread.__init__(self)

        self.queue = queue

    def run(self):

        while True:

            data = self.queue.pop()

            print 'pop %d' % (data)

            sleep(1)



if __name__ == '__main__':

    q = Queue()

    t = ConsumerThread(q)

    t.start()

    t.join()

最后我们写一个车间类,可以指定线程数量:

from SyncQueue import Queue

from Producer import ProducerThread

from Consumer import ConsumerThread



class WorkShop():

    def __init__(self, producerNums, consumerNums):

        self.producers = []

        self.consumers = []

        self.queue = Queue()

        self.producerNums = producerNums

        self.consumerNums = consumerNums

    def start(self):

        for i in range(self.producerNums):

            self.producers.append(ProducerThread(self.queue))

        for i in range(self.consumerNums):

            self.consumers.append(ConsumerThread(self.queue))

        for i in range(len(self.producers)):

            self.producers[i].start()

        for i in range(len(self.consumers)):

            self.consumers[i].start()

        for i in range(len(self.producers)):

            self.producers[i].join()

        for i in range(len(self.consumers)):

            self.consumers[i].join()



if __name__ == '__main__':

    w = WorkShop(3, 4)

    w.start()

最后写一个main模块:

from WorkShop import WorkShop



if __name__ == '__main__':

    w = WorkShop(2, 3)

    w.start()