[Python] Über Executor und zukünftige Klassen

Über diesen Artikel

Concurrent.futures, das aus Python Version 3.2 hinzugefügt wurde, wird als Memorandum zusammengefasst.

Das Modul "concurrent.futures" bietet abschließend sowohl Multithread- als auch Multiprozess-Schnittstellen.

In welcher Situation wird es verwendet?

F. Was tun, wenn das parallele Problem nicht zur asynchronen Anwendung passt oder Sie nicht wissen, was zu tun ist?

A. Delegieren Sie die Verarbeitung des problematischen Teils an einen Thread oder Prozess. Dadurch wird die delegierte Verarbeitung wie ein Collout angezeigt, die Steuerung für die Ereignisschleife freigegeben und das Endergebnis verarbeitet.

Das Modul "concurrent.future" ist darauf vorbereitet, dieses A zu realisieren.

Was kann ich tun?

Das Modul "concurrent.future" ist ebenfalls in das Modul "asycio" integriert. Durch die Kombination dieser beiden Module können Sie Blockierungsfunktionen verwenden, die in mehreren Threads oder Prozessen ausgeführt werden, z. B. ein asynchrones, nicht blockierendes Collout.

Wie benutzt man es?

Das Modul "concurrent.future" verfügt über ein "Executor" -Objekt und ein "Future" -Objekt.

Über die Executor Klasse

Executor repräsentiert einen ** Pool ** von Ressourcen, die Arbeitselemente parallel verarbeiten können. Es scheint einen ähnlichen Zweck zu haben wie die "Pool" -Klasse des "Multiprocessing" -Moduls, jedoch mit einem anderen Design als die Schnittstelle.

** Die Executor-Klasse ist eine nicht instanziierte Basisklasse **. Die Executor-Klasse hat die folgenden zwei Unterklassen.

• ThreadPoolExecutor: Geben Sie den Thread-Pool an und führen Sie die asynchrone Verarbeitung durch.
• ProcessPollExecutor: Geben Sie den Prozesspool an und führen Sie die asynchrone Verarbeitung durch.

Aufgrund dieser Tatsachen kann gesagt werden, dass die Klasse "Executor" sowohl Multithread- als auch Multiprozessschnittstellen bereitstellt.

Diese Klassen bieten drei Methoden.

• submit (fn, * args, ** kwargs): Planen Sie die Ausführung der fn-Funktion im Ressourcenpool und geben Sie ein Future-Objekt zurück
• map (func, * iterables, timeout = None, chunksize = 1): Führen Sie ähnlich wie bei der Methode multiprocessing.Pool.map () die Funktion func für jedes Element des iterierbaren Objekts aus. Ich werde.
• shutdown (wait = True): Fahren Sie Executor herunter und geben Sie alle Ressourcen frei.

Unten finden Sie ein Implementierungsbeispiel.

geocoding_by_concurrentfutures.py

from gmaps import Geocoding
from concurrent.futures import ThreadPoolExecutor

api = Geocoding(api_key='maruhi')

PLACES = (
    'Reykjavik', 'Vien', 'Zadar',
    'Venice', 'Wrocow', 'Bolognia',
    'Berlin', 'Dehil', 'New York',
    'Osaka'
)

POOL_SIZE = 4


def fetch_place(place):
    return api.geocode(place)[0]


def present_result(geocoded):
    print("{:s}, {:6.2f}, {:6.2f}".format(
        geocoded['formatted_address'],
        geocoded['geometry']['location']['lat'],
        geocoded['geometry']['location']['lng'],
    ))


def main():

    with ThreadPoolExecutor(POOL_SIZE) as executor:
        results = executor.map(fetch_place, PLACES)
        print(type(results))
        print(results)
    for result in results:
        present_result(result)


if __name__ == "__main__":
    main()

$python geocoding_by_concurrentfutures.py

<class 'generator'>
<generator object _chain_from_iterable_of_lists at 0x000001E2A3CED9C8>
Reykjavík, Iceland,  64.15, -21.94
3110 Glendale Blvd, Los Angeles, CA 90039, USA,  34.12, -118.26
Zadar, Croatia,  44.12,  15.23
Venice, Metropolitan City of Venice, Italy,  45.44,  12.32
Wrocław, Poland,  51.11,  17.04
Bologna, Metropolitan City of Bologna, Italy,  44.49,  11.34
Berlin, Germany,  52.52,  13.40
Delhi, India,  28.70,  77.10
New York, NY, USA,  40.71, -74.01
Osaka, Japan,  34.69, 135.50

Über die Future Klasse

Die Klasse "Future" wird von der Funktion "Executor.submit ()" generiert. Das "Future" -Objekt verwaltet die asynchrone Ausführung aufrufbarer Objekte und zeigt die Verarbeitungsergebnisse an. Der Rückgabewert des registrierten aufrufbaren Objekts wird mit der Methode "Future.result ()" ermittelt. ** Wenn nicht fertig, blockieren Sie, bis das Ergebnis fertig ist. ** Die Ergebniserfassung mit der Methode result () muss nicht nach dem Ende des Prozesses erfolgen, undresult ()wartet auf das Ende und gibt den Wert zurück.

[Über (offizielle) zukünftige Objekte] https://docs.python.org/ja/3/library/concurrent.futures.html#future-objects

sample_concurrent_futures.py

from concurrent.futures import ThreadPoolExecutor

def loudy_return():

    print("processing")
    return 42

with ThreadPoolExecutor(1) as executor:

    future = executor.submit(loudy_return)

print(future)
print(future.result())

$python sample_concurrent_futures.py
processing
<Future at 0x27f17bd76c8 state=finished returned int>
42

Verweise

• Expert Python Programming Revised 2nd Edition

• concurrent.futures - Parallele Taskausführung