多处理。池：何时使用应用、应用异步或映射？

Question

我还没有看到关于Pool.apply、Pool.apply_async和Pool.map的用例的清晰示例。我主要使用Pool.map；其他方法的优点是什么？

Answer 1

关于apply与map：

pool.apply(f, args)：f仅在池的一个工作进程中执行。因此池中的一个进程将运行f(args)。

pool.map(f, iterable)：此方法将iterable分成若干块，并作为单独的任务提交给流程池。所以你可以利用池中的所有过程。

Answer 2

以下是表格格式的概述，以显示Pool.apply、Pool.apply_async、Pool.map和Pool.map_async之间的区别：

            | Multi-args   Concurrence    Blocking     Ordered-results
---------------------------------------------------------------------
map         | no           yes            yes          yes
map_async   | no           yes            no           yes
apply       | yes          no             yes          no
apply_async | yes          yes            no           no

示例：

地图

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

应用

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

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

映射异步

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

应用异步

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

Answer 3

在Python的早期，要调用带有任意参数的函数，可以使用apply：

apply(f,args,kwargs)

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

f(*args,**kwargs)

是首选。multiprocessing.Pool模块试图提供类似的接口。

Pool.apply类似于Pythonapply，只是函数调用是在单独的进程中执行的。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不同的是，返回结果的顺序与参数的顺序相对应。