_thread — Low-level Threading API

Dieses Modul stellt Low-Level-Primitive für die Arbeit mit mehreren Threads (auch als leichtgewichtige Prozesse oder Tasks bezeichnet) bereit – mehrere Kontrollströme, die ihren globalen Datenspeicher teilen. Zur Synchronisierung werden einfache Sperren (auch als Mutexes oder binäre Semaphore bezeichnet) bereitgestellt. Das Modul threading bietet eine einfachere und höherwertige Threading-API, die auf diesem Modul aufbaut.

Geändert in Version 3.7: Dieses Modul war früher optional, es ist jetzt immer verfügbar.

Dieses Modul definiert die folgenden Konstanten und Funktionen

exception _thread.error

Wird bei Thread-spezifischen Fehlern ausgelöst.

Geändert in Version 3.3: Dies ist jetzt ein Synonym für die eingebaute RuntimeError.

_thread.LockType

Dies ist der Typ von Lock-Objekten.

_thread.start_new_thread(function, args[, kwargs])

Startet einen neuen Thread und gibt seine Kennung zurück. Der Thread führt die Funktion function mit der Argumentliste args (die ein Tupel sein muss) aus. Das optionale Argument kwargs gibt ein Wörterbuch von Schlüsselwortargumenten an.

Wenn die Funktion zurückkehrt, wird der Thread stillschweigend beendet.

Wenn die Funktion mit einer unbehandelten Ausnahme endet, wird sys.unraisablehook() aufgerufen, um die Ausnahme zu behandeln. Das Attribut object des Hook-Arguments ist function. Standardmäßig wird ein Stack-Trace ausgegeben und dann wird der Thread beendet (aber andere Threads laufen weiter).

Wenn die Funktion eine SystemExit-Ausnahme auslöst, wird sie stillschweigend ignoriert.

Löst ein Auditing-Event _thread.start_new_thread mit den Argumenten function, args, kwargs aus.

Geändert in Version 3.8: sys.unraisablehook() wird jetzt verwendet, um unbehandelte Ausnahmen zu behandeln.

_thread.interrupt_main(signum=signal.SIGINT, /)

Simuliert die Auswirkung eines Signals, das im Hauptthread eintrifft. Ein Thread kann diese Funktion verwenden, um den Hauptthread zu unterbrechen, es gibt jedoch keine Garantie, dass die Unterbrechung sofort erfolgt.

Wenn signum angegeben ist, ist es die Nummer des zu simulierenden Signals. Wenn signum nicht angegeben ist, wird signal.SIGINT simuliert.

Wenn das angegebene Signal nicht von Python behandelt wird (es wurde auf signal.SIG_DFL oder signal.SIG_IGN gesetzt), tut diese Funktion nichts.

Geändert in Version 3.10: Das Argument signum wird hinzugefügt, um die Signalnummer anzupassen.

Hinweis

Dies löst nicht das entsprechende Signal aus, sondern plant einen Aufruf des zugehörigen Handlers (falls vorhanden). Wenn Sie das Signal tatsächlich auslösen möchten, verwenden Sie signal.raise_signal().

_thread.exit()

Löst die Ausnahme SystemExit aus. Wenn sie nicht abgefangen wird, führt dies dazu, dass der Thread stillschweigend beendet wird.

_thread.allocate_lock()

Gibt ein neues Lock-Objekt zurück. Die Methoden von Locks sind nachfolgend beschrieben. Das Lock ist anfangs nicht gesperrt.

_thread.get_ident()

Gibt die 'Thread-Kennung' des aktuellen Threads zurück. Dies ist eine ganzzahlige Zahl ungleich Null. Ihr Wert hat keine direkte Bedeutung; sie ist als magischer Cookie gedacht, der z. B. zur Indexierung eines Wörterbuchs mit Thread-spezifischen Daten verwendet werden kann. Thread-Kennungen können wiederverwendet werden, wenn ein Thread beendet wird und ein anderer Thread erstellt wird.

_thread.get_native_id()

Gibt die native ganzzahlige Thread-ID des aktuellen Threads zurück, die vom Kernel zugewiesen wurde. Dies ist eine nicht-negative ganze Zahl. Ihr Wert kann verwendet werden, um diesen speziellen Thread systemweit eindeutig zu identifizieren (bis der Thread beendet ist, danach kann der Wert vom Betriebssystem wiederverwendet werden).

