Python - Thread Priority (Deutsch)

Hallo, ambitionierte Programmierer! Heute werden wir ein spannendes Thema im Python-Programming betreiben: Thread-Priorität. Als euer freundlicher Nachbar und Computerlehrer bin ich hier, um euch Schritt für Schritt durch diese Reise zu führen. Keine Sorge, wenn ihr neu bei der Programmierung seid; wir beginnen mit den Grundlagen und arbeiten uns nach oben vor. Also, holt euch euer Lieblingsgetränk, macht euch komfortabel und lass uns gemeinsam auf diese Python-Abenteuerreise aufbrechen!

Threads und Priorität verstehen

Bevor wir in die Details der Thread-Priorität eintauchen, lassen wir uns einen Moment Zeit, um zu verstehen, was Threads sind. Stellt euch vor, ihr seid in einer geschäftigen Küche, und ihr seid der Küchenchef. Ihr habt mehrere Aufgaben zu erledigen: Gemüse schneiden, Suppe umrühren und einen Kuchen backen. Anstatt diese Aufgaben nacheinander zu erledigen, erteilt ihr verschiedenen Köchen (Threads) die Aufgabe, diese Aufgaben gleichzeitig zu erledigen. Das ist im Grunde genommen, was Threads in der Programmierung tun – sie ermöglichen es einem Programm, mehrere Aufgaben gleichzeitig auszuführen.

Nun ist die Thread-Priorität wie das Zuteilen von Bedeutung zu diesen Aufgaben. Genau wie ihr vielleicht bevorzugt, dass die Hauptmahlzeit vor dem Dessert bereitgestellt wird, könnt ihr bestimmte Threads in eurem Python-Programm priorisieren.

Thread-Priorität mit Sleep() setzen

Eine einfache Möglichkeit, die Thread-Priorität in Python zu beeinflussen, ist die Verwendung der Funktion sleep(). Diese Methode setzt die Priorität nicht direkt, kann jedoch helfen, die Ausführungszeit verschiedener Threads zu verwalten.

Sehen wir uns ein Beispiel an:

import threading
import time

def task(name, sleep_time):
print(f"Task {name} gestartet")
time.sleep(sleep_time)
print(f"Task {name} abgeschlossen")

# Erstellen von Threads
thread1 = threading.Thread(target=task, args=("A", 2))
thread2 = threading.Thread(target=task, args=("B", 1))

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

# Warten auf das Abschluss der Threads
thread1.join()
thread2.join()

print("Alle Aufgaben abgeschlossen")

In diesem Beispiel erstellen wir zwei Threads, die die task-Funktion ausführen. Task A schläft für 2 Sekunden, während Task B für 1 Sekunde schläft. Obwohl wir Task A zuerst starten, wird Task B wahrscheinlich zuerst abgeschlossen, aufgrund seiner kürzeren Schlafzeit.

Wenn ihr diesen Code ausführt, seht ihr etwas wie folgt:

Task A gestartet
Task B gestartet
Task B abgeschlossen
Task A abgeschlossen
Alle Aufgaben abgeschlossen

Dies zeigt, wie wir die Ausführungsreihenfolge und Dauer von Threads mit sleep() beeinflussen können.

Python-Thread-Priorität auf Windows anpassen

Auf Windows-Systemen ermöglicht Python es uns, die Thread-Priorität direkter zu setzen. Wir können das Modul win32process aus dem Paket pywin32 verwenden, um Thread-Prioritäten anzupassen.

Zuerst müsst ihr pywin32 installieren:

pip install pywin32

Nun sehe wir uns ein Beispiel an:

import threading
import time
import win32api
import win32process
import win32con

def set_thread_priority(priority):
handle = win32api.GetCurrentThread()
win32process.SetThreadPriority(handle, priority)

def task(name, priority):
set_thread_priority(priority)
print(f"Task {name} gestartet mit Priorität {priority}")
time.sleep(2)
print(f"Task {name} abgeschlossen")

# Erstellen von Threads
thread1 = threading.Thread(target=task, args=("A", win32process.THREAD_PRIORITY_BELOW_NORMAL))
thread2 = threading.Thread(target=task, args=("B", win32process.THREAD_PRIORITY_ABOVE_NORMAL))

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

# Warten auf das Abschluss der Threads
thread1.join()
thread2.join()

print("Alle Aufgaben abgeschlossen")

In diesem Beispiel setzen wir Task A auf eine niedrigere und Task B auf eine höhere Priorität. Das Windows-Betriebssystem wird versuchen, mehr CPU-Zeit für Task B zu allozieren, was zu einer schnelleren Fertigstellung führen kann.

Python-Threads mit dem Queue-Modul priorisieren

Eine weitere Möglichkeit, Thread-Prioritäten zu verwalten, ist die Verwendung des Python-Moduls Queue. Obwohl es nicht direkt die Prioritäten setzt, ermöglicht es uns, die Reihenfolge zu steuern, in der Aufgaben verarbeitet werden.

Hier ist ein Beispiel:

import threading
import queue
import time

def worker(q, name):
while True:
task = q.get()
if task is None:
break
print(f"Arbeiter {name} verarbeitet Aufgabe: {task}")
time.sleep(1)
q.task_done()

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

# Hinzufügen von Aufgaben zur Warteschlange (niedrigerer Wert = höhere Priorität)
q.put((2, "Niedrige Priorität"))
q.put((1, "Hohe Priorität"))
q.put((3, "Niedrigste Priorität"))

# Erstellen und Starten von Arbeiter-Threads
threads = []
for i in range(2):
t = threading.Thread(target=worker, args=(q, i))
t.start()
threads.append(t)

# Warten auf den Abschluss aller Aufgaben
q.join()

# Arbeiter stoppen
for i in range(2):
q.put(None)

for t in threads:
t.join()

print("Alle Aufgaben abgeschlossen")

In diesem Beispiel verwenden wir eine PriorityQueue, um Aufgaben zu verwalten. Aufgaben mit niedrigeren Zahlen werden zuerst verarbeitet. Dies ermöglicht es uns, bestimmte Aufgaben vor anderen zu priorisieren.

Fazit

Und so haben wir es, meine lieben Schüler! Wir haben drei verschiedene Möglichkeiten zur Verwaltung von Thread-Prioritäten in Python erkundet. Bedenkt, wie eine gut orchestrierte Küche, die Verwaltung von Thread-Prioritäten hilft eurem Programm effizienter zu laufen.

Hier ist eine kurze Zusammenfassung der Methoden, die wir behandelt haben:

Methode	Vorteile	Nachteile
Verwendung von sleep()	Einfach zu implementieren	Setzt die Priorität nicht direkt
Windows-spezifische Priorität	Direkte Kontrolle über die Thread-Priorität	Funktioniert nur auf Windows-Systemen
Queue-Modul	Funktioniert auf allen Systemen, ermöglicht feine Kontrolle	Erfordert eine komplexere Implementierung

Wenn ihr weiterhin auf eurer Python-Reise vorankommt, werdet ihr feststellen, dass das Verständnis von Thread-Prioritäten ungemein nützlich für die Optimierung eurer Programme ist. Übt weiter, bleibt neugierig und habt keine Angst, experimentierend. Happy coding!

Credits: Image by storyset