多进程 - Python并发编程教程

在本章中，我们将更多地关注多处理和多线程之间的比较。

多进程

在一台计算机系统中使用两个或多个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]

消除全局解释器锁定(GIL)的影响

在Python中启动进程

用Spawn创建一个进程

使用Forkserver创建一个进程

守护进程如何在Python中进行处理

在Python中终止进程

在Python中识别当前进程

在子类中使用进程

Python多处理模块 - Pool类

微信关注