multiprocessing.Pool：何时使用 apply、apply_async 或 map？

Question

我还没有看到Pool.apply 、 Pool.apply_async和Pool.map用例的清晰示例。 我主要使用Pool.map ； 别人的优势是什么？

Answer 1

回到 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_async 。

---

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

如果您希望工作进程池异步执行许多函数调用，请使用Pool.apply_async 。 结果的顺序不能保证与调用Pool.apply_async的顺序相同。

另请注意，您可以使用Pool.apply_async调用许多不同的函数（并非所有调用都需要使用相同的函数）。

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

Answer 2

这是一个表格格式的概述，以显示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)

地图异步

一次性调用一份工作清单

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)

星图

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

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

星图_异步

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

Answer 3

关于apply vs map ：

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

pool.map(f, iterable) ：此方法将可迭代对象分成许多块，并将其作为单独的任务提交给进程池。 因此，您可以利用池中的所有进程。