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

多进程

在一台计算机系统中使用两个或多个CPU单元。 通过利用计算机系统中可用的全部CPU核心，这是最好的方法来充分利用我们的硬件。

多线程

这是CPU通过同时执行多个线程来管理操作系统使用的能力。 多线程的主要思想是通过将进程分成多个线程来实现并行性。

下表显示了它们之间的一些重要区别 -

消除全局解释器锁定(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]