多处理。池:什么时候使用apply, apply_async或map?

我还没有看到Pool.apply， Pool.apply_async和Pool.map用例的清晰示例。我主要使用Pool.map;其他人的优势是什么?

359892 次浏览
小开
最佳答案

在以前的Python中，要调用带有任意参数的函数，可以使用apply:

apply(f,args,kwargs)

apply仍然存在于Python2.7中，但不在Python3中，并且通常不再使用。如今,

f(*args,**kwargs)

者优先。multiprocessing.Pool模块试图提供类似的接口。

Pool.apply类似于Python的apply，除了函数调用是在一个单独的进程中执行。Pool.apply阻塞直到函数完成。

Pool.apply_async也类似于Python内置的apply，只是调用会立即返回，而不是等待结果。返回一个AsyncResult对象。调用它的get()方法来检索函数调用的结果。get()方法会阻塞直到函数完成。因此，pool.apply(func, args, kwargs)等价于pool.apply_async(func, args, kwargs).get()。

与Pool.apply相反，Pool.apply_async方法也有一个回调，如果提供，则在函数完成时调用该回调。这可以用来代替调用get()。

例如:

import multiprocessing as mp
import time


def foo_pool(x):
time.sleep(2)
return x*x


result_list = []
def log_result(result):
# This is called whenever foo_pool(i) returns a result.
# result_list is modified only by the main process, not the pool workers.
result_list.append(result)


def apply_async_with_callback():
pool = mp.Pool()
for i in range(10):
pool.apply_async(foo_pool, args = (i, ), callback = log_result)
pool.close()
pool.join()
print(result_list)


if __name__ == '__main__':
apply_async_with_callback()

可能会产生这样的结果

[1, 0, 4, 9, 25, 16, 49, 36, 81, 64]

注意，与pool.map不同，结果的顺序可能与pool.apply_async调用的顺序不一致。

因此，如果你需要在单独的进程中运行一个函数，但希望当前进程在该函数返回之前块，请使用Pool.apply。像Pool.apply一样，Pool.map会阻塞直到返回完整的结果。

如果你想让工作进程池异步执行许多函数调用，使用Pool.apply_async。结果的订单不能保证与调用Pool.apply_async的顺序相同。

还要注意，可以使用Pool.apply_async调用许多不同的函数(并非所有调用都需要使用相同的函数)。

相比之下，Pool.map将相同的函数应用于许多参数。 然而，与Pool.apply_async不同的是，返回结果的顺序与参数的顺序相对应
小开

关于apply vs map:

pool.apply(f, args): f只在池的一个worker中执行。因此，池中的一个进程将运行f(args)。

pool.map(f, iterable):该方法将可迭代对象切成若干块，并将这些块作为单独的任务提交给进程池。因此，您可以利用池中的所有进程。

小开

下面是一个表格格式的概述，以显示Pool.apply， Pool.apply_async， Pool.map和Pool.map_async之间的差异。在选择一个时，你必须考虑多参数、并发性、阻塞和排序:

                  | Multi-args   Concurrence    Blocking     Ordered-results
---------------------------------------------------------------------
Pool.map          | no           yes            yes          yes
Pool.map_async    | no           yes            no           yes
Pool.apply        | yes          no             yes          no
Pool.apply_async  | yes          yes            no           no
Pool.starmap      | yes          yes            yes          yes
Pool.starmap_async| yes          yes            no           no

注:

  • Pool.imap和Pool.imap_async - map和map_async的懒版本。

  • Pool.starmap方法，非常类似于map方法，除了它接受多个参数。

  • Async方法一次性提交所有进程，并在完成后检索结果。使用get方法获取结果。

  • Pool.map(或Pool.apply)方法非常类似于Python内置的map(或apply)。它们阻塞主进程，直到所有进程完成并返回结果。

例子:

地图

在同一时间内调用一个工作列表

results = pool.map(func, [1, 2, 3])

应用

只能申请一份工作

for x, y in [[1, 1], [2, 2]]:
results.append(pool.apply(func, (x, y)))


def collect_result(result):
results.append(result)

map_async

在同一时间内调用一个工作列表

pool.map_async(func, jobs, callback=collect_result)

apply_async

只能调用一个作业，并在后台并行执行一个作业

for x, y in [[1, 1], [2, 2]]:
pool.apply_async(worker, (x, y), callback=collect_result)

starmap

是否是支持多个参数的pool.map的变体

pool.starmap(func, [(1, 1), (2, 1), (3, 1)])

starmap_async

starmap()和map_async()的组合，迭代可迭代对象的可迭代对象，并在解包可迭代对象时调用func。返回一个结果对象。

pool.starmap_async(calculate_worker, [(1, 1), (2, 1), (3, 1)], callback=collect_result)

参考:

在这里找到完整的文档:https://docs.python.org/3/library/multiprocessing.html


提交答案