Detailliertes Beispiel dafür, wie Python Parallelitätsprobleme durch Futures behandelt

Dieser Artikel stellt Python hauptsächlich zur Bewältigung von Parallelitätsproblemen in der Zukunft vor. Er ist sehr gut und hat Referenzwert.

Erste Einführung in die Zukunft

Verwenden Sie das folgende Skript, um ein vorläufiges Verständnis der Zukunft zu erhalten:

Beispiel 1: Gewöhnliche Schleifenmethode

import os
import time
import sys
import requests
POP20_CC = (
 "CN IN US ID BR PK NG BD RU JP MX PH VN ET EG DE IR TR CD FR"
).split()
BASE_URL = 'http://flupy.org/data/flags'
DEST_DIR = 'downloads/'
def save_flag(img,filename):
 path = os.path.join(DEST_DIR,filename)
 with open(path,'wb') as fp:
 fp.write(img)
def get_flag(cc):
 url = "{}/{cc}/{cc}.gif".format(BASE_URL,cc=cc.lower())
 resp = requests.get(url)
 return resp.content
def show(text):
 print(text,end=" ")
 sys.stdout.flush()
def download_many(cc_list):
 for cc in sorted(cc_list):
 image = get_flag(cc)
 show(cc)
 save_flag(image,cc.lower()+".gif")
 return len(cc_list)
def main(download_many):
 t0 = time.time()
 count = download_many(POP20_CC)
 elapsed = time.time()-t0
 msg = "\n{} flags downloaded in {:.2f}s"
 print(msg.format(count,elapsed))
if __name__ == '__main__':
 main(download_many)

Beispiel 2: Durch die zukünftige Methode implementiert, hier verwenden wir einen Teil des obigen Codes wieder

 from concurrent import futures
from flags import save_flag, get_flag, show, main
MAX_WORKERS = 20
def download_one(cc):
 image = get_flag(cc)
 show(cc)
 save_flag(image, cc.lower()+".gif")
 return cc
def download_many(cc_list):
 workers = min(MAX_WORKERS,len(cc_list))
 with futures.ThreadPoolExecutor(workers) as executor:
 res = executor.map(download_one, sorted(cc_list))
 return len(list(res))
if __name__ == '__main__':
 main(download_many)

Führen Sie jeweils drei Mal aus, die Durchschnittsgeschwindigkeit der beiden beträgt: 13,67 und 1,59 Sekunden, man sieht, dass der Unterschied immer noch sehr groß ist.

future

future ist ein wichtiger Bestandteil des concurrent.futures-Moduls und des Asyncio-Moduls

Ab Python 3.4 gibt es in der Standardbibliothek zwei Klassen mit dem Namen Future: concurrent.futures.Future und asyncio.Future
Diese beiden Klassen haben die gleiche Funktion: Instanzen beider Future-Klassen repräsentieren Dinge, die abgeschlossen werden können oder noch nicht abgeschlossen. Ähnliche Funktionen wie die Deferred-Klasse in Twisted und die Future-Klasse im Tornado-Framework

Hinweis: Normalerweise sollten Sie einen Future nicht selbst erstellen, sondern ihn durch das Parallelitätsframework (concurrent.futures oder asyncio) instanziieren

Grund: Zukunft stellt etwas dar, das irgendwann passieren wird, und die einzige Möglichkeit, festzustellen, dass etwas passieren wird, besteht darin, die Ausführungszeit zu planen, also nur, wenn etwas zur Verarbeitung an die Unterklasse concurrent.futures.Executor übergeben wird. Es wird eine concurrent.futures.Future-Instanz erstellt.
Zum Beispiel: Der Parameter der Methode Executor.submit() ist ein aufrufbares Objekt. Nach dem Aufruf dieser Methode wird die Zeit für das eingehende aufrufbare Objekt und eine

Zukunft

Der Client-Code kann den Status der Zukunft nicht ändern, nachdem die durch die Zukunft dargestellte verzögerte Berechnung endet.

Beide Futures verfügen über eine .done()-Methode. Diese Methode blockiert nicht und der Rückgabewert ist ein boolescher Wert, der angibt, ob das mit der Zukunft verknüpfte aufrufbare Objekt ausgeführt wurde. Der Clientcode fragt normalerweise nicht, ob die Ausführung der Zukunft abgeschlossen ist, sondern wartet auf eine Benachrichtigung. Daher verfügen beide Future-Klassen über die Methode .add_done_callback(). Diese Methode hat nur einen Parameter und der Typ ist ein aufrufbares Objekt. Das angegebene aufrufbare Objekt wird nach der Ausführung der Zukunft aufgerufen. Die Methode

