Python多进程中并行编程与进程池

逸龙天下

Python的并行编程可以采用multiprocessing或mpi4py模块来完成。
multiprocessing是Python标准库中的模块，实现了共享内存机制，也就是说，可以让运行在不同处理器核心的进程能读取共享内存。在基于共享内存通信的多进程编程中，常常通过加锁或类似机制来实现互斥。
mpi4py库实现了消息传递的编程范式（设计模式）。简单来说，就是进程之间不靠任何共享信息来进行通信（也叫做shared nothing），所有的交流都通过传递信息代替。在信息传递的代码中，进程通过send() 和receive()进行交流（与共享内存通信形成对比）。
1.Unix进程模型回顾

Python的multiprocessing进程模块在Unix上是基于fork()编程接口的(MacOS上默认是spawn())，故在介绍Python的并行编程模块之前，首先让我们回顾一下Unix的进程模型。
进程的经典定义就是一个执行中程序的实例。系统中的每个程序都运行在某个进程的上下文（context)中。上下文是由程序正确运行所需的状态组成的。这个状态包括存放在内存中的程序的代码和数据，它的栈、通用目的寄存器的内容、程序计数器、环境变量以及打开文件描述符的集合。进程提供给应用程序以下的抽象：

• 一个独立的逻辑控制流，它提供一个假象，好像我们的程序独占地使用处理器。
  
• 一个私有的地址空间，它提供一个假象，好像我们的程序独占地使用内存系统。
  

进程间进行通信需要一些诸如共享内存的特殊手段，我们后文第3节部分会提到。
Unix系统上常通过以下方式创建子进程：

1. # include <stdlib.h>
2. # include <unistd.h>
3. # include <stdio.h>
5. int main(){
6.     pid_t pid;
7.     int x = 1;
8.     pid = fork();
9.     if (pid == 0){ //Child
10.         printf("child: x=%d\n", ++x);
11.         exit(0);
12.     }
13.     //Parent
14.     printf("parent: x=%d\n", --x);
15.     exit(0);
16. }

复制代码

在Unix系统上运行这个程序时，我们得到下面的结果：

1. parent: x=0
2. child: x=2

复制代码

fork()函数是一点需要注意的事它只被调用一次，却会返回两次：一次是在调用进程（父进程）中，一次是在新创建的子进程中。在父进程中，fork()返回子进程的PID；在子进程中，fork() 返回0。因为子进程的PID总是为非零，返回值就提供一个明确的方法来分辨程序是在父进程还是在子进程中执行。
2.用multiprocessing模块创建进程

前面我们说过，在Unix下Python的multiprocessing模块实际上是调用fork()系统调用来创建进程的，这么坐会克隆出一个Python解释器，在fork()时会包含所有的状态，也即父进程的所有资源都由子进程继承。此外，父进程既可以在产生子进程之后继续异步执行，也可以暂停等待子进程创建完成之后再继续执行。Python的multiprocessing库通过以下几步创建进程：

• 创建进程对象
  
• 调用start()方法，开启进程的活动
  
• 调用join()方法，在进程结束之前一直等待。
  

如下所示我们创建了3个进程：

1. import multiprocessing
2. from multiprocessing import shared_memory
3. import os
4. import time
6. def foo(i, data):
7.     data[i] = i
8.     print ('called function in process: %d, data[%d] = %d' % (os.getpid(), i, data[i]))
9.     time.sleep(10)
10.     return
12. if __name__ == '__main__':
14.     n_processes = 8
15.     data = [None for i in range(n_processes)]
16.    
17.     begin = time.time()
18.     Process_jobs = []
19.     for i in range(n_processes):
20.         # 每个子进程都拿了一个data副本
21.         p = multiprocessing.Process(target=foo, args=(i, data))
22.         Process_jobs.append(p)
23.         p.start()
25.     for i in range(n_processes):
26.         Process_jobs[i].join()
27.     end = time.time()
28.    
29.     print(data)
30.     print("time: %d" % (end - begin))

复制代码

代码打印输出：

1. called function in process: 39195, data[1] = 1
2. called function in process: 39198, data[4] = 4
3. called function in process: 39200, data[6] = 6
4. called function in process: 39197, data[3] = 3
5. called function in process: 39201, data[7] = 7
6. called function in process: 39196, data[2] = 2called function in process: 39194, data[0] = 0
8. called function in process: 39199, data[5] = 5
9. [None, None, None, None, None, None, None, None]
10. time: 11

