Python多处理

2025 年 8 月 28 日 | 阅读 9 分钟

在本文中，我们将学习如何使用 Python 实现多进程。我们还将讨论其高级概念。

什么是多进程？

多进程是指系统并行运行一个或多个进程的能力。简单来说，多进程在单个计算机系统中使用了两个或两个以上的 CPU。此方法还能够将任务分配给多个进程。

处理单元共享主内存和外围设备以同时处理程序。多进程应用程序被分解成更小的部分并独立运行。每个进程由操作系统分配给处理器。

Python 提供了一个名为 multiprocessing 的内置包，支持进程交换。在处理多进程之前，我们必须了解进程对象。

为什么需要多进程？

多进程对于在计算机系统中执行多个任务至关重要。假设一台计算机没有多进程或只有一个处理器。我们同时将各种进程分配给该系统。

它将不得不中断之前的任务并切换到另一个任务，以使所有进程都能继续进行。这就像一个厨师独自在厨房工作。他必须做很多事情来做饭，例如切、洗、煮、揉面、烘烤等。

因此，多进程对于同时执行多项任务而不中断至关重要。它还使得跟踪所有任务变得容易。这就是多进程概念的由来。

多进程可以表示为具有多个中央处理器的计算机。
多核处理器是指具有两个或多个独立单元的单个计算组件。

在多进程中，CPU 可以一次分配多个任务，每个任务都有自己的处理器。

Python 中的多进程

Python 提供了 multiprocessing 模块来在单个系统中执行多个任务。它提供了一个用户友好且直观的 API 来处理多进程。

让我们来理解一个简单的多进程示例。

示例 -

from multiprocessing import Process
   def disp():
      print ('Hello !! Welcome to Python Tutorial')
      if __name__ == '__main__':
      p = Process(target=disp)
      p.start()
      p.join()

输出

'Hello !! Welcome to Python Tutorial'

说明

在上面的代码中，我们导入了 Process 类，然后在 disp() 函数中创建了 Process 对象。然后我们使用 start() 方法启动进程，并使用 join() 方法完成进程。我们还可以使用 args 关键字向声明的函数传递参数。

让我们来理解以下带有参数的多进程示例。

示例 - 2

# Python multiprocessing example
# importing the multiprocessing module

import multiprocessing
def cube(n):
   # This function will print the cube of the given number
   print("The Cube is: {}".format(n * n * n))

def square(n):
    # This function will print the square of the given number
   print("The Square is: {}".format(n * n))

if __name__ == "__main__":
   # creating two processes
   process1 = multiprocessing.Process(target= square, args=(5, ))
   process2 = multiprocessing.Process(target= cube, args=(5, ))

   # Here we start the process 1
   process1.start()
   # Here we start process 2
   process2.start()

   # The join() method is used to wait for process 1 to complete
   process1.join()
   # It is used to wait for process 1 to complete
   process2.join()

   # Print if both processes are completed
   print("Both processes are finished")

输出

The Cube is: 125
The Square is: 25
Both processes are finished

解释 -

在上面的示例中，我们创建了两个函数 - cube() 函数计算给定数字的立方，square() 函数计算给定数字的平方。

接下来，我们定义了 Process 类的进程对象，它有两个参数。第一个参数是 target，表示要执行的函数；第二个参数是 args，表示要传递给函数的参数。

process1 = multiprocessing.Process(target= square, args=(5, ))
process2 = multiprocessing.Process(target= cube, args=(5, ))

我们使用 start() 方法启动进程。

process1.start()
process2.start()

正如我们在输出中看到的，它会等待 process one 完成，然后是 process 2。最后一条语句在两个进程都完成后执行。

Python 多进程类

Python multiprocessing 模块提供了许多类，这些类通常用于构建并行程序。我们将讨论其主要类 - Process、Queue 和 Lock。我们已经在前面的示例中讨论了 Process 类。现在我们将讨论 Queue 和 Lock 类。

让我们看一个获取系统中当前 CPU 数量的简单示例。

示例 -

import multiprocessing
print("The number of CPU currently working in system : ", multiprocessing.cpu_count())

输出

('The number of CPU currently woking in system : ', 32)

您 PC 上的 CPU 数量可能有所不同。对我们来说，核心数是 32。

使用 Queue 类的 Python 多进程