Verfügbarkeit: Windows, FreeBSD, Linux, macOS, OpenBSD, NetBSD, AIX, DragonFlyBSD, GNU/kFreeBSD.

Hinzugefügt in Version 3.8.

Geändert in Version 3.13: Unterstützung für GNU/kFreeBSD hinzugefügt.

_thread.stack_size([size])

Gibt die Thread-Stack-Größe zurück, die beim Erstellen neuer Threads verwendet wird. Das optionale Argument size gibt die für nachfolgend erstellte Threads zu verwendende Stack-Größe an und muss 0 (Plattform- oder konfigurierter Standard verwenden) oder eine positive Ganzzahl von mindestens 32.768 (32 KiB) sein. Wenn size nicht angegeben ist, wird 0 verwendet. Wenn die Änderung der Thread-Stack-Größe nicht unterstützt wird, wird ein RuntimeError ausgelöst. Wenn die angegebene Stack-Größe ungültig ist, wird ein ValueError ausgelöst und die Stack-Größe wird nicht geändert. 32 KiB ist derzeit die minimal unterstützte Stack-Größe, um genügend Stack-Speicher für den Interpreter selbst zu gewährleisten. Beachten Sie, dass einige Plattformen möglicherweise besondere Einschränkungen für Stack-Größen haben, wie z. B. eine Mindestgröße von > 32 KiB oder die Anforderung von Allokationen in Vielfachen der System-Speicherseitengröße – die Dokumentation der Plattform sollte für weitere Informationen konsultiert werden (4 KiB Seiten sind üblich; die Verwendung von Vielfachen von 4096 für die Stack-Größe ist der empfohlene Ansatz, wenn keine spezifischeren Informationen vorliegen).

Verfügbarkeit: Windows, pthreads.

Unix-Plattformen mit POSIX-Threads-Unterstützung.

_thread.TIMEOUT_MAX

Der maximal zulässige Wert für den Parameter timeout von Lock.acquire. Die Angabe eines Zeitlimits, das größer als dieser Wert ist, löst einen OverflowError aus.

Hinzugefügt in Version 3.2.

Lock-Objekte haben die folgenden Methoden

lock.acquire(blocking=True, timeout=-1)

Ohne optionale Argumente erwirbt diese Methode das Lock bedingungslos, falls notwendig wartend, bis es von einem anderen Thread freigegeben wird (nur ein Thread kann zu einem Zeitpunkt ein Lock erwerben – das ist ihr Zweck).

Wenn das Argument blocking vorhanden ist, hängt die Aktion von seinem Wert ab: wenn es false ist, wird das Lock nur erworben, wenn es sofort ohne Wartezeit erworben werden kann, während wenn es true ist, das Lock bedingungslos wie oben erworben wird.

Wenn das Gleitkomma-Argument timeout vorhanden und positiv ist, gibt es die maximale Wartezeit in Sekunden vor der Rückgabe an. Ein negatives timeout-Argument gibt ein unbegrenztes Warten an. Sie können kein timeout angeben, wenn blocking false ist.

Der Rückgabewert ist True, wenn das Lock erfolgreich erworben wurde, False, wenn nicht.

Geändert in Version 3.2: Das Parameter timeout ist neu.

Geändert in Version 3.2: Lock-Erwerbe können auf POSIX nun durch Signale unterbrochen werden.

Geändert in Version 3.14: Lock-Erwerbe können unter Windows nun durch Signale unterbrochen werden.

lock.release()

Gibt das Lock frei. Das Lock muss zuvor erworben worden sein, aber nicht unbedingt vom selben Thread.

lock.locked()

Gibt den Status des Locks zurück: True, wenn es von einem Thread erworben wurde, False, wenn nicht.

Zusätzlich zu diesen Methoden können Lock-Objekte auch über die with-Anweisung verwendet werden, z. B.

import _thread

a_lock = _thread.allocate_lock()

with a_lock:
    print("a_lock is locked while this executes")

Einschränkungen

  • Unterbrechungen gehen immer an den Hauptthread (die Ausnahme KeyboardInterrupt wird von diesem Thread empfangen).

  • Das Aufrufen von sys.exit() oder das Auslösen der Ausnahme SystemExit ist äquivalent zum Aufrufen von _thread.exit().

  • Wenn der Hauptthread beendet wird, ist es systemabhängig, ob die anderen Threads überleben. Auf den meisten Systemen werden sie beendet, ohne try … finally-Klauseln auszuführen oder Objekt-Destruktoren auszuführen.