.result() hat in den beiden Future-Klassen dieselbe Funktion: das Ergebnis des aufrufbaren Objekts zurückzugeben oder die beim Ausführen des aufrufbaren Objekts ausgelöste Ausnahme erneut auszulösen. Wenn die Zukunft jedoch nicht endet, ist das Verhalten der Ergebnismethode in den beiden Future-Klassen sehr unterschiedlich.

Bei concurrent.futures.Future-Instanzen blockiert der Aufruf der .result()-Methode den Thread des Aufrufers, bis ein Ergebnis zurückgegeben werden kann. Zu diesem Zeitpunkt kann die Ergebnismethode ein optionales Ergebnis empfangen timeout Parameter: Wenn die Zukunft nicht innerhalb der angegebenen Zeit ausgeführt wird, wird eine TimeoutError-Ausnahme ausgelöst.

Die asyncio.Future.result-Methode unterstützt das Festlegen des Timeouts nicht. Es ist am besten, die Ausbeute aus der Struktur zu verwenden, um zukünftige Ergebnisse zu erhalten, aber concurrent.futures.Future kann dies nicht

Egal ob asyncio oder concurrent.futures.Future, es wird mehrere Funktionen geben, die Future zurückgeben, und andere Funktionen verwenden Future. Im ersten Beispiel verwendet die von uns verwendete Executor.map Future und der Rückgabewert ist ein Iterator. Die Iterator-Methode __next__ ruft die Ergebnismethode jeder Zukunft auf, sodass wir das Ergebnis jeder Zukunft erhalten, nicht die Zukunft selbst

In Bezug auf die Verwendung der Funktion „future.as_completed“ verwenden wir hier zwei Schleifen, eine mit Zum Erstellen und Planen der Zukunft, die andere wird verwendet, um das Ergebnis der Zukunft zu erhalten

from concurrent import futures
from flags import save_flag, get_flag, show, main
MAX_WORKERS = 20
def download_one(cc):
 image = get_flag(cc)
 show(cc)
 save_flag(image, cc.lower()+".gif")
 return cc
def download_many(cc_list):
 cc_list = cc_list[:5]
 with futures.ThreadPoolExecutor(max_workers=3) as executor:
 to_do = []
 for cc in sorted(cc_list):
  future = executor.submit(download_one,cc)
  to_do.append(future)
  msg = "Secheduled for {}:{}"
  print(msg.format(cc,future))
 results = []
 for future in futures.as_completed(to_do):
  res = future.result()
  msg = "{}result:{!r}"
  print(msg.format(future,res))
  results.append(res)
 return len(results)
if __name__ == '__main__':
 main(download_many)

Das Ergebnis ist wie folgt:

Hinweis: Python-Code kann GIL nicht steuern. Alle Funktionen in der Standardbibliothek, die blockierende E/A-Vorgänge ausführen, geben die GIL frei, wenn sie darauf warten, dass das Betriebssystem Ergebnisse zurückgibt. Genau aus diesem Grund können Python-Threads ausgeführt werden spielen eine Rolle in E/A-intensiven Anwendungen

Die oben genannten sind concurrent.futures zum Starten des Threads, die folgenden dienen zum Starten des Prozesses durch ihn

concurrent.futures zu Starten Sie den Prozess

concurrent.futures Die ProcessPoolExecutor-Klasse verteilt die Arbeit auf mehrere Python-Prozesse. Wenn Sie also eine CPU-intensive Verarbeitung durchführen müssen, verwenden Sie dieses Modul, um die GIL zu umgehen und die gesamte CPU zu nutzen Kerne.

Das Prinzip besteht darin, dass ein ProcessPoolExecutor N unabhängige Python-Interpreter erstellt, wobei N die Anzahl der auf dem System verfügbaren CPU-Kerne ist.

Die Verwendungsmethode ist dieselbe wie die ThreadPoolExecutor-Methode

Das obige ist der detaillierte Inhalt vonDetailliertes Beispiel dafür, wie Python Parallelitätsprobleme durch Futures behandelt. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!