Python-Multithreading

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