Python - Multithreading

Hallo da, zukünftige Python-Zauberer! Heute werden wir eine aufregende Reise in die Welt der Multithreading in Python antreten. Keine Sorge, wenn du neu bei der Programmierung bist; ich werde dein freundlicher Guide sein, und wir werden dieses Thema Schritt für Schritt erkunden. Also, greife dir deinen virtuellen Zauberstab (Tastatur) und lass uns einsteigen!

Was ist Multithreading?

Bevor wir mit Python-Threads zaubern beginnen, lassen Sie uns verstehen, was Multithreading bedeutet. Stell dir vor, du bist ein Küchenchef in einer geschäftigen Küche. Wenn du allein kochst, kannst du nur eine Aufgabe zur gleichen Zeit erledigen – Gemüse schneiden, dann Wasser kochen, dann Fleisch braten. Aber was wäre, wenn du mehrere Hände hättest, die verschiedene Aufgaben gleichzeitig erledigen könnten? Das ist essentially, was Multithreading für unsere Programme leistet!

Multithreading ermöglicht es einem Programm, mehrere Aufgaben gleichzeitig innerhalb eines einzelnen Prozesses auszuführen. Es ist wie having mehrere Köche (Threads) gemeinsam in der gleichen Küche (Prozess) arbeiten, um ein leckeres Essen (Programm-Ausgabe) schneller und effizienter zuzubereiten.

Vergleich mit Prozessen

Jetzt fragst du dich vielleicht, "Aber Lehrer, ich habe auch von Prozessen gehört. Wie unterscheiden sich Threads?" Große Frage! Lassen Sie uns das aufteilen:

Ressourcennutzung: Threads sind wie Geschwister, die ein Zimmer teilen (Speicherbereich), während Prozesse wie Nachbarn mit separaten Häusern sind. Threads sind leichter und teilen Ressourcen, was sie für bestimmte Aufgaben effizienter macht.
Kommunikation: Threads können leicht miteinander chatten, indem sie Variablen teilen, aber Prozesse müssen spezielle "Telefone" (Inter-Prozess-Kommunikation) verwenden, um miteinander zu sprechen.
Overhead: Das Erstellen und Verwalten von Threads ist in der Regel schneller und erfordert weniger Systemressourcen im Vergleich zu Prozessen.
Komplexität: Während Threads dein Programm schneller machen können, bringen sie auch Komplexität mit sich. Es ist wie Jonglieren – spaßig und effizient, wenn man es richtig macht, aber du könntest einen Ball fallen lassen, wenn du nicht aufpasst!

Thread-Handling-Module in Python

Python, das es so spendierfreudig ist, bietet uns mehrere Module, um mit Threads zu arbeiten. Die beiden Hauptmodule sind:

threading: Dies ist die höhere Schnittstelle zum Arbeiten mit Threads. Es ist wie der freundliche Zauberlehrling, der die meiste schwere Arbeit für dich erledigt.
_thread: Dies ist die niedrige Schnittstelle. Es ist wie das alte Zauberbuch – mächtig, aber erfordert mehr Expertise, um es korrekt zu verwenden.

Für unsere magische Reise heute werden wir uns auf das threading-Modul konzentrieren, da es Anfängerfreundlicher und weit verbreitet ist.

Einen neuen Thread starten

Na gut, lassen Sie uns unseren ersten Thread-Zauber wirken! So erstellen und starten wir einen neuen Thread:

import threading
import time

def print_numbers():
for i in range(5):
time.sleep(1)
print(f"Thread 1: {i}")

# Erstellen eines neuen Threads
thread1 = threading.Thread(target=print_numbers)

# Starten des Threads
thread1.start()

# Hauptthread führt fort, auszuführen
for i in range(5):
time.sleep(1)
print(f"Hauptthread: {i}")

# Warten, bis thread1 beendet ist
thread1.join()

print("Alles erledigt!")

Lassen Sie uns diese magische Beschwörung aufteilen:

Wir importieren die threading und time Module.
Wir definieren eine Funktion print_numbers(), die von unserem Thread ausgeführt wird.
Wir erstellen ein neues Thread-Objekt und geben an, welche Funktion es ausführen soll.
Wir starten den Thread mit der start() Methode.
Der Hauptthread führt seinen eigenen Loop fort.
Wir verwenden join(), um auf das Ende unseres Threads zu warten, bevor das Programm endet.

Wenn du das ausführst, wirst du die Zahlen beider Threads interferenzen sehen, was eine gleichzeitige Ausführung zeigt!

Threads synchronisieren

Jetzt stell dir vor, unsere Küchenhelfer versuchen, gleichzeitig den selben Messer zu verwenden – Chaos, oder? Hier kommt die Thread-Synchronisierung ins Spiel. Wir verwenden Sperren, um sicherzustellen, dass nur ein Thread gleichzeitig auf eine gemeinsame Ressource zugreifen kann.

Hier ist ein Beispiel:

import threading
import time

# Gemeinsame Ressource
counter = 0
lock = threading.Lock()

def increment_counter():
global counter
for _ in range(100000):
lock.acquire()
counter += 1
lock.release()

# Erstellen von zwei Threads
thread1 = threading.Thread(target=increment_counter)
thread2 = threading.Thread(target=increment_counter)

# Starten der Threads
thread1.start()
thread2.start()

# Warten, bis beide Threads beendet sind
thread1.join()
thread2.join()

print(f"Endgültige Zählerwert: {counter}")

In diesem Beispiel verwenden wir eine Sperre, um sicherzustellen, dass nur ein Thread gleichzeitig den Zähler erhöhen kann, was Race Conditions verhindert.

Multithreaded Prioritäts-Warteschlange

Letztlich, aber nicht zuletzt, lassen Sie uns eine praktische Anwendung des Multithreading betrachten – eine Prioritäts-Warteschlange. Stell dir eine Krankenhaus-Notaufnahme vor, in der Patienten basierend auf der Schwere ihrer Bedingung behandelt werden, nicht nur nach ihrer Ankunftszeit.

import threading
import queue
import time
import random

# Erstellen einer Prioritäts-Warteschlange
task_queue = queue.PriorityQueue()

def worker():
while True:
priority, task = task_queue.get()
print(f"Verarbeitung der Aufgabe: {task} (Priorität: {priority})")
time.sleep(random.uniform(0.1, 0.5))  # Simulieren von Arbeit
task_queue.task_done()

# Erstellen und starten von Arbeiter-Threads
for _ in range(3):
thread = threading.Thread(target=worker, daemon=True)
thread.start()

# Hinzufügen von Aufgaben zur Warteschlange
for i in range(10):
priority = random.randint(1, 5)
task = f"Aufgabe {i}"
task_queue.put((priority, task))

# Warten, bis alle Aufgaben abgeschlossen sind
task_queue.join()
print("Alle Aufgaben abgeschlossen!")

Dieses Beispiel zeigt, wie mehrere Threads gemeinsam Aufgaben aus einer Prioritäts-Warteschlange effizient verarbeiten können.

Fazit

Herzlichen Glückwunsch, junge Pythonisten! Du hast gerade deine ersten Schritte in die magische Welt des Multithreading gemacht. Denke daran, mit großer Macht kommt große Verantwortung – benutze Threads weise, und sie werden deine Programme schneller und effizienter machen.

Hier ist eine kurze Referenztabelle der wichtigsten Thread-Methoden, die wir behandelt haben:

Methode	Beschreibung
`Thread(target=function)`	Erstellt einen neuen Thread, um die angegebene Funktion auszuführen
`start()`	Startet die Thread-Aktivität
`join()`	Wartet auf das Ende des Threads
`Lock()`	Erstellt eine Sperre für die Thread-Synchronisierung
`acquire()`	Erhält eine Sperre
`release()`	Gibt eine Sperre frei

Weiter üben, neugierig bleiben, und bald wirst du Threads wie ein wahrer Python-Maestro orchestrieren! Frohes Coding!

Credits: Image by storyset

Vorheriges Tutorial:

Python - Eingebaute Ausnahmen

Nächstes Tutorial:

Python - Lebenszyklus des Threads