我们知道 Queue 是数据结构的重要组成部分。Python 多进程与基于“先进先出”概念的数据结构队列完全相同。Queue 通常存储 Python 对象，并在进程之间共享数据方面发挥着至关重要的作用。

Queue 通常作为参数传递给 Process 的 target 函数，以允许进程消费数据。Queue 提供 put() 函数用于插入数据，get() 函数用于从队列中获取数据。让我们来理解以下示例。

示例 -

# Importing Queue Class

from multiprocessing import Queue

fruits = ['Apple', 'Orange', 'Guava', 'Papaya', 'Banana']
count = 1
# creating a queue object
queue = Queue()
print('pushing items to the queue:')
for fr in fruits:
    print('item no: ', count, ' ', fr)
    queue.put(fr)
    count += 1

print('\npopping items from the queue:')
count = 0
while not queue.empty():
    print('item no: ', count, ' ', queue.get())
    count += 1

输出

pushing items to the queue:
('item no: ', 1, ' ', 'Apple')
('item no: ', 2, ' ', 'Orange')
('item no: ', 3, ' ', 'Guava')
('item no: ', 4, ' ', 'Papaya')
('item no: ', 5, ' ', 'Banana')

popping items from the queue:
('item no: ', 0, ' ', 'Apple')
('item no: ', 1, ' ', 'Orange')
('item no: ', 2, ' ', 'Guava')
('item no: ', 3, ' ', 'Papaya')
('item no: ', 4, ' ', 'Banana')

解释 -

在上面的代码中，我们导入了 Queue 类并初始化了一个名为 fruits 的列表。接下来，我们将 count 设置为 1。count 变量将计算元素的总数。然后，我们通过调用 Queue() 方法创建了队列对象。该对象将用于在 Queue 中执行操作。在 for 循环中，我们使用 put() 函数逐个插入元素到队列中，并在每次循环迭代时将 count 加 1。

Python 多进程 Lock 类

multiprocessing Lock 类用于获取进程的锁，以便我们可以阻止其他进程执行相似的代码，直到锁被释放。Lock 类主要执行两项任务。第一项是使用 acquire() 函数获取锁，第二项是使用 release() 函数释放锁。

Python 多进程示例

假设我们有多个任务。因此，我们创建了两个队列：第一个队列将维护任务，另一个队列将存储完成的任务日志。下一步是实例化进程来完成任务。如前所述，Queue 类已经是同步的，所以我们不需要使用 Lock 类来获取锁。

在下面的示例中，我们将合并所有多进程类。让我们看下面的示例。

示例 -

from multiprocessing import Lock, Process, Queue, current_process
import time
import queue 


def jobTodo(tasks_to_perform, complete_tasks):
    while True:
        try:

            # The try block to catch task from the queue.
            # The get_nowait() function is used to
            # raise queue.Empty exception if the queue is empty.

            task = tasks_to_perform.get_nowait()

        except queue.Empty:

            break
        else:

                # if no exception has been raised, the else block will execute
                # add the task completion
                

            print(task)
            complete_tasks.put(task + ' is done by ' + current_process().name)
            time.sleep(.5)
    return True


def main():
    total_task = 8
    total_number_of_processes = 3
    tasks_to_perform = Queue()
    complete_tasks = Queue()
    number_of_processes = []

    for i in range(total_task):
        tasks_to_perform.put("Task no " + str(i))

    # defining number of processes
    for w in range(total_number_of_processes):
        p = Process(target=jobTodo, args=(tasks_to_perform, complete_tasks))
        number_of_processes.append(p)
        p.start()

    # completing process
    for p in number_of_processes:
        p.join()

    # print the output
    while not complete_tasks.empty():
        print(complete_tasks.get())

    return True


if __name__ == '__main__':
    main()

输出

Task no 2
Task no 5
Task no 0
Task no 3
Task no 6
Task no 1
Task no 4
Task no 7
Task no 0 is done by Process-1
Task no 1 is done by Process-3
Task no 2 is done by Process-2
Task no 3 is done by Process-1
Task no 4 is done by Process-3
Task no 5 is done by Process-2
Task no 6 is done by Process-1
Task no 7 is done by Process-3

Python 多进程 Pool

Python multiprocessing pool 对于在多个输入值上并行执行函数至关重要。它还用于将输入数据分发到进程 (数据并行)。考虑以下多进程 Pool 示例。

示例 -

from multiprocessing import Pool
import time

