队列

栈：先进后出（First In Last Out 简称 FILO）
队列： 先进先出（First In First Out 简称 FIFO）
from multiprocessing import Queue
q = Queue(num)
num ： 队列的最大长度
q.get()  # 阻塞等待获取数据，如果有数据直接获取，如果没有数据，阻塞等待
q.put()  # 阻塞，如果可以继续往队列中放数据，就直接放，不能放就阻塞等待

q.get_nowait()  # 不阻塞，如果有数据直接获取，没有数据就报错
q.put_nowait()  # 不阻塞，如果可以继续往队列中放数据，就直接放，不能放就报错

from multiprocessing import Queue
q = Queue(3)
q.put(123)
q.put("aaa")
print(123)
q.put([1,2,3])
print(456)
q.put("你好")
print(789)
结果:
123
456

from multiprocessing import Queue
q = Queue(3)
q.put(123)
q.put("aaa")
print(123)
q.put([1,2,3])
print(456)
q.put_nowait("你好")
print(789)
报错:Full

from multiprocessing import Queue
q = Queue(3)
q.put(123)
q.put("aaa")
print(123)
q.put([1,2,3])
print(456)
try:
    q.put_nowait("你好")
except:
    print("队列满了")
print(789)

from multiprocessing import Queue
q = Queue(3)
q.put(123)
q.put("aaa")
q.put([1,2,3])

print(q.get())
print(q.get())
print(q.get())
print(q.get()) #阻塞等待



from multiprocessing import Queue
q = Queue(3)
q.put(123)
q.put("aaa")
q.put([1,2,3])

print(q.get())
print(q.get())
print(q.get())
print(q.get_nowait())
报错:Empty

生产者消费者模型
主要是为解耦
借助队列来实现生产者消费者模型
借助Queue解决生产者消费者模型

from multiprocessing import Process,Queue
def consumer(q,name):
    while 1 :
        info = q.get()
        if info:
            print("%s购买了%s" % (name,info))
        else:
            break
def producer(q,product):
    for i in range(20):
        info = product + "的拉菲%s箱" %str(i)
        q.put(info)
    q.put(None)

if __name__ == '__main__':
    q = Queue(10)
    p = Process(target=consumer,args=(q,"aa"))
    p1 = Process(target=producer,args=(q,"97年的"))
    p.start()
    p1.start()

将生产者生产结束的标识，放到父进程中

from multiprocessing import Process, Queue
def consumer(q, name,color):
    while 1:
        info = q.get()
        if info:
            print("%s %s购买了%s 33[0m" % (color,name, info))
        else:
            break
def producer(q, product):
    for i in range(20):
        info = product + "的拉菲%s箱" % str(i)
        q.put(info)
if __name__ == '__main__':
    q = Queue(10)
    p = Process(target=consumer, args=(q, "aa","33[31m"))
    p1 = Process(target=producer, args=(q, "97年的"))
    p.start()
    p1.start()
    p1.join()
    q.put(None)

from multiprocessing import Process, Queue
def consumer(q, name,color):
    while 1:
        info = q.get()
        if info:
            print("%s %s购买了%s 33[0m" % (color,name, info))
        else:
            break
def producer(q, product):
    for i in range(20):
        info = product + "的拉菲%s箱" % str(i)
        q.put(info)
if __name__ == '__main__':
    q = Queue(10)
    P1 = Process(target=consumer, args=(q, "aa","33[31m"))
    P2 = Process(target=consumer, args=(q, "bb","33[31m"))
    p1 = Process(target=producer, args=(q, "97年的"))
    p2 = Process(target=producer, args=(q, "98年的"))
    p3 = Process(target=producer, args=(q, "99年的"))
    p = [p1,p2,p3,P1,P2]
    [i.start() for i in p]
    p1.join()
    p2.join()
    p3.join()
    q.put(None)
    q.put(None)

from multiprocessing import JoinableQueue#可连接的队列
       JoinableQueue是继承Queue，所以可以使用Queue中的方法
       并且JoinableQueue又多了两个方法
       q.join()# 用于生产者。等待 q.task_done的返回结果，通过返回结果，生产者就能获得消费者当前消费了多少个数据
       q.task_done() # 用于消费者，是指每消费队列中一个数据，就给join返回一个标识。
假设生产者生产了100个数据，join就能记录下100这个数字。每次消费者消费一个数据，就必须要task_done返回一个标识，

from multiprocessing import JoinableQueue,Process
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,produce):
    for i in range(20):
        info = produce+"拉菲%s箱" % str(i)
        q.put(info)
    q.join()
if __name__ == '__main__':
    q = JoinableQueue(10)
    p1 = Process(target=consumer,args=(q,"aa","33[32m"))
    p2 = Process(target=producer,args=(q,"92年的"))
    p1.daemon = True # 把消费者进程设为守护进程
    p1.start()
    p2.start()
    p2.join()
程序有3个进程，主进程和生产者进程和消费者进程。当主进程执行到p2.join()，主进程会等待生产进程结束
    而生产进程中q.join()会等待消费者进程把所有数据消费完，生产者进程才结束。
    现在的状态就是  主进程等待生产者进程结束，生产者进程等待消费者消费完所有数据
    所以，把消费者设置为守护进程。  当主进程执行完，就代表生产进程已经结束，也就代表消费者进程已经把队列中数据消费完
    此时，主进程一旦结束，守护进程也就是消费者进程也就跟着结束。 整个程序也就能正常结束了。

from multiprocessing import Queue #是用于多进程的队列,就是专门用来做进程间通信(IPC)

import queue#是用于同一进程内的队列,不能做多进程之间的通信

from multiprocessing import Queue #是用于多进程的队列,就是专门用来做进程间通信(IPC)
先进先出
q = Queue()
q.put(1)
q.put(2)
q.put(3)
print(q.get())
print(q.get())
print(q.get())
import queue#是用于同一进程内的队列,不能做多进程之间的通信
q = queue.LifoQueue()
后进先出
q.put(1)
q.put(2)
q.put(3)
print(q.get())
print(q.get())
print(q.get())

import queue#是用于同一进程内的队列,不能做多进程之间的通信
q = queue.PriorityQueue()
优先级队列,
put()方法接受的是个元祖,以一个参数是优先级,第二个参数是数据
优先级如果是数字,直接比较数值
如果是字符串，是按照 ASCII 码比较的。当ASCII码相同时，会按照先进先出的原则
q.put((1,123))
q.put((20,456))
q.put((5,789))
print(q.get())
print(q.get())
print(q.get())