生产者消费者模型（Queue，JoinableQueue模块）

#模块：Queue
#导入方法：from multiprocessing import Process,Queue
#模块方法：
       from multiprocessing import Queue   借助Queue解决生产者消费者模型
       队列是安全的。
       q = Queue(num)
       num ： 队列的最大长度
       q.get()# 阻塞等待获取数据，如果有数据直接获取，如果没有数据，阻塞等待
       q.put()# 阻塞，如果可以继续往队列中放数据，就直接放，不能放就阻塞等待
       q.get_nowait()# 不阻塞，如果有数据直接获取，没有数据就报错
       q.put_nowait()# 不阻塞，如果可以继续往队列中放数据，就直接放，不能放就报错
#使用方法：生产者消费者模型（主要是为解耦）


###################
from multiprocessing import Process,Queue
import time

def consumer(q,student):
    while 1:
        str=q.get()
        if str:
            print(student+"拿走了{}".format(str))
        else:   #如果该字符串为空，表示生产者停止生产，则消费者程序退出，否则将会在q.get()中阻塞程序
            break

def producer(q,version):
    for i in range(20):
        info = version+"{}的蛋糕".format(i)
        q.put(info)
    q.put(None) #生产停止的标志，告诉消费者不再生产产品

if __name__ == '__main__':
    q=Queue()
    pCon=Process(target=consumer,args=(q,'学生'))
    pPro=Process(target=producer,args=(q,'粤牌'))
    pCon.start()
    pPro.start()
    #扩充，可以在父进程中写q.put(None)而不需要在生产者中写，但必须保证生产者能完整生产所有产品，即父进程等待生产者进程的方法为join
    #pPro.join()
    #q.put(None)
    #如果有多个生产者，但是最后的结束标志需要根据消费者进程数进行设置，比如有2个消费者进程，则需q.put(None)两次



###################################

from multiprocessing import Queue# 是用于多进程的队列，就是专门用来做进程间通信（IPC）。
import queue# 是用于同一进程内的队列，不能做多进程之间的通信

# q = queue.Queue()
# # 先进先出
# q.put(1)
# q.put(2)
# q.put(3)
# print(q.get())
# print(q.get())

# q = queue.LifoQueue()
# # 后进先出的队列
# q.put(1)
# q.put(2)
# q.put(3)
# print(q.get())

q = queue.PriorityQueue()
# 优先级队列，put()方法接收的是一个元组（），第一个位置是优先级，第二个位置是数据
# 优先级如果是数字，直接比较数值
# 如果是字符串，是按照 ASCII 码比较的。当ASCII码相同时，会按照先进先出的原则
# q.put((1,'abc'))
# q.put((5,'qwe'))
# q.put((-5,'zxc'))
# print(q.get())
# print(q.get())
# print(chr(48))

#模块：JoinableQueue
#导入方法：from multiprocessing import Process,JoinableQueue
#模块方法：
       JoinableQueue是继承Queue，所以可以使用Queue中的方法
       并且JoinableQueue又多了两个方法
       q=JoinableQueue()
       q.join()# 用于生产者。等待 q.task_done的返回结果，通过返回结果，生产者就能获得消费者当前消费了多少个数据
       q.task_done() # 用于消费者，是指每消费队列中一个数据，就给join返回一个标识。
       
       
       
#使用方法：生产者消费者模型
from multiprocessing import Process,JoinableQueue

q = JoinableQueue()
# 假设生产者生产了100个数据，join就能记录下100这个数字。每次消费者消费一个数据，就必须要task_done返回一个标识，当生产者（join）接收到100个消费者返回来的标识的时候，生产者就能知道消费者已经把所有数据都消费完了。

from multiprocessing import Queue,Process
import time

def consumer(q,name,color):
    while 1:
        info = q.get()
        print('%s %s 拿走了%s 33[0m'%(color,name,info))
        q.task_done()

def producer(q,product):
    for i in range(20):
        info = product + '的娃娃%s号'%str(i)
        q.put(info)
    q.join()# 记录了生产了20个数据在队列中,此时会阻塞等待消费者消费完队列中所有数据

if __name__ == '__main__':
    q = JoinableQueue(10)
    p_pro1 = Process(target=producer,args=(q,'岛国米饭保你爱'))
    p_con1 = Process(target=consumer,args=(q,'alex','33[31m'))
    p_con1.daemon = True# 把消费者进程设为守护进程
    p_con1.start()
    p_pro1.start()
    p_pro1.join()# 主进程等待生产者进程结束
    # 程序有3个进程，主进程和生产者进程和消费者进程。  当主进程执行到35行代码时，主进程会等待生产进程结束
    # 而生产进程中（第26行）会等待消费者进程把所有数据消费完，生产者进程才结束。
    # 现在的状态就是  主进程等待生产者进程结束，生产者进程等待消费者消费完所有数据
    # 所以，把消费者设置为守护进程。  当主进程执行完，就代表生产进程已经结束，也就代表消费者进程已经把队列中数据消费完
    # 此时，主进程一旦结束，守护进程也就是消费者进程也就跟着结束。    整个程序也就能正常结束了。