一文速通 Python 并行计算：08 Python 多进程编程-multiprocessing 模块、进程的创建命名、获取进程 ID、创建守护进程和进程的终止

Python 中的多线程无法利用多核优势，如果想要充分地使用多核 CPU 的资源，在 python 中大部分情况需要使用多进程。Python 提供了 multiprocessing 模块用来开启子进程，并在子进程中执行我们定制的任务（比如函数），该模块与多线程模块 threading 的编程接口类似。multiprocessing 模块的功能众多：支持子进程、通信和共享数据、执行不同形式的同步，提供了 Process、Queue、Pipe、Lock 等组件。

1.进程的创建

首先我们看一下 multiprocessing.Process 对象：

class multiprocessing.Process(group=None, target=None, name=None, args=(), kwargs={}, *, daemon=None)

其中：

group ：应该始终是 None ；它仅用于兼容 threading.Thread 。

target ：是由 run() 方法调用的可调用对象。它默认为 None ，意味着什么都没有被调用。

name ：是进程名称（有关详细信息，请参阅 name ）。

args ：是目标调用的参数元组。 args 参数默认值为 ()，可被用来指定要传递给 target 的参数列表或元组。

Kwargs：是目标调用的关键字参数字典。

daemon：将进程 daemon 标志设置为 True 或 False 。如果是 None （默认值），则该标志将从创建的进程继承。

1.1 调用 Process 类的构造器创建进程

Process 类提供了 __init__() 构造器，可以用来创建进程，其常见启动进程的方法包括：

进程的属性包括：

这里，我们进行进程创建和启动的测试，代码如下：

from multiprocessing import  Process

def fun1(name):

    print('测试%s多进程' %name)

if __name__ == '__main__':

    process_list = []

    for i in range(5):  _#开启5个子进程执行fun1函数_

        p = Process(target=fun1,args=('Python',)) _#实例化进程对象_

        p.start()

        process_list.append(p)

    for i in process_list:

        p.join()

    print('结束测试')

上面的代码开启了 5 个子进程去执行函数，我们可以观察结果，是同时打印的，这里实现了真正的并行操作，就是多个 CPU 同时执行任务。

我们知道进程是 python 中最小的资源分配单元，也就是进程中间的数据，内存是不共享的，每启动一个进程，都要独立分配资源和拷贝访问的数据，所以进程的启动和销毁的代价是比较大了。注意，使用进程对象调用 join() 方法。如果没有 join() ，主进程退出之后子进程会留在idle中，你必须手动杀死它们。

1.2 继承 Process 类创建进程类

如果子类重写构造函数，它必须确保它在对进程执行任何其他操作之前调用基类构造函数 Process.__init__() ，同时，对于 run() 方法，可以查看官方文档：

这里，测试代码如下：

from multiprocessing import  Process

class MyProcess(Process): _#继承Process类_

    def __init__(self,name):

        super(MyProcess,self).__init__()

        self.name = name

    def run(self):

        print('测试%s多进程' % self.name)

if __name__ == '__main__':

    process_list = []

    for i in range(5):  _#开启5个子进程执行fun1函数_

        p = MyProcess('Python') _#实例化进程对象_

        p.start()

        process_list.append(p)

    for i in process_list:

        p.join()

    print('结束测试')

结果如下，效果和第一种方式一样：

注意：在 windows 中Process()必须放到if name == 'main':下

通过在 main 代码块中实例化进程对象，我们可以预防无限递归调用。最佳实践是在不同的脚本文件中定义目标函数，然后导入进来使用。

2.进程的命名

在上一节的例子中，我们创建了一个进程，并为其分配了目标函数和函数变量。然而如果能给进程分配一个名字，那么 debug 的时候就更方便了。

current_process() 可以返回返回与当前进程相对应的 Process 对象。下面的代码在主程序中创建了一个有名字的进程和一个没有名字的进程，目标函数都是 foo() 函数。

import multiprocessing

import time

def foo():

    name = multiprocessing.current_process().name

    print("Starting %s \n" % name)

    time.sleep(3)

    print("Exiting %s \n" % name)

if __name__ == '__main__':

    process_with_name = multiprocessing.Process(name='foo_process', target=foo)

    process_with_default_name = multiprocessing.Process(target=foo)

    process_with_name.start()

    process_with_default_name.start()

如下为运行结果：

3.获取进程的 PID

进程控制符（PID），英文全称为 Process Identifier。也常被称为进程标识符。顾名思义，它是各进程的身份标识,程序一运行系统就会自动分配给进程一个独一无二的 PID。进程中止后 PID 被系统回收，可能会被继续分配给新运行的程序。

这里可以使用 current_process().pid 获取当前进程的 PID。将如上代码中 current_process().name 改为 current_process().pid，可得：

4.守护进程

守护进程是一种进程驻留内存的后台进程，它脱离终端控制，不受终端信号影响，即 Ctrl+C，通常守护进程用于周期性的执行某种任务或持续等待处理某些发生的事件。当主进程终止时，守护进程随机终止（本质上是在主进程结束之前结束的,主进程需要负责回收资源）。

如果需要处理比较巨大的任务，又不需要人为干预，将其作为后台进程执行是个非常常用的编程模型。此进程又可以和其他进程并发执行。通过 Python 的 multiprocessing 模块的后台进程选项，我们可以让进程在后台运行。

为了在后台运行进程，我们设置 daemon 参数为 True：

代码如下：

import multiprocessing

import time

def foo():

    name = multiprocessing.current_process().name

    print("Starting %s " % name)

    time.sleep(3)

    print("Exiting %s " % name)

if __name__ == '__main__':

    background_process = multiprocessing.Process(name='background_process', target=foo)

    background_process.daemon = True

    NO_background_process = multiprocessing.Process(name='NO_background_process', target=foo)

    NO_background_process.daemon = False

    background_process.start()

    NO_background_process.start()

运行结果如下：

在非后台运行的进程会看到一个输出，后台运行的没有输出，后台运行进程在主进程结束之后会自动结束。

5.进程的终止

我们可以使用 terminate() 方法立即杀死一个进程。另外，我们可以使用 is_alive() 方法来判断一个进程是否还存活：

在本例中，创建一个目标函数为 foo() 的进程。启动之后，我们通过 terminate() 方法杀死它。

import multiprocessing

import time

def foo():

        print('Starting function')

        time.sleep(0.1)

        print('Finished function')

if __name__ == '__main__':

        p = multiprocessing.Process(target=foo)

        print('Process before execution:', p, p.is_alive())

        p.start()

        print('Process running:', p, p.is_alive())

        p.terminate()

        print('Process terminated:', p, p.is_alive())

        p.join()

        print('Process joined:', p, p.is_alive())

        print('Process exit code:', p.exitcode)

运行结果如下：

我们创建了一个线程，然后用 is_alive() 方法监控它的生命周期。然后通过调用 terminate() 方法结束进程。最后，我们通过读进程的 ExitCode 状态码（status code）验证进程已经结束。