复制代码

可以看到子进程的打印是乱序的，说明我们不能对子进程的执行顺序做出任何假设。此外，可以看到每个子进程都拥有主进程中data的副本（也即地址空间独立），在子进程中对data进行修改并没有影响到我们主进程data中的值。最后，我们可以看到虽然我们每个子进程都会睡眠10s，但是整个程序的执行时间是11s，说明我们子进程的执行是并行的（本机为8核CPU）。
这里我们使用VSCode的调试插件，可以直观地看到子进程的创建情况：

诶，我们不是一共生成了8个子进程吗，为什么显示有9个子进程吗？这是因为我是在MacOS上测试的，而在Python3.8版本之后: 对于 MacOS，spawn()启动方式是默认方式。
因为 fork()可能导致subprocess崩溃。若以spawn()方式启动多进程会同时启动一个资源追踪进程，负责追踪当前程序的进程产生的、并且不再被使用的命名系统资源(如命名信号量以及SharedMemory对象)。当所有进程退出后，资源追踪会负责释放这些仍被追踪的的对象。
通常情况下是不会有这种对象的，但是假如一个子进程被某个信号杀死，就可能存在这一类资源的“泄露”情况。
3.共享内存

进程有独立的地址空间既是优点也是缺点。这样一来，一个进程不可能不小心覆盖另一个进程的虚拟内存，这就消除了许多令人迷惑的错误——这是一个明显的优点。另一方面，独立的地址空间使得进程共享状态信息变得更加困难。为了共享信息，它们必须使用显式的IPC(进程间通信）机制。基于进程的设计的另一个缺点是，它们往往比较慢，因为进程控制和IPC的开销很高。
进程间通信的手段有许多，包括管道、消息队列，系统V共享内存，系统V信号量(semaphore)、socket（不同主机上）等。Python的multiprocessing采用共享内存进行进程进程间通信，如下所示：

1. import multiprocessing
2. from multiprocessing import shared_memory
3. import os
4. import time
6. def foo(i, data):
7.     data[i] = i
8.     print ('called function in process: %d, data[%d] = %d' % (os.getpid(), i, data[i]))
9.     time.sleep(10)
10.     return
12. if __name__ == '__main__':
14.     n_processes = 8
15.     data = [None for i in range(n_processes)]
16.     # 需要置为共享内存
17.     data = shared_memory.ShareableList([999 for i in range(n_processes)])
18.    
19.     begin = time.time()
20.     Process_jobs = []
21.     for i in range(n_processes):
22.         # 每个子进程都拿了一个data副本
23.         p = multiprocessing.Process(target=foo, args=(i, data))
24.         Process_jobs.append(p)
25.         p.start()
27.     for i in range(n_processes):
28.         Process_jobs[i].join()
29.     end = time.time()
31.     print(data)
32.     print("time: %d" % (end - begin))
33.   
34.     data.shm.close()
35.     data.shm.unlink()

复制代码

该代码运行结果如下：

1. called function in process: 43848, data[6] = 6
2. called function in process: 43842, data[0] = 0
3. called function in process: 43849, data[7] = 7
4. called function in process: 43843, data[1] = 1
5. called function in process: 43846, data[4] = 4
6. called function in process: 43844, data[2] = 2
7. called function in process: 43847, data[5] = 5
8. called function in process: 43845, data[3] = 3
9. ShareableList([0, 1, 2, 3, 4, 5, 6, 7], name='psm_c252aac3')
10. time: 11

复制代码

可以看到8个子进程成功修改了共享内存中的内容。
4.终止/杀掉进程

我们可以使用terminate() 方法终止一个进程，这在Unix系统上是使用SIGTERM信号完成的。另外，我们可以使用 is_alive()方法来判断一个进程是否还存活。

1. # 杀死一个进程
2. import multiprocessing
3. import time
5. def foo():
6.     print('Starting function')
7.     time.sleep(0.1)
8.     print('Finished function')
10. if __name__ == '__main__':
11.     p = multiprocessing.Process(target=foo)
12.     print('Process before execution:', p, p.is_alive())
13.     p.start()
14.     print('Process running:', p, p.is_alive())
15.     p.terminate()
16.     time.sleep(0.1) # 注意，传信号需要时间，故sleep一下
17.     print('Process terminated:', p, p.is_alive())
18.     p.join()
19.     print('Process joined:', p, p.is_alive())
20.     print('Process exit code:', p.exitcode)

复制代码

该代码打印：

1. Process before execution: <Process name='Process-1' parent=50932 initial> False
2. Process running: <Process name='Process-1' pid=50944 parent=50932 started> True
3. Process terminated: <Process name='Process-1' pid=50944 parent=50932 stopped exitcode=-SIGTERM> False
4. Process joined: <Process name='Process-1' pid=50944 parent=50932 stopped exitcode=-SIGTERM> False
5. Process exit code: -15

复制代码

最后，我们通过读进程的ExitCode状态码（status code）验证进程已经结束， ExitCode可能的值如下：

• == 0: 没有错误正常退出
  
• > 0: 进程有错误，并以此状态码退出
  
• < 0: 进程被-1 *信号杀死并以此作为 ExitCode 退出
  
• 在我们的例子中，输出的ExitCode 是 -15 。负数表示子进程被数字为15的信号杀死。
  

如果我们修改为p.kill()则为立即杀掉一个进程。则上述程序会打印输出：

1. Process before execution: <Process name='Process-1' parent=52481 initial> False
2. Process running: <Process name='Process-1' pid=52492 parent=52481 started> True
3. Process terminated: <Process name='Process-1' pid=52492 parent=52481 stopped exitcode=-SIGKILL> False
4. Process joined: <Process name='Process-1' pid=52492 parent=52481 stopped exitcode=-SIGKILL> False
5. Process exit code: -9

复制代码

也即子进程接收到数字为9的信号，即被杀死。终止进程和杀死进程的区别在于终止进程会先将数据由内存写入磁盘（类似于关机），但杀掉进程则不会保存数据（类似于直接给计算机断掉电源）。
Unix系统上常见信号查询手册如下：

最后，还需要强调一点，Python虽然提供了用信号杀掉进程的函数，但是并不提供用信号直接杀掉线程的函数，这是因为杀掉进程远比杀掉线程安全
5.进程间同步

多个进程可以协同工作来完成一项任务，而这通常需要共享数据。所以在多进程之间保持数据的一致性就很重要了。需要共享数据协同的进程必须以适当的策略来读写数据。相关的同步原语和线程的库很类似。
进程的同步原语如下：

• Lock: 这个对象可以有两种状态：锁住的（locked）和没锁住的（unlocked）。一个Lock对象有两个方法， acquire()和release() ，来控制共享数据的读写权限（如果使用with Lock():这样的语法，那么程序的控制流程在进入和离开with语句块时会自动调用acquire()和release()方法，我们将称with语句为创建了一个上下文环境（context）[8]）。
  
• Event: 实现了进程间的简单通信，一个进程发事件的信号，另一个进程等待事件的信号。 Event对象有两个方法， set()和clear()，来管理自己内部的变量。
  
• Condition: 此对象用来同步部分工作流程，在并行的进程中，有两个基本的方法： wait()用来等待进程， notify_all()用来通知所有等待此条件的进程。
  
• Semaphore: 用来共享资源，例如，支持固定数量的共享连接。
  
• Rlock: 递归锁对象。其用途和方法同Threading模块一样。
  
• Barrier: 将程序分成几个阶段，适用于有些进程必须在某些特定进程之后执行。处于障碍（Barrier）之后的代码不能同处于障碍之前的代码并行。
  

下列代码展示了如何使用Barrier来同步两个进程。我们有4个进程，进程1和2由Barrier管理，而进程3和4则没有同步策略。

1. import multiprocessing
2. from multiprocessing import Barrier, Lock, Process
3. from time import time
4. from datetime import datetime
6. def test_with_barrier(synchronizer, serializer):
7.     name = multiprocessing.current_process().name
8.     synchronizer.wait()
9.     now = time()
10.     with serializer:
11.         print("process %s ----> %s" % (name, datetime.fromtimestamp(now)))
13. def test_without_barrier():
14.     name = multiprocessing.current_process().name
15.     now = time()
16.     print("process %s ----> %s" % (name, datetime.fromtimestamp(now)))
18. if __name__ == '__main__':
19.     synchronizer = Barrier(2) # Barrier声明的参数代表要管理的进程总数：
20.     serializer = Lock()
21.     Process(name='p1 - test_with_barrier', target=test_with_barrier, args=(synchronizer,serializer)).start()
22.     Process(name='p2 - test_with_barrier', target=test_with_barrier, args=(synchronizer,serializer)).start()
23.     Process(name='p3 - test_without_barrier', target=test_without_barrier).start()
24.     Process(name='p4 - test_without_barrier', target=test_without_barrier

复制代码

以上代码运行结果如下：

1. process p3 - test_without_barrier ----> 2022-12-09 20:09:18.382580
2. process p1 - test_with_barrier ----> 2022-12-09 20:09:18.432348
3. process p2 - test_with_barrier ----> 2022-12-09 20:09:18.432586
4. process p4 - test_without_barrier ----> 2022-12-09 20:09:18.464562

复制代码

可以看到with_barrier的进程1和进程2比without_barrier的进程3和4时间差的小很多。
关于用Barrier同步两个进程的过程，可描述如下图：

6.使用进程池

下面的例子展示了如果通过进程池来执行一个并行应用。我们创建了有8个进程的进程池，然后使用pool.map()方法来进行一个简单的并行计算(这里采样了函数式编程中的map-reduce思想)，并与串行的map（）方法进行对比。

1. import time
2. import multiprocessing
4. def function_square(x):
5.     return x * x
7. if __name__ ==  '__main__':
8.     data = [i for i in range(1000000)]
10.     # Parallel implementation
11.     begin = time.time()
12.     pool = multiprocessing.Pool(processes=8)
13.     results1 = pool.map(function_square, data)
14.     pool.close()
15.     pool.join()
16.     end = time.time()
17.     print("Parallel time: %f" % (end - begin))
18.    
19.    
20.     # Nonparallel code
21.     begin = time.time()
22.     results2 = map(function_square, data)
23.     end = time.time()
24.     print("Nonparallel time: %f" % (end-begin))
26.     if list(results1) == list(results2):
27.         print("Correct!")
28.         print(results1[:10])

复制代码

上述代码运行结果如下：

1. Parallel time: 1.638756
2. Nonparallel time: 0.000003
3. Correct!
4. [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

复制代码

可见串行和并行代码运行结果相同，但是居然并行的时间更慢！这是由于我们计算的主要时间耗费在进程间通信上了（主进程需要将列表的各个部分拷贝到子进程），而每个子进程的计算量又很小，是典型的计算开销小于通信的情况，故不能取得理性的（8倍）的加速比。这告诉我们在使用Python多进程并行编程时要完成的工作规模必须足够大，这样可以弥补额外产生的通信开销。
这里需要说明一下使用Python进程池进行并行化处理时需要考虑的重要因素：

• 这种并行化处理技术只适用于可以将问题分解成各个独立部分的情况。
  
• 任务必须定义成普通的函数来提交。实例方法、闭包或者其他类型的可调用对象都是不支持并行处理的。
  
• 函数的参数和返回值必须课兼容于pickle编码。任务的执行是在单独的解释器中完成的，这中间需要用到进程间通信。因此，在不同的解释器间交换数据必须要进行序列化处理（这一点尤其重要，在实际项目中我发现Pytorch的sparse_coo_tensor(类型就无法进行序列化），在调用p.start()时会报错NotImplementedError: Cannot access storage of SparseTensorImpl。
  

7.用多进程来规避GIL

多进程编程的一个好处就是可以用来规避GIL的限制。比如假设我们有以下线程代码：

1. # Performs a large calculation (CPU bound)
2. def some_work(args):
3.     ...
4.     return result
6. # A thread that calls the above function
7. def some_thread():
8.     while True:
9.         ...
10.         r = some_work(args)
11.         ...

复制代码

我们可以采用如下方法将代码修改为使用进程池的方式：

1. import os
2. #学习中遇到问题没人解答？小编创建了一个Python学习交流群：531509025
3. # Processing pool (see below for initiazation)
4. pool = None
6. #  Performs a large calculation (CPU bound)
7. def some_work(args):
8.     ...
9.     return result
11. # A thread that calls the  above function
12. def some_thread():
13.     while True:
14.         ...
15.         r = pool.apply(some_work, (args))
16.         ...
17.         
18. # Initiaze the pool
19. if __name__ == "__main__":
20.     import multiprocessing
21.     pool = multiprocessing.Pool()

复制代码

在上面这段代码中，每当有线程要执行CPU密集型的任务时，它就把任务提交到池中，然后进程池将任务转交给运行在另一个进程中的Python解释器。当线程等待结果的时候就会释放GIL。
此外，由于计算是在另一个单独的解释器中进行的，这样就不再受到GIL的限制了。在多核系统上，将会发现采用这种技术能轻易地利用到所有的CPU核心

来源:https://www.cnblogs.com/python1111/p/18458818
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！