【进程与线程】多进程

多进程multiprocessing

from multiprocessing import Process
import os

def info(title):
    print(title)
    print('module name:',__name__)
    print('parent process:',os.getppid())
    print('process id:',os.getpid())
    print('\n')

def f(name):
    print('\033[31;1mfunction f\033[0m')
    print('hello',name)

if __name__ == '__main__':
    info('\033[32;1mmain process line\033[0m')
    p=Process(target=f,args=('q1ang',))
    p.start()
    # p.join()

>>>

main process line
module name: __main__
parent process: 8044
process id: 11048


function f
hello q1ang

两进程间的通讯

不同进程间内存是不共享的，要想实现两个进程间的数据交换，可以用以下方法：

1.进程Queues

def a(q):
    q.put('hehe')


if __name__=='__main__':
    q=Queue()
    p=Process(target=a,args=(q,))
    p.start()
    print(q.get())
    p.join()

2.Pipe

from multiprocessing import Process,Pipe

def a(conn):
    conn.send('hehe')
    conn.close()

if __name__ == '__main__':
    parent_conn,child_conn=Pipe()
    p=Process(target=a,args=(child_conn,))
    p.start()
    print(parent_conn.recv())
    p.join()

3.Managers

from multiprocessing import Process,Manager

def a(d,l):
    d[1]='1'
    d['2']=2
    d[3]=None
    l.append(1)
    print(l)

if __name__ == '__main__':
    with Manager() as manager:
        d=manager.dict()
        l=manager.list(range(5))

        p_list=[]
        for i in range(10):
            p=Process(target=a,args=(d,l))
            p.start()
            p_list.append(p)
        for res in p_list:
            res.join()

        print(d)
        print(l)

 进程同步：主要功能是屏幕锁

from multiprocessing import Process,Lock

def f(l,i):
    l.acquire()
    try:
        print('hello world',i)
    finally:
        l.release()

if __name__ == '__main__':
    lock=Lock()

    for num in range(10):
        Process(target=f,args=(lock,num)).start()

进程池

进程池内部维护一个进程序列，当使用时，则去进程池中获取一个进程，如果进程池序列中没有可供使用的进进程，那么程序就会等待，直到进程池中有可用进程为止。

apply_async(并行)
apply(串行)

from multiprocessing import Pool
import time,os

def Foo(i):
    time.sleep(1)
    print(i)
    return i

def Bar(arg):
    print('-->exec done:', arg,os.getpid())

if __name__ == '__main__':
    pool = Pool(5) #允许进程池同时放入五个进程
    print(os.getpid())
    for i in range(10):
        #apply_async(并行)
        #apply(串行)
        # pool.apply_async(func=Foo, args=(i,), callback=Bar)#callback回调
        pool.apply(func=Foo, args=(i,))
        print('end')
    pool.close()
    pool.join()  # 进程池中进程执行完毕后再关闭，如果注释，那么程序直接关闭。