Multi-Threading ähnelt der Ausführung mehrerer verschiedener Programme gleichzeitig und bietet folgende Vorteile:
Durch die Verwendung von Threads können Aufgaben in Langzeitprogrammen zur Verarbeitung in den Hintergrund gerückt werden.
Die Benutzeroberfläche kann attraktiver gestaltet werden, sodass, wenn der Benutzer auf eine Schaltfläche klickt, um die Verarbeitung bestimmter Ereignisse auszulösen, ein Fortschrittsbalken angezeigt werden kann, der den Fortschritt der Verarbeitung anzeigt.
Die Die Laufgeschwindigkeit des Programms kann beschleunigt werden
Threads sind nützlicher bei der Implementierung einiger Warteaufgaben wie Benutzereingaben, Lesen und Schreiben von Dateien sowie Senden und Empfangen von Daten über das Netzwerk. In diesem Fall können wir einige wertvolle Ressourcen wie Speichernutzung usw. freigeben.
Threads unterscheiden sich immer noch von Prozessen während der Ausführung. Jeder unabhängige Thread verfügt über einen Einstiegspunkt für die Programmausführung, eine sequentielle Ausführungssequenz und einen Ausstiegspunkt für das Programm. Threads können jedoch nicht unabhängig ausgeführt werden und müssen im Anwendungsprogramm vorhanden sein, und das Anwendungsprogramm bietet eine Steuerung für die Ausführung mehrerer Threads.
Jeder Thread verfügt über einen eigenen Satz von CPU-Registern, den sogenannten Thread-Kontext, der den Zustand der CPU-Register zum letzten Mal widerspiegelt, als der Thread ausgeführt wurde.
Der Befehlszeiger und das Stapelzeigerregister sind die beiden wichtigsten Register im Thread-Kontext. Der Thread wird immer im Prozesskontext ausgeführt. Diese Adressen werden verwendet, um den Speicher im Adressraum des Prozesses zu markieren der Thread.
Threads können vorbelegt (unterbrochen) werden.
Ein Thread kann vorübergehend angehalten werden (auch Ruhezustand genannt), während andere Threads ausgeführt werden – dies wird als Thread-Zurückziehen bezeichnet.
Beginnen Sie mit dem Erlernen von Python-Threads
Es gibt zwei Möglichkeiten, Threads in Python zu verwenden: Funktionen oder Klassen zum Umschließen von Thread-Objekten.
Funktional: Rufen Sie die Funktion start_new_thread() im Thread-Modul auf, um einen neuen Thread zu generieren. Die Syntax lautet wie folgt:
thread.start_new_thread ( function, args[, kwargs] )
Parameterbeschreibung:
Funktion – Thread-Funktion.
args – die an die Thread-Funktion übergebenen Parameter, es muss ein Tupeltyp sein.
kwargs – optionale Parameter.
Instanz:
#!/usr/bin/python
Thread importieren
Importzeit
# Definieren Sie eine Funktion für den Thread
def print_time(threadName, Verzögerung):
count = 0
while count < 5:
time.sleep(delay)
count = 1
print "%s: %s" % (threadName, time . ctime(time.time()) )
# Erstelle zwei Threads
versuche:
thread.start_new_thread( print_time, ("Thread- 1", 2, ) )
thread.start_new_thread( print_time, ("Thread-2", 4, ) )
außer:
print "Fehler: nicht möglich start thread"
while 1:
pass
Das Ausgabeergebnis der oben genannten Ausführung Das Programm lautet wie folgt:
Thread-1: Do, 22. Jan. 15:42:17 2009
Thread-1: Do, 22. Jan. 15 :42:19 2009
Thread-2: Do, 22. Jan. 15:42:19 2009
Thread-1: Do, 22. Jan. 15:42:21 2009
Thread -2: Do, 22. Jan. 15:42:23 2009
Thread-1: Do, 22. Jan. 15:42:23 2009
Thread-1: Do, 22. Jan. 15:42:25 2009
Thread-2: Do, 22. Jan. 15:42:27 2009
Thread-2: Do, 22. Jan. 15:42:31 2009
Thread-2: Do. Jan 22 15:42:35 2009
Das Ende eines Threads hängt im Allgemeinen vom natürlichen Ende der Thread-Funktion ab; Sie können auch thread.exit() aufrufen; in der Thread-Funktion, die eine SystemExit-Ausnahme auslöst, um den Zweck des Beendens des Threads zu erreichen.
Threading-Modul
Python bietet Unterstützung für Threads durch zwei Standardbibliotheken, Thread und Threading. Thread bietet einfache Low-Level-Threads und eine einfache Sperre.
Andere vom Thread-Modul bereitgestellte Methoden:
threading.currentThread(): Gibt die aktuelle Thread-Variable zurück.
threading.enumerate(): Gibt eine Liste mit laufenden Threads zurück. „Laufen“ bezieht sich auf die Zeit nach dem Start und vor dem Ende des Threads, mit Ausnahme von Threads vor dem Start und nach der Beendigung.
threading.activeCount(): Gibt die Anzahl der laufenden Threads zurück, was das gleiche Ergebnis wie len(threading.enumerate()) hat.
Zusätzlich zu den Verwendungsmethoden stellt das Thread-Modul auch die Thread-Klasse zur Verarbeitung von Threads bereit. Die Thread-Klasse stellt die folgenden Methoden bereit:
run(): Eine Methode zur Darstellung der Thread-Aktivität.
start(): Thread-Aktivität starten.
join([time]): Warten Sie, bis der Thread beendet ist. Dadurch wird der aufrufende Thread blockiert, bis die Methode „join()“ des Threads abgebrochen wird – normal beendet wird oder eine nicht behandelte Ausnahme ausgelöst wird – oder ein optionaler Timeout auftritt.
isAlive(): Gibt zurück, ob der Thread aktiv ist.
getName(): Gibt den Thread-Namen zurück.
setName(): Setzt den Thread-Namen.
Verwenden Sie das Threading-Modul, um einen Thread zu erstellen
Verwenden Sie das Threading-Modul, um einen Thread zu erstellen, erben Sie direkt von threading.Thread und überschreiben Sie dann die __init__-Methode und die Ausführungsmethode:
#!/usr/bin/python
Threading importieren
Importzeit
exitFlag = 0
class myThread (threading.Thread): #Inherit the parent class threading.Thread
def __init__(self, threadID, Name, Zähler):
not not been been there — . Der Thread führt die Ausführungsfunktion direkt nach seiner Erstellung aus
print „Starting“ self.name
print_time(self .name, self.counter, 5)
print „Exiting“ self.name
def print_time(threadName, delay, counter):
while counter:
if exitFlag:
thread.exit()
time.sleep(delay)
print „%s: %s“ % (threadName, time.ctime(time.time()))
counter -= 1
# Einen neuen Thread erstellen
thread1 = myThread( 1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)
# Thread öffnen
thread1.start()
thread2. start()
print „Hauptthread verlassen“
Die Ausführungsergebnisse des obigen Programms sind wie folgt;
Thread-1: Do, 21. März 09:10:03 2013
Thread-1: Do, 21. März 09:10:04 2013
Thread-2: Do. März 21 09:10:04 2013
Thread-1: Do 21. März 09:10:05 2013
Thread-1: Do 21. März 09:10:06 2013
Thread-2: Do, 21. März 09:10:06 2013
Thread-1: Do, 21. März 09:10:07 2013
Thread-1 wird verlassen
Thread -2: Do, 21. März 09:10:08 2013
Thread-2: Do, 21. März 09:10:10 2013
Thread-2: Do, 21. März 09:10:12 2013
Thread-2 beenden
Thread-Synchronisation
Wenn mehrere Threads gemeinsam bestimmte Daten ändern, kann es zu unvorhersehbaren Ergebnissen kommen Um die Richtigkeit der Daten sicherzustellen, müssen mehrere Threads synchronisiert werden.
Eine einfache Thread-Synchronisierung kann mithilfe der Sperr- und Rlock-Methoden des Thread-Objekts erreicht werden. Für Daten, für deren Ausführung jeweils nur ein Thread erforderlich ist, können die Vorgänge zwischen Erwerb und Freigabe platziert werden Methoden. Wie folgt:
Der Vorteil von Multithreading besteht darin, dass mehrere Aufgaben gleichzeitig ausgeführt werden können (zumindest fühlt es sich so an). Wenn Threads jedoch Daten gemeinsam nutzen müssen, kann es zu Problemen mit der Datensynchronisierung kommen.
Stellen Sie sich diese Situation vor: Alle Elemente in einer Liste sind 0, der Thread „set“ ändert alle Elemente von hinten nach vorne auf 1 und der Thread „print“ ist dafür verantwortlich, die Liste von vorne nach hinten zu lesen und Drucken.
Wenn sich dann der Thread „set“ zu ändern beginnt, druckt der Thread „print“ möglicherweise die Liste und die Ausgabe ist halb 0 und halb 1. Dies ist die Desynchronisation der Daten. Um diese Situation zu vermeiden, wurde das Konzept der Sperren eingeführt.
Schlösser haben zwei Zustände – gesperrt und entsperrt. Immer wenn ein Thread wie „set“ auf gemeinsam genutzte Daten zugreifen möchte, muss er zuerst die Sperre erhalten. Wenn ein anderer Thread wie „print“ bereits eine Sperre erhalten hat, muss der Thread „set“ angehalten werden, was eine synchrone Blockierung darstellt bis der Thread " Drucken "Nachdem der Zugriff abgeschlossen und die Sperre aufgehoben wurde, lassen Sie den Thread weiter "setzen".
Nach einer solchen Verarbeitung werden beim Drucken der Liste entweder alle Nullen oder alle Einsen ausgegeben, und es gibt keine peinliche Szene mehr aus halben Nullen und halben Einsen mehr.
Instanz:
#!/usr/bin/python
Threading importieren
Importzeit
class myThread (threading.Thread):
def __init__(self, threadID, name, counter):
threading.Thread.__init__(self)
self.threadID = threadID
self.name = name
self.counter = counter
def run(self):
print „Starting“ self.name
# Erhalten Sie die Sperre und geben Sie „True“ zurück nach Zeitüberschreitung zurückgegeben > threadLock.release()
def print_time(threadName, delay, counter):
while counter:
time.sleep(delay)
print "%s: %s" % (threadName, time.ctime(time.time()))
counter -= 1
threadLock = threading.Lock()
threads = []
# Einen neuen Thread erstellen
thread1 = myThread(1, "Thread-1" , 1)
thread2 = myThread( 2, „Thread-2“, 2)
# Einen neuen Thread starten
thread1.start()
thread2.start()
# Thread zur Threadliste hinzufügen
threads.append(thread1)
threads.append (thread2)
# Warten, bis alle Threads abgeschlossen sind
für t in Threads:
t.join()
print „ Exiting Main Thread“
Thread Priority Queue (Queue)
Pythons Queue-Modul bietet eine synchrone, threadsichere Warteschlangenklasse, einschließlich FIFO-Warteschlange (First In First Out), LIFO ( (Last In First Out) Warteschlange LifoQueue und Prioritätswarteschlange PriorityQueue. Diese Warteschlangen implementieren Sperrprimitive und können direkt in Multithreads verwendet werden. Warteschlangen können verwendet werden, um eine Synchronisierung zwischen Threads zu erreichen.
Gemeinsame Methoden im Queue-Modul:
Queue.qsize() gibt die Größe der Warteschlange zurück
Queue.empty() Wenn die Warteschlange ist leer, gibt True zurück, andernfalls False
Queue.full() Wenn die Warteschlange voll ist, wird True zurückgegeben, andernfalls False
Queue.full entspricht der maximalen Größe
Queue.get([ block[, timeout]]) Holen Sie sich die Warteschlange, Timeout-Wartezeit
Queue.get_nowait() entspricht Queue.get(False)
Queue.put(item ) In die Warteschlange schreiben, Timeout-Wartezeit
Queue.put_nowait(item) entspricht Queue.put(item, False)
Queue.task_done() Nach Abschluss einer Aufgabe wird die Warteschlange Die Funktion .task_done() gibt eine Nachricht an die abgeschlossene Aufgabe zurück
Queue.join() bedeutet eigentlich, zu warten, bis die Warteschlange leer ist, bevor andere Vorgänge ausgeführt werden
Beispiel:
#!/usr/bin/python
Import Queue
Import Threading
Importzeit
exitFlag = 0
class myThread (threading.Thread):
def __init__(self, threadID, name, q):
process_data(self.name, self.q)
print „Exiting“ self.name
def Process_data(threadName, q):
while not exitFlag:
queueLock.acquire()
if not workQueue.empty( ):
data = q.get()
queueLock.release()
print "%s processing %s" % (threadName, data)
else:
queueLock.release()
time.sleep(1)
threadList = ["Thread-1", "Thread-2", "Thread-3"]
nameList = ["One", "Two", "Three ", "Vier", "Fünf"]
queueLock = threading.Lock()
workQueue = Queue.Queue(10)
threads = []
threadID = 1
# 创建新线程
für tName in threadList:
thread = myThread(threadID, tName, workQueue)
thread.start()
threads.append(thread)
threadID = 1
# 填充队列
queueLock.acquire()
für Wort in
# 等待队列清空while nicht 🎜>exitFlag = 1
# 等待所有线程完成
für t in-Threads:
t.join()
print "Hauptthread verlassen"
以上程序执行结果：
Startthread-1
Thread-2 wird gestartet
Thread-3 wird gestartet
Thread-1 verarbeitet Eins
Thread-2 verarbeitet Zwei
Thread-3 verarbeitet Drei
Thread-1 verarbeitet Vier
Thread-2 verarbeitet Fünf
Thread-3 wird beendet
Thread-1 wird beendet
Thread-2 wird beendet
Hauptthread verlassen
