Python中的多处理 |第 1 套（介绍）

本文简要介绍了Python编程语言中的多处理。

什么是多处理？

多处理是指系统同时支持多个处理器的能力。多处理系统中的应用程序被分解为独立运行的较小例程。操作系统将这些线程分配给提高系统性能的处理器。

为什么要多处理？

考虑具有单个处理器的计算机系统。如果它同时被分配了几个进程，它将不得不中断每个任务并短暂地切换到另一个，以保持所有进程的运行。
这种情况就像厨师独自在厨房工作一样。他必须做一些任务，比如烘烤、搅拌、揉面团等。

所以要点是：你必须一次完成的任务越多，跟踪它们就越困难，而保持正确的时间变得更具挑战性。
这就是多处理的概念出现的地方！
多处理系统可以具有：

多处理器，即具有多个中央处理器的计算机。
多核处理器，即具有两个或多个独立实际处理单元（称为“核”）的单个计算组件。

在这里，CPU 可以轻松地一次执行多个任务，每个任务都使用自己的处理器。

就好像最后的厨师得到助手的协助一样。现在，他们可以在自己之间分配任务，厨师不需要在他的任务之间切换。

Python中的多处理

在Python中，多处理模块包含一个非常简单直观的 API，用于在多个进程之间划分工作。
让我们考虑一个使用多处理模块的简单示例：

# importing the multiprocessing module
import multiprocessing
  
def print_cube(num):
    """
    function to print cube of given num
    """
    print("Cube: {}".format(num * num * num))
  
def print_square(num):
    """
    function to print square of given num
    """
    print("Square: {}".format(num * num))
  
if __name__ == "__main__":
    # creating processes
    p1 = multiprocessing.Process(target=print_square, args=(10, ))
    p2 = multiprocessing.Process(target=print_cube, args=(10, ))
  
    # starting process 1
    p1.start()
    # starting process 2
    p2.start()
  
    # wait until process 1 is finished
    p1.join()
    # wait until process 2 is finished
    p2.join()
  
    # both processes finished
    print("Done!")

Square: 100
Cube: 1000
Done!

让我们试着理解上面的代码：

要导入多处理模块，我们执行以下操作：
```
import multiprocessing
```
为了创建一个进程，我们创建一个Process类的对象。它需要以下参数：
- target : 进程要执行的函数
- args ：要传递给目标函数的参数
注意：流程构造函数还有许多其他参数，稍后将讨论。在上面的示例中，我们创建了 2 个具有不同目标函数的进程：
```
p1 = multiprocessing.Process(target=print_square, args=(10, ))
p2 = multiprocessing.Process(target=print_cube, args=(10, ))
```
要启动一个进程，我们使用Process类的start方法。
```
p1.start()
p2.start()
```
一旦进程开始，当前程序也会继续执行。为了在进程完成之前停止当前程序的执行，我们使用join方法。
```
p1.join()
p2.join()
```
结果，当前程序将首先等待p1的完成，然后是p2 。一旦它们完成，则执行当前程序的下一条语句。

让我们考虑另一个程序来理解在同一个Python脚本上运行的不同进程的概念。在下面的示例中，我们打印运行目标函数的进程的 ID：

# importing the multiprocessing module
import multiprocessing
import os
  
def worker1():
    # printing process id
    print("ID of process running worker1: {}".format(os.getpid()))
  
def worker2():
    # printing process id
    print("ID of process running worker2: {}".format(os.getpid()))
  
if __name__ == "__main__":
    # printing main program process id
    print("ID of main process: {}".format(os.getpid()))
  
    # creating processes
    p1 = multiprocessing.Process(target=worker1)
    p2 = multiprocessing.Process(target=worker2)
  
    # starting processes
    p1.start()
    p2.start()
  
    # process IDs
    print("ID of process p1: {}".format(p1.pid))
    print("ID of process p2: {}".format(p2.pid))
  
    # wait until processes are finished
    p1.join()
    p2.join()
  
    # both processes finished
    print("Both processes finished execution!")
  
    # check if processes are alive
    print("Process p1 is alive: {}".format(p1.is_alive()))
    print("Process p2 is alive: {}".format(p2.is_alive()))

ID of main process: 28628
ID of process running worker1: 29305
ID of process running worker2: 29306
ID of process p1: 29305
ID of process p2: 29306
Both processes finished execution!
Process p1 is alive: False
Process p2 is alive: False

主Python脚本具有不同的进程 ID，当我们创建Process对象p1和p2时，多处理模块会产生具有不同进程 ID 的新进程。在上面的程序中，我们使用os.getpid()函数来获取运行当前目标函数的进程 ID。
请注意，它与我们使用Process类的pid属性获得的p1和p2的进程 ID 匹配。
每个进程独立运行并拥有自己的内存空间。
一旦目标函数的执行完成，进程就会终止。在上面的程序中，我们使用Process类的is_alive方法来检查进程是否仍然处于活动状态。

考虑下图以了解新进程与主要Python脚本的不同之处：

因此，这是对Python中的多处理的简要介绍。接下来的几篇文章将涵盖以下与多处理相关的主题：

使用数组、值和队列在进程之间共享数据。
多处理中的锁和池概念

下一个：

Python中的多处理 |设置 2
Python中进程的同步和池化

参考：

http://learn.parallax.com/tutorials/language/blocklyprop/blocklyprop-functions-and-multicore/bit-about-multicore
https://文档。 Python.org/3/library/multiprocessing.html