Python多进程编程实战：Process与Pool详解
本文详解Python中创建多进程的三种常用方法。通过实例解析multiprocessing模块中的Process类，涵盖参数传递、常用方法及属性；介绍通过继承Process类处理复杂任务的技巧；并深入讲解利用Pool进程池管理大量进程的非阻塞与阻塞调用方式，帮助开发者提升程序运行效率。
多进程基础与Process类创建
程序运行时，单线程或单进程的执行效率往往较低。为了提升运行速度，可以采用多进程技术，实现多任务并发执行。例如，对于四核处理器，理论上可以配置四个并行进程来加速计算。
接下来，我们将具体探讨多进程在Python中的实际应用场景。
1、利用multiprocessing模块创建进程
multiprocessing模块提供了Process类，用于表示一个进程对象。其基本语法结构如下：
Process([group[,target[,name[,args[,kwargs]]]]])
参数说明如下：group参数目前未被使用，始终为None。
target指定进程启动时要执行的可调用对象（函数）。
name用于设置当前进程实例的别名。
args表示传递给target函数的参数元组。
kwargs表示传递给target函数的关键字参数字典。
以下是一个使用多进程的基础示例：
from multiprocessing import Process # 导入模块
# 执行子进程代码
def test(interval):
print('我是子进程')
# 执行主程序
def main():
print('主进程开始')
# 实例化Procss进程类
p = Process(target=test,args=(1,))
# 启动子进程
p.start()
print('主进程结束')
if __name__ == '__main__':
main()运行结果如下：
主进程开始 主进程结束 我是子进程
除了start()方法外，Process实例p还包含以下常用方法：
is_alive()：用于判断进程实例是否仍在运行。
join([timeout])：阻塞主进程，直到子进程执行结束，或等待指定的秒数。
start()：启动子进程，即创建并运行子进程。
run()：如果未指定target参数，调用start()时将直接执行对象内部的run()方法。
terminate()：无论任务是否完成，立即终止进程。
Process类还具备以下常用属性：
name：进程实例的别名，默认格式为Process-N，其中N是从1开始递增的整数。
pid：当前进程实例的系统进程ID。
下面通过代码展示Process类方法和属性的具体应用。我们创建两个子进程，分别利用os模块和time模块输出父进程与子进程的ID及执行时间，并调用Process类的name和pid属性：
# -*- coding:utf-8 -*-
from multiprocessing import Process
import time
import os
#两个子进程将会调用的两个方法
def child_1(interval):
print("子进程（%s）开始执行，父进程为（%s）" % (os.getpid(), os.getppid()))
# 计时开始
t_start = time.time()
# 程序将会被挂起interval秒
time.sleep(interval)
# 计时结束
t_end = time.time()
print("子进程（%s）执行时间为'%0.2f'秒"%(os.getpid(),t_end - t_start))
def child_2(interval):
print("子进程（%s）开始执行，父进程为（%s）" % (os.getpid(), os.getppid()))
# 计时开始
t_start = time.time()
# 程序将会被挂起interval秒
time.sleep(interval)
# 计时结束
t_end = time.time()
print("子进程（%s）执行时间为'%0.2f'秒"%(os.getpid(),t_end - t_start))
if __name__ == '__main__':
print("------父进程开始执行-------")
# 输出当前程序的ID
print("父进程PID：%s" % os.getpid())
# 实例化进程p1
p1=Process(target=child_1,args=(1,))
# 实例化进程p2
p2=Process(target=child_2,name="mrsoft",args=(2,))
# 启动进程p1
p1.start()
# 启动进程p2
p2.start()
#同时父进程仍然往下执行，如果p2进程还在执行，将会返回True
print("p1.is_alive=%s"%p1.is_alive())
print("p2.is_alive=%s"%p2.is_alive())
#输出p1和p2进程的别名和PID
print("p1.name=%s"%p1.name)
print("p1.pid=%s"%p1.pid)
print("p2.name=%s"%p2.name)
print("p2.pid=%s"%p2.pid)
print("------等待子进程-------")
# 等待p1进程结束
p1.join()
# 等待p2进程结束
p2.join()
print("------父进程执行结束-------")运行结果如下：
------父进程开始执行-------
父进程PID：13808
p1.is_alive=True
p2.is_alive=True
p1.name=Process-1
p1.pid=13360
p2.name=mrsoft
p2.pid=21500
------等待子进程-------
子进程（13360）开始执行，父进程为（13808）
子进程（21500）开始执行，父进程为（13808）
子进程（13360）执行时间为'1.01'秒
子进程（21500）执行时间为'2.00'秒
------父进程执行结束-------在上述代码中，首次实例化Process类时，name属性默认被赋值为Process-1；第二次实例化时默认为Process-2。然而，由于在实例化进程p2时显式设置了name属性为mrsoft，因此p2.name的值最终为mrsoft。
继承Process类处理复杂任务
2、通过Process子类创建进程
对于简单任务，通常直接使用Process(target=test)即可。但若需处理复杂逻辑，建议定义一个继承自Process类的子类。以下是通过子类创建多个进程的实现方式：
# -*- coding:utf-8 -*-
from multiprocessing import Process
import time
import os
#继承Process类
class SubProcess(Process):
# 由于Process类本身也有__init__初识化方法，这个子类相当于重写了父类的这个方法
def __init__(self,interval,name=''):
# 调用Process父类的初始化方法
Process.__init__(self)
# 接收参数interval
self.interval = interval
# 判断传递的参数name是否存在
if name:
# 如果传递参数name,则为子进程创建name属性，否则使用默认属性
self.name = name
#重写了Process类的run()方法
def run(self):
print("子进程(%s) 开始执行，父进程为（%s）"%(os.getpid(),os.getppid()))
t_start = time.time()
time.sleep(self.interval)
t_stop = time.time()
print("子进程(%s)执行结束，耗时%0.2f秒"%(os.getpid(),t_stop-t_start))
if __name__=="__main__":
print("------父进程开始执行-------")
# 输出当前程序的ID
print("父进程PID：%s" % os.getpid())
p1 = SubProcess(interval=1,name='mrsoft')
p2 = SubProcess(interval=2)
#对一个不包含target属性的Process类执行start()方法，就会运行这个类中的run()方法，
#所以这里会执行p1.run()
# 启动进程p1
p1.start()
# 启动进程p2
p2.start()
# 输出p1和p2进程的执行状态，如果真正进行，返回True,否则返回False
print("p1.is_alive=%s"%p1.is_alive())
print("p2.is_alive=%s"%p2.is_alive())
#输出p1和p2进程的别名和PID
print("p1.name=%s"%p1.name)
print("p1.pid=%s"%p1.pid)
print("p2.name=%s"%p2.name)
print("p2.pid=%s"%p2.pid)
print("------等待子进程-------")
# 等待p1进程结束
p1.join()
# 等待p2进程结束
p2.join()
print("------父进程执行结束-------")运行结果如下：
------父进程开始执行-------
父进程PID：2512
p1.is_alive=True
p2.is_alive=True
p1.name=mrsoft
p1.pid=20328
p2.name=SubProcess-2
p2.pid=13700
------等待子进程-------
子进程(20328) 开始执行，父进程为（2512）
子进程(13700) 开始执行，父进程为（2512）
子进程(20328)执行结束，耗时1.00秒
子进程(13700)执行结束，耗时2.00秒
------父进程执行结束-------代码中定义了一个SubProcess子类，继承自multiprocessing.Process。SubProcess内部包含__init__()初始化方法和run()方法。在__init__()中必须调用父类multiprocessing.Process的__init__()，否则父类初始化逻辑会被覆盖，导致进程无法正确开启。此外，虽然SubProcess未定义start()方法，但在主程序中调用start()时，会自动执行SubProcess重写的run()方法。
使用进程池Pool管理大量进程
3、使用进程池Pool创建进程
前文介绍了使用Process类创建两个进程的方法。如果需要创建数十甚至上百个进程，逐个实例化Process类将变得繁琐。此时，可以使用multiprocessing模块提供的Pool类，即进程池，来高效管理大量进程。
首先了解Pool类的常用方法：
apply_async(func[,args[,kwds]])：以非阻塞方式调用func()函数（即并行执行，无需等待前一个进程结束即可提交下一个任务）。args为传递给func()的位置参数列表，kwds为关键字参数列表。
apply(func[,args[,kwds]])：以阻塞方式调用func()函数（即必须等待当前进程执行完毕后，才能执行下一个任务）。
close()：关闭进程池，禁止提交新任务。
terminate()：无论任务是否完成，立即终止所有进程。
join()：主进程阻塞，等待所有子进程退出。此方法必须在close()或terminate()之后调用。
以下示例演示如何通过进程池创建多进程。设置最大进程数为3，并使用非阻塞方式执行10个任务：
# -*- coding=utf-8 -*-
from multiprocessing import Pool
import os, time
def task(name):
print('子进程（%s）执行task %s ...' % ( os.getpid() ,name))
# 休眠1秒
time.sleep(1)
if __name__=='__main__':
print('父进程（%s）.' % os.getpid())
# 定义一个进程池，最大进程数3
p = Pool(3)
# 从0开始循环10次
for i in range(10):
# 使用非阻塞方式调用task()函数
p.apply_async(task, args=(i,))
print('等待所有子进程结束...')
# 关闭进程池，关闭后p不再接收新的请求
p.close()
# 等待子进程结束
p.join()
print('所有子进程结束.')运行结果如下：
父进程（3856）.
等待所有子进程结束...
子进程（18872）执行task 0 ...
子进程（11220）执行task 1 ...
子进程（10140）执行task 2 ...
子进程（18872）执行task 3 ...
子进程（11220）执行task 4 ...
子进程（10140）执行task 5 ...
子进程（18872）执行task 6 ...
子进程（11220）执行task 7 ...
子进程（10140）执行task 8 ...
子进程（18872）执行task 9 ...
所有子进程结束.以上内容涵盖了Python多进程编程的核心技巧，希望能为您的学习提供有益参考。
免责声明：本文内容仅供参考，不代表本站观点。转载或引用请注明出处。
