Python 生產者消費者問題

生產者消費之模型就是,比如一個包子鋪,中的顧客吃包子,和廚師做包子,
不可能是將包子一塊做出來,在給顧客吃,但是單線程只能這麼做,
所以用多線程來執行,廚師一邊做包子,顧客一邊吃包子,
當顧客少時,廚師做的包子就放在一個容器中,等着顧客來吃,
當顧客多的時候,就從容器中先取出來給顧客吃,廚師繼續做包子
用隊列來模擬這個容器

1. 當做完一個包子後就要給顧客發送一個信號,表示已經做完,讓他們吃包子

import threading, time, queue
q = queue.Queue()
def Produce(name):
    count = 0   #   conut表示做的包子總個數
    while count < 10:
        print('廚師%s在做包子中...'%name)
        time.sleep(2)
        q.put(count)   # 容器中添加包子
  # 當做完一個包子後就要給顧客發送一個信號,表示已經做完,讓他們吃包子
        print('produce%s已經做好了第%s個包子'%(name, count))
        count += 1
        print('oking...')
def Consumer(name):
    count = 0    #  count表示包子被吃的總個數
    while count < 10:
        time.sleep(2)  #  排隊去取包子,
        if not q.empty():   # 如果存在
            data = q.get() #  取包子, 吃包子
            print('\033[32;1mConsumer %s已經把第%s個包子吃了...\033[0m' %(name, data))
        else:
            print('包子被吃完了...')
        count += 1
if __name__ == '__main__':
    p1 = threading.Thread(target=Produce, args=('A君',))
    c1 = threading.Thread(target=Consumer, args=('B君',))
    c2 = threading.Thread(target=Consumer, args=('C君',))
    c3 = threading.Thread(target=Consumer, args=('D君',))
    p1.start()
    c1.start()
    c2.start()
    c3.start()

2.這裏就是: 當顧客吃完了然後給生產者發送一個信號,當生產者就接收到信號時,繼續做包子

import threading, time, queue
q = queue.Queue()
def Produce(name):
    count = 0   #   conut表示做的包子總個數
    while count < 10:
        print('廚師%s在做包子中...'%name)
        time.sleep(2)
        q.put(count)   # 容器中添加包子
  # 當做完一個包子後就要給顧客發送一個信號,表示已經做完,讓他們吃包子
        print('produce%s已經做好了第%s個包子'%(name, count))
        count += 1
        print('oking...')
def Consumer(name):
    count = 0    #  count表示包子被吃的總個數
    while count < 10:
        time.sleep(2)  #  排隊去取包子,
        if not q.empty():   # 如果存在
            data = q.get() #  取包子, 吃包子
            print('\033[32;1mConsumer %s已經把第%s個包子吃了...\033[0m' %(name, data))
        else:
            print('包子被吃完了...')
        count += 1
if __name__ == '__main__':
    p1 = threading.Thread(target=Produce, args=('A君',))
    c1 = threading.Thread(target=Consumer, args=('B君',))
    c2 = threading.Thread(target=Consumer, args=('C君',))
    c3 = threading.Thread(target=Consumer, args=('D君',))
    p1.start()
    c1.start()
    c2.start()
    c3.start()

3.利用同步對象

event = threading.Event()
def Produce(name):
    count = 0   #   conut表示做的包子總個數
    while count < 10:
        print('廚師%s在做包子中...'%name)
        time.sleep(2)
        q.put(count)   # 容器中添加包子
        print('produce%s已經做好了第%s個包子'%(name, count))
        event.set()  # 等待接收信號,
        count += 1

def Consumer(name):
    count = 0  
    while count < 10:
        # time.sleep(2)
        event.wait()
        data = q.get()  # 取包子, 吃包子
        print('%seating...'%name)
        time.sleep(2)   #   吃包子用了2s然後給廚師發送一個信號
        print('\033[32;1mConsumer %s已經把第%s個包子吃了...\033[0m' % (name, data))
        event.clear()
        count += 1

4. 協程實現

def consumer():
    r = ''
    while True:
        n = yield r
        if not n:
            return
        print('[CONSUMER] Consuming %s ...' % n)
        r = '200 OK'


def produce(c):
    c.send(None)
    n = 0
    while n < 5:
        n = n + 1
        print('[PRODUCER] Producing %s ...' % n)
        r = c.send(n)
        print('[PRODUCER] Consumer return: %s ' % r)
    c.close()


c = consumer()
produce(c)

參考：
https://www.liaoxuefeng.com/wiki/1016959663602400/1017968846697824
https://www.cnblogs.com/xiaokang01/p/9096475.html