在本章中，我们将更多地关注多处理和多线程之间的比较。
多进程
在一台计算机系统中使用两个或多个CPU单元。 通过利用计算机系统中可用的全部CPU核心，这是最好的方法来充分利用我们的硬件。
多线程
这是CPU通过同时执行多个线程来管理操作系统使用的能力。 多线程的主要思想是通过将进程分成多个线程来实现并行性。
下表显示了它们之间的一些重要区别 -
编号
多进程
多程序
1
多处理是指多个CPU同时处理多个进程。
多程序同时在主存储器中保存多个程序，并使用单个CPU同时执行它们。
2
它利用多个CPU。
它利用单个CPU
3
它允许并行处理。
上下文切换。
4
处理工作的时间更少。
处理工作需要花费更多的时间。
5
它有助于计算机系统设备的高效利用。
效率低于多重处理。
6
系统通常更昂贵。
这样的系统更便宜。
消除全局解释器锁定(GIL)的影响
在使用并发应用程序时，Python中存在一个名为GIL(全局解释器锁)的限制。 GIL从来不允许我们利用CPU的多个内核，因此可以说Python中没有真正的线程。 GIL是互斥锁 - 互斥锁，它使线程安全。 换句话说，可以说GIL阻止了多个线程并行执行Python代码。锁一次只能由一个线程保存，如果想执行一个线程，那么它必须先获取锁。
通过使用多处理，可以通过GIL有效地绕过 -
通过使用多处理，利用多个进程的能力，因此使用GIL的多个实例。
由于这个原因，在程序中一次执行一个线程的字节码没有限制。
在Python中启动进程
可以使用以下三种方法在多处理模块内用Python启动进程 -
Fork
Spawn
Forkserver
使用Fork创建一个流程
Fork命令是在UNIX中找到的标准命令。 它用于创建称为子进程的新进程。 此子进程与称为父进程的进程同时运行。 这些子进程也与其父进程相同，并继承父进程可用的所有资源。 使用Fork创建流程时使用以下系统调用 -
fork() - 这是一个通常在内核中实现的系统调用，它用于创建进程的副本。
getpid() - 该系统调用返回调用进程的进程ID(PID)。
示例
以下Python脚本示例将演示如何创建新的子进程并获取子进程和父进程的PID -
import os
def child():
n = os.fork()
if n > 0:
print("PID of Parent process is : ", os.getpid())
else:
print("PID of Child process is : ", os.getpid())
child()
执行上面示例代码，得到以下结果 -
PID of Parent process is : 25989
PID of Child process is : 25990
用Spawn创建一个进程
Spawn意味着开始新的事物。 因此，产生一个过程意味着父过程创建一个新进程。 父进程异步继续执行或等待子进程结束其执行。 按照这些步骤产生一个进程 -
导入多处理模块。
创建对象进程。
通过调用start()方法来启动进程活动。
等待进程完成其工作并通过调用join()方法退出。
示例
以下Python脚本示例产生三个进程 -
import multiprocessing
def spawn_process(i):
print ('This is process: %s' %i)
return
if __name__ == '__main__':
Process_jobs = []
for i in range(3):
p = multiprocessing.Process(target = spawn_process, args = (i,))
Process_jobs.append(p)
p.start()
p.join()
执行上面示例代码，得到以下结果 -
This is process: 0
This is process: 1
This is process: 2
使用Forkserver创建一个进程
Forkserver机制仅适用于那些支持通过Unix Pipes传递文件描述符的所选UNIX平台。 考虑以下几点来理解Forkserver机制的工作 -
服务器通过使用Forkserver机制来启动新进程。
然后服务器接收命令并处理创建新进程的所有请求。
要创建一个新的进程，python程序会向Forkserver发送一个请求，之后它会创建一个进程。
最后，我们可以在程序中使用这个新创建的进程。
守护进程如何在Python中进行处理
Python多处理模块允许通过它的守护进程选项来守护进程。 守护进程或在后台运行的进程遵循与守护进程线程类似的概念。 要在后台执行该进程，需要将守护进程标志设置为true。 只要主进程正在执行，守护进程将继续运行，并在完成执行或主程序被终止后终止进程。
示例
在这里，我们使用与守护进程线程中使用的相同的示例。 唯一的区别是模块从多线程更改为多处理，并将守护标志设置为true。 但是，如下所示，输出结果会发生变化 -
import multiprocessing
import time
def nondaemonProcess():
print("starting my Process")
time.sleep(8)
print("ending my Process")
def daemonProcess():
while True:
print("Hello")
time.sleep(2)
if __name__ == '__main__':
nondaemonProcess = multiprocessing.Process(target = nondaemonProcess)
daemonProcess = multiprocessing.Process(target = daemonProcess)
daemonProcess.daemon = True
nondaemonProcess.daemon = False
daemonProcess.start()
nondaemonProcess.start()
执行上面示例代码，得到以下结果 -
starting my Process
ending my Process
输出与守护进程线程生成的输出相比是不同的，因为没有守护进程模式的进程有输出。 因此，主程序结束后，守护进程会自动结束以避免运行进程的持久性。
在Python中终止进程
可以使用terminate()方法立即终止或终止一个进程。 在完成执行之前，我们将使用此方法来终止在函数的帮助下创建的子进程。
例子
import multiprocessing
import time
def Child_process():
print ('Starting function')
time.sleep(5)
print ('Finished function')
P = multiprocessing.Process(target = Child_process)
P.start()
print("My Process has terminated, terminating main thread")
print("Terminating Child Process")
P.terminate()
print("Child Process successfully terminated")
输出结果 -
My Process has terminated, terminating main thread
Terminating Child Process
Child Process successfully terminated
该输出显示程序在执行使用Child_process()函数创建的子进程之前终止。 这意味着子进程已成功终止。
在Python中识别当前进程
操作系统中的每个进程都具有称为PID的进程标识。 在Python中，可以借助以下命令找出当前进程的PID -
import multiprocessing
print(multiprocessing.current_process().pid)
例子
以下Python脚本示例用于找出主进程的PID以及子进程的PID -
import multiprocessing
import time
def Child_process():
print("PID of Child Process is: {}".format(multiprocessing.current_process().pid))
print("PID of Main process is: {}".format(multiprocessing.current_process().pid))
P = multiprocessing.Process(target=Child_process)
P.start()
P.join()
执行上面示例代码，得到以下结果 -
PID of Main process is: 9401
PID of Child Process is: 9402
在子类中使用进程
可以通过对threading.Thread类进行子分类来创建线程。 另外，还可以通过对multiprocessing.Process类进行子分类来创建流程。 要在子类中使用流程，需要考虑以下几点 -
需要定义一个Process类的新子类。
需要覆盖_init_(self [，args])类。
需要重写run(self [，args])方法来实现Process类
需要通过调用start()方法来启动进程。
参考以下代码 -
import multiprocessing
class MyProcess(multiprocessing.Process):
def run(self):
print ('called run method in process: %s' %self.name)
return
if __name__ == '__main__':
jobs = []
for i in range(5):
P = MyProcess()
jobs.append(P)
P.start()
P.join()
执行上面示例代码，得到以下代码-
called run method in process: MyProcess-1
called run method in process: MyProcess-2
called run method in process: MyProcess-3
called run method in process: MyProcess-4
called run method in process: MyProcess-5
Python多处理模块 - Pool类
如果在Python应用程序中讨论简单的并行处理任务，那么多处理模块提供了Pool类。 下面的Pool类方法可以用来在主程序中创建多个子进程。
apply()方法
该方法与ThreadPoolExecutor的submit()方法类似，直到结果准备就绪。
apply_async()方法
当需要并行执行任务时，需要使用apply_async()方法将任务提交给池。 这是一个异步操作，直到执行完所有的子进程之后才会锁定主线程。
map()方法
就像apply()方法一样，它也会阻塞直到结果准备就绪。 它相当于内置的map()函数，它将多个块中的可迭代数据分开并作为单独的任务提交给进程池。
map_async()方法
它是map()方法的一个变体，apply_async()是apply()方法的变体。 它返回一个结果对象。 当结果准备就绪时，就会应用一个可调用对象。 可调用函数必须立即完成; 否则，处理结果的线程将被阻止。
例子
以下示例实现执行并行执行的进程池。 通过multiprocessing.Pool方法应用square()函数，可以简单计算数字的平方。 然后使用pool.map()提交5，因为输入是从0到4的整数列表。结果将被存储在p_outputs中并被打印输出结果 -
def square(n):
result = n*n
return result
if __name__ == '__main__':
inputs = list(range(5))
p = multiprocessing.Pool(processes = 4)
p_outputs = pool.map(function_square, inputs)
p.close()
p.join()
print ('Pool :', p_outputs)
执行上面示例代码，得到以下结果 -
Pool : [0, 1, 4, 9, 16]
我要打赏
纠错/补充
收藏
上一篇：进程池
加QQ群啦，易百教程官方技术学习群
注意：建议每个人选自己的技术方向加群，同一个QQ最多限加 3 个群。
转播
