生产者消费者问题

问题描述：

生产者在生产产品，这些产品将提供给若干个消费者去消费，为了使生产者和消费者能并发执行，在两者之间设置一个具有多个缓冲区的缓冲池，生产者将它生产的产品放入一个缓冲区中，消费者可以从缓冲区中取走产品进行消费，显然生产者和消费者之间必须保持同步，即不允许消费者到一个空的缓冲区中取产品，也不允许生产者向一个已经放入产品的缓冲区中再次投放产品。

条件变量解决方案：

• 基于队列构建一个缓冲区，生产者在队尾填充，消费者在队头获取。队列缓冲区作为多个线程的共享资源。
• 由于多个消费者和生产者线程可以并发访问缓冲区，需要互斥锁来控制对缓冲区的互斥访问。
• 队列空时消费者线程需要等到队列中存在资源、队列满时生产者线程需要等到队列中有资源被消费。通过使用条件变量来实现线程的阻塞、通知以达到生产、消费线程的同步。

from threading import Lock
from threading import Condition
import threading

class myQueue:
    def __init__(self, size):
        self.size = size
        self.list = list()
        self.lock = Lock()
        self.notFullCond = Condition(self.lock)
        self.notEmptyCond = Condition(self.lock)

    def isFull(self):
        if self.size == len(self.list):
            return True
        return False

    def isEmpty(self):
        if 0 == len(self.list):
            return True
        return False
    
    def enQueue(self, elem):
        self.lock.acquire()
        while self.isFull():                   #队列满时触发等待notFullCond条件，线程阻塞同时释放互斥锁
            print('queue is full, waiting...')
            self.notFullCond.wait()   
        print(threading.current_thread().getName() + ' product ' + str(elem))
        self.list.append(elem)
#当有资源进入队列通知所有等待notEmptyCond条件的线程，等释放互斥锁后，等待notEmptyCond条件的线程获取锁，再次判断条件
        self.notEmptyCond.notify_all()             
        self.lock.release()

    def deQueue(self):
        self.lock.acquire()
        while self.isEmpty():                  #队列空时触发等待notEmptyCond条件，线程阻塞同时释放互斥锁
            print('queue is empty, waiting...')
            self.notEmptyCond.wait()
        elem = self.list[0]
        del(self.list[0])
        print(threading.current_thread().getName() + ' consume ' + str(elem))
#当有资源出队列通知所有等待notFullCond条件的线程，等释放互斥锁后，等待notFullCond条件的线程获取锁，再次判断条件
        self.notFullCond.notify_all()              
        self.lock.release()

        return elem

信号量解决方案：

• 通过信号量来控制线程的同步，信号量管理可以获得资源的个数，初始队列为空，写信号量资源个数为队列长度，读信号量资源个数为0

from threading import Lock

from threading import Semaphore

import threading



class mySemQueue:

    def __init__(self, size):

        self.size = size

        self.list = list()

        self.lock = Lock()

        self.writeSem = Semaphore(size)#初始化写信号量

        self.readSem  = Semaphore(0)   #初始化读信号量

    

    def enQueue(self, elem):

        self.writeSem.acquire()        #资源入队申请写信号量，如果为0则阻塞

        

        self.lock.acquire()　　　　　　　 #互斥锁来保证资源的互斥访问

        self.list.append(elem)

        print(threading.current_thread().getName() + ' product ' + str(elem))

        self.lock.release()



        self.readSem.release()         #资源入队后释放一个读信号量，如果其它线程阻塞在这个信号量上，唤醒该线程



    def deQueue(self):

        self.readSem.acquire()         #资源出队申请读信号量，如果为0则阻塞



        self.lock.acquire()

        elem = self.list[0]

        del(self.list[0])

        print(threading.current_thread().getName() + ' consume ' + str(elem))

        self.lock.release()

        

        self.writeSem.release()        #资源出队后释放一个写信号量，如果其它线程阻塞在这个信号量上，唤醒该线程

        

        return elem

• 测试

from threading import Thread

import sys

import threading



class myThread(Thread):

    def __init__(self, func):

        Thread.__init__(self)

        self.func = func



    def run(self):

        print(threading.current_thread().getName() + ' start')

        self.func()



from myThread import myThread

from myQueue import myQueue

import random

import sys



def producter():

    while True:

        elem =random.randint(1, 100)

        que.enQueue(elem)



def consumer():

    while True:

        que.deQueue()



fp = open('log.txt','w')

sys.stdout = fp



que = myQueue(10)

t1 = myThread(producter)

t2 = myThread(consumer)

t3 = myThread(consumer)

t1.start()

t2.start()

t3.start()