Python教程中的并发性

Python中的并发 - 多处理

← 上一节 下一节 →

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

多处理

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

多线程

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

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

多处理Multiprogramming
多处理是指多个CPU同时处理多个进程.多重编程同时在主存储器中保存多个程序，并使用单个CPU同时执行它们.
它使用多个CPU.它使用单CPU.
它允许并行处理.进行上下文切换.
处理作业所需的时间减少.更多处理作业所需的时间.
它有助于高效利用计算机系统的设备.比多处理效率低.
通常更贵.此类系统较便宜.

消除全球翻译锁(GIL)的影响

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

使用多处理，我们可以有效地绕过由GIL和负号引起的限制;

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

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

在Python中启动进程

以下三种方法可用于在多处理中启动Python中的进程module :

  • 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 multiprocessing 模块允许我们通过其守护进程选项来获取守护进程.守护程序进程或在后台运行的进程遵循与守护程序线程类似的概念.要在后台执行该过程，我们需要将守护进程标志设置为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")


输出

 
我的进程终止，终止主线程
终止子进程
子进程成功终止


输出显示程序在执行子进程之前终止，该子进程是在Child_proc的帮助下创建的ess()函数.这意味着子进程已成功终止.

在Python中识别当前进程

操作系统中的每个进程都具有已知的进程标识作为PID.在Python中，我们可以借助以下命令找出当前进程的PID :

My Process has terminated, terminating main thread
Terminating Child Process
Child Process successfully terminated


示例

以下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 类进行子类化来创建流程.对于在子类中使用进程，我们需要考虑以下几点 :

  • 我们需要定义一个新的子类流程类.

  • 我们需要覆盖 _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，因为输入是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]
← 上一节 下一节 →

相关菜鸟教程