Der Unterschied zwischen Python-Thread-Pool und Multithreading

Der Unterschied zwischen Python-Thread-Pool und Multithreading: 1. Threads durchlaufen den Prozess; 3. Ein Prozess kann mehrere Threads enthalten; 4. Es ist schwierig, Daten zwischen verschiedenen Prozessen zu teilen; . Prozess Verbraucht mehr Computerressourcen als Threads.

1. Threads und Multi-Threads

Prozess: Wenn ein Programm ausgeführt wird, kann es als Prozess bezeichnet werden, der das laufende Programm sowie die vom Programm verwendeten Speicher- und Systemressourcen umfasst Mehrere Threads bestehen aus.

Thread: Ein Thread ist ein Ausführungsablauf in einem Programm. Jeder Thread verfügt über ein eigenes privates Register, und der Codebereich wird gemeinsam genutzt.

Multithreading: Multithreading bedeutet, dass ein Programm mehrere Ausführungsströme enthält, d. h. ein Programm kann mehrere verschiedene Threads gleichzeitig ausführen, um unterschiedliche Aufgaben auszuführen, sodass ein einzelnes Programm mehrere parallele Ausführungsthreads erstellen kann, um ihre jeweiligen Aufgaben zu erledigen.

Das größter Vorteil von Multithreading: Verbesserung der CPU-Auslastung (besonders geeignet für I/O-intensive Programme, die Geschwindigkeitsverbesserung ist besonders offensichtlich)

Der Unterschied zwischen Prozessen und Threads:

Eine einfache Metapher: Prozess = Zug, Thread = Wagen

Threads laufen unter dem Prozess (ein einfacher Wagen kann nicht laufen)

Ein Prozess kann mehrere Threads enthalten (ein Zug kann mehrere Wagen haben)

Es ist schwierig, Daten zwischen verschiedenen Prozessen auszutauschen (es ist schwierig für Fahrgäste in einem Zug Wechsel in einen anderen Zug, z. B. Bahnhofstransfer)

Daten können problemlos zwischen verschiedenen Threads im selben Prozess ausgetauscht werden (es ist einfach, von Waggon A zu Waggon B zu wechseln)

Prozesse verbrauchen mehr Computerressourcen als Threads (unter Verwendung mehrerer Züge Züge verbrauchen mehr Ressourcen als mehrere Waggons)

Die Prozesse wirken sich nicht gegenseitig aus. Wenn ein Thread hängen bleibt, bleibt der gesamte Prozess hängen (ein Zug hat keinen Einfluss auf einen anderen Zug, aber wenn der mittlere Wagen in einem Zug ist, wird es zu einem Brand kommen alle Waggons)

Der Prozess kann auf mehrere Maschinen erweitert werden, und der Prozess ist höchstens für Mehrkerne geeignet (verschiedene Züge können auf mehreren Gleisen fahren, und die Waggons desselben Zuges können sich nicht auf unterschiedlichen Gleisen befinden)

Prozess verwenden Die Speicheradresse kann gesperrt werden. Wenn also ein Thread gemeinsam genutzten Speicher verwendet, müssen andere Threads warten, bis dieser Speicher beendet ist, bevor sie diesen Speicher verwenden können. (Zum Beispiel die Toilette im Zug) - „Mutex-Sperre“

Die vom Prozess verwendete Speicheradresse kann die Nutzung einschränken (z. B. ein Restaurant im Zug, es darf nur eine maximale Anzahl von Personen eintreten, wenn es ist voll, Sie müssen an der Tür warten, bis jemand herauskommt Die Vorgehensweise zum Erstellen eines Threads lautet wie folgt:

threading.Thread(group=None, target=None, name=None, args=(), kwargs={}, *, 
daemon=None)

Gruppe: Der Name der ausgeführten Funktion darf nicht in Klammern gesetzt werden.

Name: Thread-Name, standardmäßig ist „Thread-N“. ' Form.

args: Parametertupel des im Parameterziel übergebenen aufrufbaren Objekts

daemon: Guardian-Modus-Attribut, der Standardwert ist „Keine“.

Wichtige Methoden des Thread-Objekts:

start(): Dadurch wird die run()-Methode in einem unabhängigen Thread aufgerufen.

run(): Diese Methode stellt die Thread-Aktivität dar Keine): Lassen Sie den aktuellen Aufruf-Thread warten, bis der Thread endet.

