本文首发于公众号：Hunter后端
原文链接：Python笔记六之多进程
在 Python 里，我们使用 multiprocessing 这个模块来进行多进程的操作。
multiprocessing 模块通过创建子进程的方式来运行多进程，因此绕过了 Python 里 GIL 的限制，可以充分利用机器上的多个处理器。
1、多进程使用示例
多进程的使用方式和多线程的方式类似，这里使用到的是 multiprocessing.Process 类，下面是一个简单的示例：
from multiprocessing import Process
import time
def f(x):
if x % 2 == 1:
time.sleep(x+1)
print(x * x)
return x * x
def test_multi_process():
processes = []
for i in range(5):
processes.append(Process(target=f, args=(i,)))
for p in processes:
p.start()
for p in processes:
p.join(0.5)
for p in processes:
print(p, p.is_alive(), p.pid, p._parent_pid)
if __name__ == "__main__":
test_multi_process()
在上面的示例中，test_multi_process() 函数里使用多进程的方式调用 f 函数，和多线程的调用方式一致，通过 start() 方法启动进程活动，使用 join() 方法阻塞调用其的进程。
接下来介绍一下 multiprocessing.Process 的一些方法和属性。
1. run()
表示进程活动的方法，可以在子类中重载此方法，比如多线程笔记的操作里重写 run() 对函数执行报错进行了处理，并返回了执行结果
2. start()
启动进程活动，将对象的 run() 方法在一个单独的进程中调用
3. join()
阻塞调用 join() 方法的进程，在上面的示例中也就是父进程，默认值为 None，也就表示阻塞操作。
如果设置为其他正数值，那么则最多会阻塞多少秒，比如上面的示例为 0.5 秒，如果超时，那么父进程则会继续往后执行。
比如上面的示例输出结果如下：
0
4
16
'Process-1' pid=6600 parent=24248 stopped exitcode=0> False 6600 24248
'Process-2' pid=4368 parent=24248 started> True 4368 24248
'Process-3' pid=13024 parent=24248 stopped exitcode=0> False 13024 24248
'Process-4' pid=3288 parent=24248 started> True 3288 24248
'Process-5' pid=16880 parent=24248 stopped exitcode=0> False 16880 24248
1
9
在打印每个进程的信息时，f() 函数内部进行 sleep 的进程还没有执行结束，但是进程已经超时了，所以不再阻塞父进程向下执行。
4. is_alive()
上面有打印出信息，返回布尔值，表示该进程是否还活着。
5. pid 和 parent_pid
上面使用 .pid 和 ._parent_pid 属性打印出了每个进程的 id 和其父进程的 id。
2、进程池
进程使用的对象是 multiprocessing.pool.Pool()。
接受 processes 参数为进程数，表示要使用的工作进程数目，如果不传入，则默认使用 cpu 的核数，根据 os.cpu_count() 获取。
接下来分别使用示例介绍 multiprocessing.pool 下的几个调用方法，进程池的使用可以使用 map() 和 starmap() 两个函数。
1. map()
map() 接受两个参数，func 表示多进程要执行的函数，iterable 表示要执行的 func 函数输入的参数的迭代对象。
这里需要注意一下，map() 函数使用的 func 函数只能接受一个参数，比如我们前面定义的 f 函数，下面是其使用示例：
def f(x):
return x * x
def test_pool_map():
with Pool(processes=4) as pool:
results = pool.map(func=f, iterable=range(10))
print(results)
2. starmap()
starmap() 函数与 map() 使用方法类似，但是 iterable 迭代参数的元素是 func 函数的多个参数，比如我们想要对下面的 add() 函数使用多进程：
def f_add(x, y):
return x + y
它的调用方式如下：
def test_pool_starmap():
with Pool(processes=4) as pool:
results = pool.starmap(func=f_add, iterable=zip(range(6), range(6, 12)))
print(results)
这里返回的 results 是一个列表，元素是每个进程执行的函数的返回结果。
3、进程间交换对象
前面介绍了，多进程的运行方式是通过建立子进程的形式来操作，而不同进程间数据是不共享的，这一点不同于多线程。
因为多线程的操作是在同一个进程内实现的，所以线程间数据是共享数据资源的。
接下来介绍一下如何在进程间进行对象的交换，其实进程间进行对象的交换是一个子命题，更高层级的概括是在进程间进行通信，在官方的文档中对其进行了细分，所以这里也对其进行分类别的介绍。
在进程间进行对象交换的方式有两种，一种是队列，一种是管道。
1. 队列
1) 队列的代码示例
这里的模块的引入是 multiprocess.Queue，这个类近似于是 queue.Queue 的克隆，以下是官方文档的一个示例，内容是在父进程中创建一个队列，然后在子进程中写入数据，然后再在父进程中读取：
from multiprocessing import Process, Queue
def f(q):
q.put([42, None, 'hello'])
if __name__ == '__main__':
q = Queue()
p = Process(target=f, args=(q,))
p.start()
print(q.get()) # prints "[42, None, 'hello']"
p.join()
队列的写入使用 put()，读取使用 get()。
get() 还可以加上两个参数，block 和 timeout，block 表示是否阻塞，timeout 表示获取的超时时间。
接下来我们再实现一个功能，两个子进程写入数据，一个子进程读取数据，代码示例如下：
from multiprocessing import Queue, Process
def f_write(q, n, name):
for i in range(n):
q.put(f"{name}_{i}")
time.sleep(0.1)
def f_read(q):
while q.qsize() > 0:
print(q.get(block=False, timeout=1))
time.sleep(0.5)
def test_queue():
# 三个进程，一个写进程，两个读进程
q = Queue()
q.put("origin_value")
q.put("b")
# p1 = Process(target=f_queue, args=(q, "c"))
# p2 = Process(target=f_queue, args=(q, ))
p1 = Process(target=f_write, args=(q, 5, "a"))
p2 = Process(target=f_write, args=(q, 8, "b"))
p3 = Process(target=f_read, args=(q,))
p1.start()
p2.start()
p3.start()
p1.join()
p2.join()
p3.join()
print("total: ", q.qsize())
if __name__ == "__main__":
test_queue()
2) 队列的相关方法
关于队列的相关函数，除了前面介绍的几种，还有比如判断队列的长度，是否为空等。
a) Queue()
在定义一个队列的时候，我们前面是直接定义 q=Queue()，不为其设置元素长度，而如果我们想要为其设置一个最大的长度，可以加上 maxsize 参数：
q = Queue(maxsize=3)
那么队列里最多只能有三个元素，而如果队列满了还往其中 put() 加入操作，则会阻塞，直到其他进程对其读取其中的数据。
b) put()
put() 函数表示的是往队列里添加元素，元素的类型不限，添加数字，字符串，字典，列表都可以：
q = Queue()
q.put(1)
q.put({"a": 4})
q.put([1,3,4])
前面介绍了，如果队列满了，还往队列里进行 put() 操作，则会进入阻塞操作，可以通过添加 block 或者 timeout 来进行避免。
block 表示是否阻塞，为 True 的话则会进入阻塞等待状态。False 的话则会引发异常。
timeout 表示超时，尝试往队列里添加数据，超出等待时间同样已发队列已满的异常。
c) get()
get() 函数表示从队列中读取元素，队列的写入和读取的原则是先入先出，最先进去的最先出来。
而为了避免队列为空的情况下进行 get() 进入阻塞状态，get() 可以使用两个参数，一个是 block，表示是否阻塞，一个是 timeout，表示超时时间。
如果队列为空还进行 get() 操作，使用上面这两个操作则会 raise 一个 Empty 的 error。
d) qsize()
返回队列的长度，但由于多进程或多线程的上下文，这个数字是不可靠的。
e) empty()
如果队列是空的，则返回 True，否则返回 False，由于多进程或多线程的环境，该状态是不可靠的。
f) full()
如果队列设置了 maxsize 参数，那么如果队列满了，则返回 True，否则返回 False，由于多进程或多线程的环境，该状态是不可靠的。
g) close()
关闭队列，如果执行了 q.close()，再往里面添加元素执行 q.put() 操作，则会引发报错。
2. 管道
1) 管道的相关函数
管道的引入方式如下：
from multiprocessing import Pipe
管道的定义可以直接实例化 Pipe，返回管道的两端：
conn1, conn2 = Pipe()
默认情况下，Pipe() 的参数 duplex 值为 True，表示管道是双工的，也就是可以双向通信的，比如 conn1 可以写入，也可以读出，conn2 可以写入也可以读出数据。
而如果手动设置 duplex 为 False，那么管道则是单向的，conn1 只能用于接收消息，conn2 只能发送消息。
管道用于发送和接收的函数分别如下：
发送信息
conn.send(obj)
发送的对象可以是字符串，也可以是其他对象，比如列表，字典等。
接收信息
conn.recv()
关闭连接对象
我们可以使用 close() 来关闭连接对象，当连接对象被垃圾回收时会自动调用：
conn.close()
判断连接对象中是否有可以读取的数据
如果我们直接使用 conn.recv() 的时候，如果管道内没有可接收的对象，会进入阻塞状态，直到管道内传入数据。
我们可以使用 poll() 函数判断管道内是否有可以读取的数据，返回的是一个布尔型数据，表示是否有数据：
has_data = conn.poll()
但是如果不设置超时时间，同样会进入等待状态，所以可以设置一个最大阻塞秒数：
has_data = conn.pool(timeout=3) # 等待 3 秒
2) 管道的代码示例
接下来我们用下面的代码来进行管道的双工测试，即从管道的两端分别写入和读取数据。
from multiprocessing import Process, Pipe
def send_info(conn, info):
conn.send(info)
conn.close()
def read_info(conn):
while conn.poll(timeout=2):
info = conn.recv()
print(info)
def test_pipe():
# 两个 conn 分别都往里面读和写
parent_conn, child_conn = Pipe()
# p1 向 child 管道写入
print("id out of func: ", id(child_conn))
p1 = Process(target=send_info, args=(child_conn, "send_info_from_child"))
p1.start()
p1.join()
# p2 从 parent 管道读取
p2 = Process(target=read_info, args=(parent_conn,))
p2.start()
p2.join()
# p3 向 parent 管道写入
p3 = Process(target=send_info, args=(parent_conn, "send_info_from_parent"))
p3.start()
p3.join()
# p4 从 child 管道读取
p4 = Process(target=read_info, args=(child_conn,))
p4.start()
p4.join()
if __name__ == "__main__":
test_pipe()
注意 ：如果两个进程（或线程）同时尝试读取或写入管道的 同一 端，则管道中的数据可能会损坏。当然，在不同进程中同时使用管道的不同端的情况下不存在损坏的风险。
4、进程间同步
与多线程一样，多进程也可以使用锁来确保一次只有一个进程来执行一个操作，比如有一个打印到标准输出的操作，我们需要确保其打印的日志不紊乱，就可以使用下面的操作：
from multiprocessing import Process, Lock
def f(l, i):
l.acquire()
try:
print("hello ", i)
finally:
l.release()
if __name__ == "__main__":
lock = Lock()
for num in range(10):
Process(target=f, args=(lock, num)).start()
而如果不使用锁，我们重写 f 函数如下：
def f(l, i):
print("hello ", i)
多执行几次，我们可以看到控制台的输出会出现错乱的情况，这样就可能对输出信息不能直观查看，比如：
hello 2
hello 0
hello 4
hello hello 3
1
hello 5
hello 6
hello 8
hello 9
hello 7
5、进程间共享状态
在并发编程的时候，应当尽量避免使用共享状态，尤其是多进程操作时，但如果真的有这个需求，需要共享一些数据，multiprocessing 提供了两种方法，一种是共享内存，一种是服务进程。
1. 共享内存
我们可以使用 Value 或者 Array 将数据存储在共享内存映射中。
Value 是存储的单个变量，Array 存储的是数组，注意下，这里的 Value 和 Array 在定义的时候都需要指定元素类型。
其引入及代码示例如下：
from multiprocessing import Process, Value, Array
def f(n, a):
n.value = 5
a[0] = 100
if __name__ == "__main__":
num = Value('d', 1)
arr = Array('i', range(5))
print(num.value)
print(arr[:])
p = Process(target=f, args=(num, arr))
p.start()
p.join()
print(num.value)
print(arr[:])
其中，引入的方式可以直接从 multiprocessing 中引入，在定义 Value 和 Array 的时候，第一个参数是 'd' 和 'i'，分别表示类型是双精度浮点数和有符号整数。
这些共享对象将是进程和线程安全的。
更多的关于共享内存的信息，可以使用 multiprocessing.sharedctypes 模块。
2. 服务进程
我们可以使用 Manager() 返回的管理对象控制一个服务进程，这个进程还可以保存 Python 对象并允许其他进程使用代理操作它们。
这个操作的意思就是使用 Manager() 会跟多进程的操作方式一样，创建一个子进程，然后将一些需要共享的数据都放到这个子进程里，其他子进程可以操作这个子进程的数据来达到数据共享的目的。
Manager() 支持的数据类型有：list，dict，Namespace，Lock，Value，Array 等，下面介绍一下代码示例：
from multiprocessing import Process, Manager
def f(d, l):
d["a"] = 1
d["b"] = 2
l[0] = 100
if __name__ == "__main__":
with Manager() as manager:
d = manager.dict()
l = manager.list(range(5))
p = Process(target=f, args=(d, l))
p.start()
p.join()
print(d)
print(l)
使用服务进程的管理器比使用共享内存对象更灵活，因为它们可以支持任意对象类型。
此外，单个管理器可以通过网络由不同计算机上的进程共享。但是，它们比使用共享内存慢。
如果想获取更多后端相关文章，可扫码关注阅读：
