Threads und der GIL
Die Grenzen von Python-Threads verstehen
Threads und der GIL ist eine kostenlose Python Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Python Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Python Academy-Kurs umfasst insgesamt 4 Lektionen.
Was ist ein Thread?
Ein Thread ist ein eigener Ausführungsfluss innerhalb eines Prozesses. Mit Pythons threading-Modul können Sie Funktionen innerhalb eines einzelnen Programms nebenläufig ausführen.
import threading
def worker():
print('hello from thread')
t = threading.Thread(target=worker)
t.start()
t.join()
print('main done')Mehrere Threads starten
Sie können mehrere Threads starten. Jeder führt seine Zielfunktion aus. join() sorgt dafür, dass der Haupt-Thread wartet, bis ein Thread beendet ist.
import threading
def task(name):
print('task', name)
threads = [threading.Thread(target=task, args=(i,)) for i in range(3)]
for t in threads:
t.start()
for t in threads:
t.join()
print('all finished')Der Global Interpreter Lock
CPython verfügt über einen Global Interpreter Lock (GIL): Zu jedem Zeitpunkt führt nur ein Thread Python-Bytecode aus. Daher bieten Threads bei rechenintensiver Arbeit mit reinem Python keinen echten parallelen Geschwindigkeitsgewinn.
import sys
print('Running on:', sys.implementation.name)
print('Only one thread runs Python bytecode at a time due to the GIL')Wo Threads trotzdem helfen
Threads eignen sich hervorragend für I/O-bound-Arbeit: Netzwerkanfragen, Festplattenzugriffe und Wartezeiten. Während ein Thread wartet, wird der GIL freigegeben, sodass ein anderer ausgeführt werden kann.
import threading, time
def fake_io(name):
time.sleep(0.1)
print('done', name)
start = time.perf_counter()
ts = [threading.Thread(target=fake_io, args=(i,)) for i in range(3)]
for t in ts: t.start()
for t in ts: t.join()
print('elapsed about 0.1s, not 0.3s')CPU-bound-Arbeit wird nicht schneller
Bei aufwendigen Berechnungen wird die Ausführung durch zusätzliche Threads nicht schneller, weil der GIL sie serialisiert. Verwenden Sie für CPU-bound-Arbeit stattdessen multiprocessing.
import threading
def burn():
total = 0
for i in range(1000000):
total += i
return total
t = threading.Thread(target=burn)
t.start()
t.join()
print('CPU-bound: threads share one core under the GIL')Daemon-Threads
Ein Daemon-Thread wird automatisch beendet, wenn das Hauptprogramm endet. Verwenden Sie ihn für Hintergrundaufgaben, auf deren Abschluss Sie nicht warten müssen.
import threading, time
def background():
time.sleep(0.05)
print('background tick')
t = threading.Thread(target=background, daemon=True)
t.start()
t.join()
print('main exits')Threads benennen und identifizieren
Jeder Thread hat einen Namen und eine ID. threading.current_thread() gibt das Objekt des aktuell ausgeführten Threads zurück und ist praktisch für die Protokollierung.
import threading
def show():
t = threading.current_thread()
print('running in', t.name)
t = threading.Thread(target=show, name='Worker-1')
t.start()
t.join()
print('main thread:', threading.current_thread().name)Thread ableiten
Statt ein Ziel zu übergeben, können Sie Thread ableiten und run() überschreiben. Das ist nützlich, wenn ein Thread seinen eigenen Zustand benötigt.
import threading
class Greeter(threading.Thread):
def __init__(self, name):
super().__init__()
self.who = name
def run(self):
print('hi', self.who)
g = Greeter('Sam')
g.start()
g.join()Ergebnisse aus Threads zurückgeben
Der Rückgabewert einer Zielfunktion wird verworfen. Um Ergebnisse zu sammeln, schreiben Sie sie in eine gemeinsam verwendete Datenstruktur (später lernen Sie sicherere Werkzeuge wie Queues kennen).
import threading
results = {}
def compute(key):
results[key] = key * key
ts = [threading.Thread(target=compute, args=(i,)) for i in range(4)]
for t in ts: t.start()
for t in ts: t.join()
print(results)Aktive Threads zählen
threading.active_count() gibt an, wie viele Threads derzeit aktiv sind, einschließlich des Haupt-Threads.
import threading, time
def wait():
time.sleep(0.05)
ts = [threading.Thread(target=wait) for _ in range(2)]
for t in ts: t.start()
print('active now:', threading.active_count())
for t in ts: t.join()
print('active after join:', threading.active_count())Threads oder Prozesse wählen
Als Faustregel gilt: Verwenden Sie Threads für I/O-bound-Nebenläufigkeit und Prozesse für CPU-bound-Parallelität. Der GIL ist der Grund dafür.
tasks = {'download files': 'threads', 'crunch numbers': 'processes', 'call APIs': 'threads'}
for task, choice in tasks.items():
print(task, '->', choice)Kurzer Test
Testen Sie Ihr Verständnis von Threads und dem GIL.
Zusammenfassung
Sie haben Threads und den GIL kennengelernt:
- Threads laufen innerhalb eines Prozesses mithilfe von
threading.Threadnebenläufig. - Der GIL serialisiert die Ausführung von Python-Bytecode.
- Threads helfen bei I/O-bound-Arbeit; Prozesse helfen bei CPU-bound-Arbeit.
- Verwenden Sie
start(),join(), Daemon-Threads und Ableitungen.
Als Nächstes: Threads mit ThreadPoolExecutor übersichtlich verwalten.
Häufig gestellte Fragen
Ist die Lektion „Threads und der GIL“ kostenlos?
Ja — der vollständige Text von „Threads und der GIL“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Python Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Python Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Threads und der GIL“?
Die Grenzen von Python-Threads verstehen Du übst Python Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Python Academy zu starten?
Keine Vorkenntnisse erforderlich. Python Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.
Wie lange dauert die Lektion „Threads und der GIL“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Python Academy-Lektion Code schreiben und ausführen?
Ja. Jede Python Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.