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

多cpu

它是在单个计算机系统中使用两个或更多cpu单元。通过利用我们计算机系统中可用的全部cpu内核，这是从硬件中充分发挥潜力的最佳方法。

多线程

通过并发执行多个线程，cpu能够管理操作系统的使用。多线程的主要思想是通过将进程划分为多个线程来实现并行性。

下表显示了它们之间的一些重要差异

消除全球翻译锁（gil）的影响

在使用并发应用程序时，python中存在一个名为 gil（全局解释器锁）的限制 。gil从不允许我们使用多个cpu内核，因此我们可以说python中没有真正的线程。gil是互斥锁 - 互斥锁，它使线程安全。换句话说，我们可以说gil阻止多个线程并行执行python代码。锁一次只能由一个线程保存，如果我们想要执行一个线程，那么它必须首先获取锁。

通过使用多处理，我们可以有效地绕过gil引起的限制 -

• 通过使用多处理，我们正在利用多个流程的能力，因此我们正在利用gil的多个实例。

• 因此，在任何时候都没有限制在我们的程序中执行一个线程的字节码。

在python中启动进程

以下三种方法可用于在多处理模块中以python启动进程 -

• fork
• spawn
• forkserver

使用fork创建进程

fork命令是unix中的标准命令。它用于创建称为子进程的新进程。此子进程与称为父进程的进程同时运行。这些子进程也与其父进程相同，并继承了父进程可用的所有资源。使用fork创建进程时使用以下系统调用

• fork（） - 这是一个通常在内核中实现的系统调用。 它用于创建process.p>的副本

• 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管道传递文件描述符的所选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多处理模块 - 池类

如果我们在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，因为input是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]