41. Python Queue 多进程的消息队列 PIPE

昊漫玉

　　消息队列：
　　消息队列是在消息传输过程中保存消息的容器。
　　消息队列最经典的用法就是消费者和生产者之间通过消息管道来传递消息，消费者和生产生是不通的进程。生产者往管道中写消息，消费者从管道中读消息。

　　相当于水管，有一个入口和出口，水从入口流入出口流出，这就是一个消息队列
　　线程或进程往队列里面添加数据，出口从队列里面读数据
　　左侧多线程往入口处添加完数据，任务就结束了；右侧只要依次从水管里取数据就行了。
　　异步完成的任务
　　比如京东下单，下单后付完钱，相当于把消息堆在了水管里，后台会有线程去接收这个单的消息，然后去库房，发货，走物流，直到接收货物并签收完，点击完成，整个流程才走完。
　　客户交完钱后，丢了个消息在这个队列中，会给客户返回一个结果，告知你已经买了这个商品；而后面接收订单消息，发货，物流都是后面的"进程"或"线程"干的事情。
　　所以，一般在异步处理问题时候，都会用到消息队列处理的这种思想。
　　使用multiprocessing里面的Queue来实现消息队列。
　　语法:
from mutliprocessing import Queue　　
q = Queue
　　
q.put(data)
　　
data = q.get(data)
　　举例：
from multiprocessing import Queue, Process　　

　　
def write(q):
　　
    for i in ['a','b','c','d']:
　　
        q.put(i)
　　
        print ('put {0} to queue'.format(i))
　　

　　
def read(q):
　　
    while 1:
　　
        result = q.get()
　　
        print ("get {0} from queue".format(result))
　　

　　

　　
def main():
　　
    q = Queue()
　　
    pw = Process(target=write,args=(q,))
　　
    pr = Process(target=read,args=(q,))
　　
    pw.start()
　　
    pr.start()
　　
    pw.join()
　　
    pr.terminate()  #停止
　　
    # 相当于join，等pr完成以后，当whlie没有任何执行后，结束。
　　

　　
if __name__ == '__main__':
　　
    main()
　　返回结果：
put a to queue　　
get a from queue
　　
put b to queue
　　
get b from queue
　　
put c to queue
　　
get c from queue
　　
put d to queue
　　
get d from queue
　　PIPE：
　　多进程里面有个pipe的方法来实现消息队列：
　　1. Pipe 方法返回(conn1, conn2)代表一个管道的两端。PIPE方法有个deplex参数，如果deplex参数为True（默认值），那么这个管道是全双工模式，也就是说conn1和conn2均可收发。duplex为False，conn1只负责接收消息，conn2负责发送消息。
　　2.send 和recv方法分别是发送和接受消息的方法。close方法表示关闭管道，当消息接收结束以后，关闭管道。
import time　　
from multiprocessing import Pipe, Process
　　

　　

　　
def proc1(pipe):
　　
    for i in xrange(1, 10):
　　
        pipe.send(i)
　　
        print ("send {0} to pipe".format(i))
　　
        time.sleep(1)
　　

　　

　　
def proc2(pipe):
　　
    n = 9
　　
    while n > 0:
　　
        result = pipe.recv()
　　
        print ("recv {0} from pipe".format(result))
　　
        n -= 1
　　

　　

　　

　　
def main():
　　
    pipe = Pipe(duplex=False)
　　
    print (type(pipe))
　　
    p1 = Process(target=proc1, args=(pipe[1],))
　　
    p2 = Process(target=proc2, args=(pipe[0],)) #接收写0
　　
    p1.start()
　　
    p2.start()
　　
    p1.join()
　　
    p2.join()
　　
    pipe[0].close()
　　
    pipe[1].close()
　　

　　

　　
if __name__ == '__main__':
　　
    main()
　　返回结果(逐行打印):
<type 'tuple'>　　
send 1 to pipe
　　
recv 1 from pipe
　　
recv 2 from pipe
　　
send 2 to pipe
　　
send 3 to pipe
　　
recv 3 from pipe
　　
recv 4 from pipe
　　
send 4 to pipe
　　
send 5 to pipe
　　
recv 5 from pipe
　　
recv 6 from pipe
　　
send 6 to pipe
　　
recv 7 from pipe
　　
send 7 to pipe
　　
recv 8 from pipe
　　
send 8 to pipe
　　
send 9 to pipe
　　
recv 9 from pipe