w = (["V", 5], ["X", 2], ["Y", 1], ["Z", 3])


def work_log(data_for_work):
    print(" Process name is %s waiting time is %s seconds" % (data_for_work[0], data_for_work[1]))
    time.sleep(int(data_for_work[1]))
    print(" Process %s Executed." % data_for_work[0])


def handler():
    p = Pool(2)
    p.map(work_log, w)

if __name__ == '__main__':
    handler()

输出

Process name is V waiting time is 5 seconds
Process V Executed.
Process name is X waiting time is 2 seconds
Process X Executed.
Process name is Y waiting time is 1 seconds
Process Y Executed.
Process name is Z waiting time is 3 seconds
Process Z Executed.

让我们来理解另一个多进程 Pool 示例。

示例 - 2

from multiprocessing import Pool
def fun(x):
    return x*x

if __name__ == '__main__':
    with Pool(5) as p:
        print(p.map(fun, [1, 2, 3]))

输出

[1, 8, 27]

代理对象

代理对象被称为驻留在不同进程中的共享对象。此对象也称为代理。多个代理对象可能具有相似的指代物。代理对象包含各种方法，用于调用其指代物的相应方法。下面是代理对象的示例。

示例 -

from multiprocessing import Manager
manager = Manager()
l = manager.list([i*i for i in range(10)])
print(l)
print(repr(l))
print(l[4])
print(l[2:5])

输出

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
<ListProxy object, typeid 'list' at 0x7f063621ea10>
16
[4, 9, 16]

代理对象是可腌制的，因此我们可以将它们在进程之间传递。这些对象还用于对同步进行控制。

多进程常用函数

到目前为止，我们已经讨论了使用 Python 进行多进程的基本概念。多进程本身是一个广泛的主题，对于在单个系统中执行各种任务至关重要。我们定义了一些常用的、用于实现多进程的必要函数。

方法	描述
pipe()	pipe() 函数返回一对连接对象。
run()	run() 方法用于表示进程活动。
start()	start() 方法用于启动进程。
join([timeout])	join() 方法用于阻塞进程，直到调用 join() 方法的进程终止。timeout 是可选参数。
is_alive()	如果进程正在运行，则返回 True。
terminate()	顾名思义，它用于终止进程。请始终记住 - terminate() 方法在 Linux 中使用，在 Windows 中，我们使用 TerminateProcess() 方法。
kill()	此方法类似于 terminate()，但在 Unix 上使用 SIGKILL 信号。
close()	此方法用于关闭 Process 对象并释放与之关联的所有资源。
qsize()	它返回队列的近似大小。
empty()	如果队列为空，则返回 True。
full()	如果队列已满，则返回 True。
get_await()	此方法等同于 get(False)。
get()	此方法用于从队列中获取元素。它会移除并返回队列中的一个元素。
put()	此方法用于将元素插入队列。
cpu_count()	它返回系统中正在工作的 CPU 数量。
current_process()	它返回与当前进程对应的 Process 对象。
parent_process()	它返回与当前进程对应的父 Process 对象。
task_done()	此函数用于指示已完成一个入队任务。
join_thread()	此方法用于连接后台线程

下一主题Python 正则表达式

Python多处理

什么是多进程？

为什么需要多进程？

Python 中的多进程

Python 多进程类

使用 Queue 类的 Python 多进程

Python 多进程 Lock 类

Python 多进程示例

Python 多进程 Pool

代理对象

多进程常用函数

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Python教程

Python变量和数据类型

Python控制语句

Python数据结构

Python函数

Python模块

Python OOP

Python异常处理

Python文件处理

Python搜索和排序

Python高级主题

Python MySQL

Python MongoDB

Python SQLite

Python MCQ

Python Tkinter (GUI)

Python Web Blocker

Python内置函数

Python字符串函数

Python列表

Python字典

Plotly

相关教程

Python多处理

什么是多进程？

为什么需要多进程？

Python 中的多进程

Python 多进程类

使用 Queue 类的 Python 多进程

Python 多进程 Lock 类

Python 多进程示例

Python 多进程 Pool

代理对象

多进程常用函数

相关帖子

Python魔术方法

Python高阶函数

Python IDE

Python发送电子邮件

Python程序查找第n个斐波那契数

Python生成器

Python中的网格搜索

如何使用Python中的folium包绘制Google地图

Python断言

Python SimpleImputer模块

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器