python的进程池map函数_进程池 - Python并发编程教程™-CSDN博客

本文链接：https://blog.csdn.net/weixin_30737027/article/details/113985717

本文介绍了Python的进程池ProcessPoolExecutor，它是concurrent.futures模块的一部分，用于多进程编程。通过示例展示了如何创建和使用ProcessPoolExecutor，以及与ThreadPoolExecutor的区别。ProcessPoolExecutor适用于CPU密集型任务，而ThreadPoolExecutor适合I/O密集型任务。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

进程池可以像创建和使用线程池一样创建和使用。进程池可以被定义为一组预先实例化和空闲的进程，它们随时可以开始工作。当我们需要执行大量任务时，创建进程池优于为每个任务实例化新进程。

Python模块 - Concurrent.futures

Python标准库有一个叫做concurrent.futures的模块。这个模块是在Python 3.2中添加的，为开发人员提供了启动异步任务的高级接口。它是Python的线程和多处理模块的顶层的一个抽象层，用于提供使用线程或进程池运行任务的接口。

在后面的章节中，我们将要学习concurrent.futures模块的不同子类。

执行者类

Executor是 Python concurrent.futures模块的抽象类。它不能直接使用，我们需要使用以下具体子类之一 -

ThreadPoolExecutor

ProcessPoolExecutor

ProcessPoolExecutor - 一个具体的子类

它是Executor类的具体子类之一。它使用多重处理，并且我们获得提交任务的过程池。此池将任务分配给可用的进程并安排它们运行。

如何创建一个ProcessPoolExecutor？

通过concurrent.futures模块及其具体子类Executor的帮助，可以轻松创建一个过程池。为此，需要构建一个ProcessPoolExecutor，其中包含需要的池中的进程数。默认情况下，数字为5。然后将任务提交到进程池。

示例

现在将考虑创建线程池时使用的相同示例，唯一的区别是现在将使用ProcessPoolExecutor而不是ThreadPoolExecutor。

from concurrent.futures import ProcessPoolExecutor

from time import sleep

def task(message):

sleep(2)

return message

def main():

executor = ProcessPoolExecutor(5)

future = executor.submit(task, ("Completed"))

print(future.done())

sleep(2)

print(future.done())

print(future.result())

if __name__ == '__main__':

main()

执行上面示例代码，得到以下结果 -

False

Completed

在上面的例子中，一个ProcessPoolExecutor已经被构造成5个线程。然后在提交消息之前等待2秒的任务被提交给进程池执行器。从输出中可以看出，任务直到2秒才完成，所以第一次调用done()将返回False。2秒后，任务完成，通过调用result()方法得到未来的结果。

实例化ProcessPoolExecutor - 上下文管理器

实例化ProcessPoolExecutor的另一种方法是借助上下文管理器。它的工作方式与上例中使用的方法类似。使用上下文管理器的主要优点是它在语法上看起来不错。实例化可以在下面的代码的帮助下完成 -

with ProcessPoolExecutor(max_workers = 5) as executor

示例

为了更好地理解，这里演示创建线程池示例。在这个例子中，我们需要从导入concurrent.futures模块开始。然后创建一个名为load_url()的函数，它将加载请求的url。然后使用池中的5个线程创建ProcessPoolExecutor。 ProcessPoolExecutor已被用作上下文管理器。我们可以通过调用result()方法来获得future的结果。

import concurrent.futures

from concurrent.futures import ProcessPoolExecutor

import urllib.request

URLS = ['http://www.foxnews.com/',

'http://www.cnn.com/',

'http://europe.wsj.com/',

'http://www.bbc.co.uk/',

'http://some-made-up-domain.com/']

def load_url(url, timeout):

with urllib.request.urlopen(url, timeout = timeout) as conn:

return conn.read()

def main():

with concurrent.futures.ProcessPoolExecutor(max_workers=5) as executor:

future_to_url = {executor.submit(load_url, url, 60): url for url in URLS}

for future in concurrent.futures.as_completed(future_to_url):

url = future_to_url[future]

try:

data = future.result()

except Exception as exc:

print('%r generated an exception: %s' % (url, exc))

else:

print('%r page is %d bytes' % (url, len(data)))

if __name__ == '__main__':

main()

上面的Python脚本将生成以下输出 -

'http://some-made-up-domain.com/' generated an exception:

'http://www.foxnews.com/' page is 229476 bytes

'http://www.cnn.com/' page is 165323 bytes

'http://www.bbc.co.uk/' page is 284981 bytes

'http://europe.wsj.com/' page is 967575 bytes

使用Executor.map()函数

Python map()函数广泛用于执行许多任务。一个这样的任务是对可迭代内的每个元素应用某个函数。同样，可以将迭代器的所有元素映射到函数，并将这些作为独立作业提交给ProcessPoolExecutor。考虑下面的Python脚本示例来理解这一点。

示例

我们将考虑使用Executor.map()函数创建线程池时使用的相同示例。在下面的示例中，map函数用于将square()函数应用于values数组中的每个值。

from concurrent.futures import ProcessPoolExecutor

from concurrent.futures import as_completed

values = [2,3,4,5]

def square(n):

return n * n

def main():

with ProcessPoolExecutor(max_workers = 3) as executor:

results = executor.map(square, values)

for result in results:

print(result)

if __name__ == '__main__':

main()

上面的Python脚本将生成以下输出 -

何时使用ProcessPoolExecutor和ThreadPoolExecutor？

现在我们已经学习了两个Executor类 - ThreadPoolExecutor和ProcessPoolExecutor，我们需要知道何时使用哪个执行器。需要在受CPU限制的工作负载情况下选择ProcessPoolExecutor，而在受I/O限制的工作负载情况下则需要选择ThreadPoolExecutor。

如果使用ProcessPoolExecutor，那么不需要担心GIL，因为它使用多处理。而且，与ThreadPoolExecution相比，执行时间会更少。考虑下面的Python脚本示例来理解这一点。

示例

import time

import concurrent.futures

value = [8000000, 7000000]

def counting(n):

start = time.time()

while n > 0:

n -= 1

return time.time() - start

def main():

start = time.time()