Note11：python多进程

一、多进程创建

from multiprocessing import Process


def fun(n):
    print('process task', n)

if __name__ == '__main__':
    for i in range(10):
        p = Process(target=fun, args=(i,))
        p.start()
    print('end')
    
#执行结果
# end
# process task 5
# process task 8
# process task 4
# process task 6
# process task 9
# process task 3
# process task 7
# process task 0
# process task 2
# process task 1 

    由此看出，python多进程的创建与多线程是相似的。

 

二、进程之间的通信问题。

    进程之间的内存是相互独立的，当父进程创建了一个子进程时，它的内存数据都会被子进程复制一份。如图：

    我们再来看一个代码：

from multiprocessing import Process


def fun1(li):
    li.append('abc')

if __name__ == '__main__':
    li = []
    p = Process(target=fun1, args=(li,))
    p.start()
    print(li)

# 执行结果
# []

    很清晰地看出，父进程与子进程的数据是不共享的。

    我们再来看一个线程的例子：

import threading


def fun1(li):
    li.append('abc')

if __name__ == '__main__':
    li = []
    t = threading.Thread(target=fun1, args=(li,))
    t.start()
    print(li)

# 执行结果
# ['abc']

    同样很清晰地看出，主线程与子线程的数据是共享的。

    那么问题来了，如何实现进程之间的通信呢？

    

三、通过Queue来实现进程之间的通信。

from multiprocessing import Process,Queue


def fun1(queue):
    queue.put(['a', 'b', 'c'])

if __name__ == '__main__':
    queue = Queue()
    p = Process(target=fun1, args=(queue,))
    p.start()
    print(queue.get())

# 执行结果
# ['a', 'b', 'c']

    通过复制成另一个q传给了函数，q往里面放入了数据后。其实是通过pickle序列化给一个中间代理，再通过反序列化给Q，因此主进程取出来的数据就是子进程往里面放进去的数据。这样就实现了两个进程间的通信。

 

四、通过Pipe来实现进程之间的通信

from multiprocessing import Process,Pipe


def fun1(conn):
    conn.send(['a', 'b', 'c'])
    conn.send("hello word!")
    print('----fun1----', conn.recv())

if __name__ == '__main__':
    p_conn, c_conn = Pipe()
    p = Process(target=fun1, args=(c_conn,))
    p.start()
    print(p_conn.recv())
    print(p_conn.recv())
    p_conn.send({'a': 97, 'b': 98})
    
#执行结果
# ['a', 'b', 'c']
# hello word!
# ----fun1---- {'a': 97, 'b': 98}

    首先调用pipe()返回了两头管道，两管道通向不同的进程，所以可以通过管道进行不同进程的数据传递。

 

五、通过Manager来实现进程之间的共享数据。

    Queue和Pipe实际上实现的是进程间的数据传递，并没有在进程间共享数据，如果要共享数据的话，需要用到Manager。

from multiprocessing import Process,Manager
import os


def fun1(d, l):
    d['a'] = 97
    d['b'] = 98
    l.append(os.getpid())

if __name__ == '__main__':
    manager = Manager()
    d = manager.dict()
    l = manager.list()
    p_list = []
    for i in range(10):
        p = Process(target=fun1, args=(d, l))
        p.start()
        p_list.append(p)
    for i in p_list:
        i.join()
    print(d)
    print(l)
    
#执行结果
# {'a': 97, 'b': 98}
# [10080, 7652, 7756, 2820, 6772, 6480, 4248, 10708, 4756, 3368]

    通过manager实现两个进程间的通信，修改数据。使用manager注意：主进程必须等待子进程执行完成后才能退出，否则会出错，所以必须加join等待子进程执行完成。

 

六、进程池

    以上我们知道进程之间不共享数据，当父进程创建一个子进程的时候，子进程会把父进程的数据全部克隆一遍，那如果父进程的数据很大，又创建了很多个子进程的话，那么将占用的空间将会很大。

    因此，当需要创建的子进程数量不多时，可以直接利用multiprocessing中的Process动态成生多个进程，但如果是上百甚至上千个目标，手动的去创建进程的工作量巨大，此时就可以用到multiprocessing模块提供的Pool方法。

    

from multiprocessing import Pool, Process
import time
import os


def fun1(n):
    time.sleep(1)
    print('Process task:', os.getpid())

if __name__ == '__main__':
    pool = Pool(3)
    for i in range(13):
        pool.apply_async(fun1, (i,))
    pool.close()#关闭进程池，关闭后pool不再接收新的请求
    pool.join()#等待pool中所有子进程执行完成，必须放在close语句之后
    print('----end----')

    运行结果是每三个一输出。说明当在Pool(3)传入的值为3时，那么在13个子进程中是每次将3个进程放入进程池中同时执行，其他则在休眠。

    其中pool.apply_async()可以通过回调函数来实现异步。什么是异步呢，就是当你一直在干一件事的时候，你突然去干另一件事，干完后再接着干之前的事。

    

from multiprocessing import Pool
import time
import os


def fun1():
    print('-----fun1----Process task:', os.getpid())
    for i in range(3):
        print('----id-----',i)
        time.sleep(1)
    return 'ok'


def log(args):
    print('----log---process task', os.getpid())
    print('---log----args:', args)

if __name__ == '__main__':
    pool = Pool(4)
    pool.apply_async(func=fun1, callback=log)
    while True:
        time.sleep(1)
        print('----main process----process task', os.getpid())

#执行结果
# -----fun1----Process task: 14908
# ----id----- 0
# ----main process----process task 11560
# ----id----- 1
# ----main process----process task 11560
# ----id----- 2
# ----main process----process task 11560
# ----log---process task 11560
# ---log----args: ok
# ----main process----process task 11560
# ...

    回调函数test中必须有一个参数args，当主进程创建一个子进程时，并发回调函数时，当子进程执行完了之后，子进程返回了OK给主进程，主进程调用回调函数并且将OK传给回调函数当参数。所以回调函数输入args为ok。

 

七、总结

    python多进程是不共享数据的，当主进程创建一个子进程的时候，子进程会将主进程内的数据全都拷贝一份给自己。

    为了实现不同进程之间的通信，我们有进程Queue,Pipe,Manger方法来实现。其中Queue,Pipe是两进程之间用来数据传递的。Manager是用来共享数据的。

    为了解决当创建很多个子进程造成内存空间占用过大的情况，我们用进程池Pool来解决这个问题。同时进程池中通过回调函数 也可以实现异步。