Daemon: Stellt dar, ob der Thread ein Daemon-Thread ist, wahr oder falsch.

Erstellen Sie eine Multithread-Instanz:

import random
import threading
import time
def awesome_function(name):
wait_time = random.randint(1, 10)
print('current thread name is :{0} and wait {1} s'.format(name, 
wait_time))
time.sleep(wait_time)
print('thread {} finished.'.format(name))
if __name__ == '__main__':
for i in range(0, 3):
t = threading.Thread(target=awesome_function, args=(i,))
t.start()

Sie können zuerst einen Blick darauf werfen Bei den laufenden Ergebnissen, die ich aufgezeichnet habe:

Das obige Beispiel startet 3 Threads und 3 Threads führen Aufgaben gleichzeitig aus. Der Thread (der mit der kürzesten Zeit. Schlaf) gibt das Ergebnis zuerst aus.

Drei Threads -Verwendete Thread-Pool-Klasse ThreadPoolExecutor

Das Starten eines neuen Threads ist sehr teuer, da es eine Interaktion mit dem Betriebssystem erfordert. In diesem Fall kann die Verwendung von Thread-Pools die Programmleistung erheblich verbessern, insbesondere wenn das Programm eine große Anzahl von Threads erstellen muss Bei sehr kurzen Lebensdauern sollten Sie die Verwendung von Thread-Pools in Betracht ziehen.

Der Thread-Pool erstellt beim Systemstart eine große Anzahl von Leerlauf-Threads, und das Programm startet einen Leerlauf, solange eine Funktion an den Thread-Pool übermittelt wird Wenn die Funktion beendet ist, stirbt der Thread nicht, sondern kehrt zum Thread-Pool zurück und wartet auf die nächste Funktion. Gleichzeitig kann die Anzahl der gleichzeitigen Threads effektiv gesteuert werden Wenn das System eine große Anzahl gleichzeitiger Threads enthält, führt dies zu einem starken Rückgang der Systemleistung und sogar zum Absturz des Python-Interpreters. Der Parameter „Anzahl der Threads“ kann die Anzahl der gleichzeitigen Threads steuern Das System darf diese Anzahl nicht überschreiten.

Der derzeit im Mainstream verwendete Thread-Pool ist der ThreadPoolExecutor im concurrent.futures-Modul:

import random
import time
from concurrent.futures import ThreadPoolExecutor
def awesome_function(name):
wait_time = random.randint(1, 10)
print('current thread name is :{0} and wait {1} s'.format(name, 
wait_time))
time.sleep(wait_time)
print('thread {} finished.'.format(name))
if __name__ == '__main__':
with ThreadPoolExecutor(max_workers=3) as t:
for i in range(0, 3):
t.submit(awesome_function, i)

Die laufenden Ergebnisse werden wie folgt aufgezeichnet:

Erstellen Sie einen Thread-Pool mit einer maximalen Kapazität von 3 Thread-Pool-Objekt, senden Sie die ausgeführte Funktion über Submit an den Thread-Pool. Wenn ein Thread im Thread-Pool (thread 2) Wenn die Ausführung abgeschlossen ist, wird der inaktive Thread (Thread 3) in den Pool gestellt usw., bis alle Threads abgeschlossen sind und das Programm endet.

Das obige ist der detaillierte Inhalt vonDer Unterschied zwischen Python-Thread-Pool und Multithreading. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!