2018-08-01-Python全栈开发day35-事件、IO、select-part1-进程与协程

1.进程间的通信

• 　　队列
• 管道
• managers

　　1.1 进程通过队列进行通信

　　　　

import multiprocessing,queue,time

def test(q):
    print('this is test')
    q.put(123)
    q.put('888')
    



if __name__ == '__main__':
    q=multiprocessing.Queue()
    p=multiprocessing.Process(target=test,args=(q,))#将队列传入进程，与主进程进行通讯
    p.start()

    print(q.get())
    print(q.get())

进程通过队列通信

　　1.1 通过管道通信

　　　　通过管道通信类似于socket

　　　　

from multiprocessing import Pipe,Process

def test(conn):
    conn.send('this is your litte')
    data=conn.recv()
    print(data)
    conn.close()


if __name__ == '__main__':
    brother_pipe,litte_pipe=Pipe()#大的就是本身这个进程，litte等会传给test这个进程
    p=Process(target=test,args=(litte_pipe,))#此时给test进程赋管道
    p.start()
    data=brother_pipe.recv()
    print(data)
    brother_pipe.send('hahah,this is your brother')
    p.join()

　　1.2 通过managers进行进程间通讯

　　　　通过managers封装的字典、列表等，可以被不同的进程获取。

　　　　

from multiprocessing import Manager,Process

def test(dict1,list1,n):
    dict1[123]='alex'
    dict1['alex']=888
    list1.append(n)

if __name__ == '__main__':
    with Manager() as manager:
        dict1=Manager().dict()#通过manager封装的字典
        list1=Manager().list()
        l=[]
        for i in range(5):
            p=Process(target=test,args=(dict1,list1,i))
            p.start()
            l.append(p)
        for s in l:
            s.join()
        print(dict1)
        print(list1)

2.进程池

　　因为进程的开销比较大，为了缓解这种情况，在程序运行时，生成一个池子，只有进入池子的进程才能得到执行，进程在池子里完成之后继续执行callback函数

　　

from multiprocessing import Process,Pool
import time

def test(n):
    print('this is %s process' %n)
    time.sleep(2)

def callback1(n):
    print('this is callback')

if __name__ == '__main__':

    pool=Pool(5)
    for i in range(100):
        p=pool.apply_async(func=test,args=(i,),callback=callback1)#会自动给callback一个参数
    pool.close()
    pool.join()
    print('end')

3.协程