Ich habe keine klaren Beispiele mit Anwendungsfällen für gesehen Pool.apply, Pool.apply_async und Pool.map. Ich benutze hauptsächlich Pool.map; Was sind die Vorteile anderer?

In den alten Tagen von Python würden Sie verwenden, um eine Funktion mit beliebigen Argumenten aufzurufen apply:

apply(f,args,kwargs)

apply existiert immer noch in Python2.7, jedoch nicht in Python3, und wird im Allgemeinen nicht mehr verwendet. Heutzutage,

f(*args,**kwargs)

Ist bevorzugt. Das multiprocessing.Pool Module versucht, eine ähnliche Schnittstelle bereitzustellen.

Pool.apply ist wie Python applyaußer dass der Funktionsaufruf in einem separaten Prozess durchgeführt wird. Pool.apply blockiert, bis die Funktion abgeschlossen ist.

Pool.apply_async ist auch wie in Python eingebaut apply, außer dass der Aufruf sofort zurückkehrt, anstatt auf das Ergebnis zu warten. Ein AsyncResult Objekt wird zurückgegeben. Du nennst es get() -Methode, um das Ergebnis des Funktionsaufrufs abzurufen. Das get() Methode blockiert, bis die Funktion abgeschlossen ist. Daher, pool.apply(func, args, kwargs) ist äquivalent zu pool.apply_async(func, args, kwargs).get().

Im Kontrast zu Pool.applydas Pool.apply_async -Methode hat auch einen Rückruf, der, falls angegeben, aufgerufen wird, wenn die Funktion abgeschlossen ist. Dies kann anstelle des Anrufs verwendet werden get().

Zum Beispiel:

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()

kann ein Ergebnis wie z

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

Beachten Sie, anders pool.mapentspricht die Reihenfolge der Ergebnisse möglicherweise nicht der Reihenfolge, in der die pool.apply_async Anrufe wurden getätigt.

Also, wenn Sie eine Funktion in einem separaten Prozess ausführen müssen, aber möchten, dass der aktuelle Prozess dies tut Block bis diese Funktion zurückkehrt, verwenden Pool.apply. Wie Pool.apply, Pool.map Blöcke, bis das vollständige Ergebnis zurückgegeben wird.

Wenn Sie möchten, dass der Pool von Arbeitsprozessen viele Funktionsaufrufe asynchron ausführt, verwenden Sie Pool.apply_async. Das bestellen der Ergebnisse stimmt nicht garantiert mit der Reihenfolge der Aufrufe überein Pool.apply_async.

Beachten Sie auch, dass Sie mehrere anrufen können anders funktioniert mit Pool.apply_async (Nicht alle Anrufe müssen dieselbe Funktion verwenden).

Im Gegensatz, Pool.map wendet dieselbe Funktion auf viele Argumente an. Allerdings im Gegensatz Pool.apply_asyncwerden die Ergebnisse in einer Reihenfolge zurückgegeben, die der Reihenfolge der Argumente entspricht.

Hier ist eine Übersicht in Tabellenform, um die Unterschiede aufzuzeigen Pool.apply, Pool.apply_async, Pool.map und Pool.map_async. Bei der Auswahl müssen Sie Multi-Args, Parallelität, Blockierung und Reihenfolge berücksichtigen:

                  | 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

Anmerkungen:

• Pool.imap und Pool.imap_async – faulere Version von map und map_async.

• Pool.starmap Methode, die der Kartenmethode sehr ähnlich ist, abgesehen davon, dass sie mehrere Argumente akzeptiert.

• Async Methoden übermitteln alle Prozesse auf einmal und rufen die Ergebnisse ab, sobald sie abgeschlossen sind. Verwenden Sie die get-Methode, um die Ergebnisse zu erhalten.

• Pool.map(oder Pool.apply)-Methoden sind der in Python integrierten map(or apply) sehr ähnlich. Sie blockieren den Hauptprozess, bis alle Prozesse abgeschlossen sind, und geben das Ergebnis zurück.

Beispiele:

Karte

Wird für eine Liste von Jobs auf einmal aufgerufen

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

anwenden

Kann nur für einen Job angerufen werden

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

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

map_async

Wird für eine Liste von Jobs auf einmal aufgerufen

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

apply_async

Kann nur für einen Job aufgerufen werden und führt parallel einen Job im Hintergrund aus

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

Sternenkarte

Ist eine Variante von pool.map die mehrere Argumente unterstützen

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

starmap_async

Eine Kombination aus starmap() und map_async(), die über Iterable von Iterables iteriert und func mit den entpackten Iterables aufruft. Gibt ein Ergebnisobjekt zurück.

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

Bezug:

Vollständige Dokumentation finden Sie hier: https://docs.python.org/3/library/multiprocessing.html

Bezüglich apply vs map:

pool.apply(f, args): f wird nur in EINEM der Worker des Pools ausgeführt. Einer der Prozesse im Pool wird also ausgeführt f(args).

pool.map(f, iterable)Hinweis: Diese Methode zerlegt das Iterable in eine Reihe von Chunks, die es als separate Tasks an den Prozesspool übermittelt. So nutzen Sie alle Prozesse im Pool.