Einführung

Das Threading-Modul in Python bietet eine High-Level-Schnittstelle zum Erstellen und Verwalten von Threads, sodass Sie Code gleichzeitig ausführen können. Dies kann besonders nützlich für Aufgaben sein, die parallel ausgeführt werden können, wie z. B. E/A-gebundene Vorgänge. Nachfolgend finden Sie eine Liste häufig verwendeter Methoden und Funktionen im Threading-Modul mit kurzen Beispielen.

1. Thread()

Die Thread-Klasse ist das Herzstück des Threading-Moduls. Mit dieser Klasse können Sie neue Threads erstellen und starten.

import threading

def print_numbers():
    for i in range(5):
        print(i)

t = threading.Thread(target=print_numbers)
t.start()  # Starts a new thread
t.join()   # Waits for the thread to finish

2. start()

Startet die Aktivität des Threads.

t = threading.Thread(target=print_numbers)
t.start()  # Runs the target function in a separate thread

3. beitreten([timeout])

Blockiert den aufrufenden Thread, bis der Thread, dessen join()-Methode aufgerufen wird, beendet wird. Optional können Sie ein Timeout angeben.

t = threading.Thread(target=print_numbers)
t.start()
t.join(2)  # Waits up to 2 seconds for the thread to finish

4. is_alive()

Gibt True zurück, wenn der Thread noch läuft.

t = threading.Thread(target=print_numbers)
t.start()
print(t.is_alive())  # True if the thread is still running

5. current_thread()

Gibt das aktuelle Thread-Objekt zurück, das den aufrufenden Thread darstellt.

import threading

def print_current_thread():
    print(threading.current_thread())

t = threading.Thread(target=print_current_thread)
t.start()  # Prints the current thread info

6. enumerate()

Gibt eine Liste aller aktuell aktiven Thread-Objekte zurück.

t1 = threading.Thread(target=print_numbers)
t2 = threading.Thread(target=print_numbers)
t1.start()
t2.start()

print(threading.enumerate())  # Lists all active threads

7. active_count()

Gibt die Anzahl der aktuell aktiven Thread-Objekte zurück.

print(threading.active_count())  # Returns the number of active threads

8. Sperren()

Ein Lock-Objekt ist eine primitive Sperre, die verwendet wird, um Race Conditions zu verhindern. Sie können damit sicherstellen, dass jeweils nur ein Thread auf eine gemeinsam genutzte Ressource zugreift.

lock = threading.Lock()

def thread_safe_function():
    with lock:  # Acquires the lock
        # Critical section
        print("Thread-safe code")

t = threading.Thread(target=thread_safe_function)
t.start()

9. RLock()

Eine Wiedereintrittssperre ermöglicht es einem Thread, die Sperre mehrmals zu erwerben(), ohne sich selbst zu blockieren.

lock = threading.RLock()

def reentrant_function():
    with lock:
        with lock:  # Same thread can acquire the lock again
            print("Reentrant lock example")

t = threading.Thread(target=reentrant_function)
t.start()

10. Bedingung()

Ein Bedingungsobjekt ermöglicht es Threads, auf die Erfüllung einer Bedingung zu warten.

condition = threading.Condition()

def thread_wait():
    with condition:
        condition.wait()  # Wait for the condition
        print("Condition met")

def thread_notify():
    with condition:
        condition.notify()  # Notify the waiting thread

t1 = threading.Thread(target=thread_wait)
t2 = threading.Thread(target=thread_notify)
t1.start()
t2.start()

11. Ereignis()

Ein Event-Objekt wird zur Signalisierung zwischen Threads verwendet. Ein Thread kann darauf warten, dass ein Ereignis festgelegt wird, und ein anderer Thread kann das Ereignis festlegen.

event = threading.Event()

def wait_for_event():
    event.wait()  # Wait until the event is set
    print("Event has been set")

t = threading.Thread(target=wait_for_event)
t.start()
event.set()  # Set the event to allow the thread to continue

12. Semaphor ()

Mit einem Semaphore-Objekt können Sie die Anzahl der Threads begrenzen, die gleichzeitig auf eine Ressource zugreifen können.

semaphore = threading.Semaphore(2)  # Only 2 threads can access the resource at once

def access_resource():
    with semaphore:
        print("Resource accessed")

t1 = threading.Thread(target=access_resource)
t2 = threading.Thread(target=access_resource)
t3 = threading.Thread(target=access_resource)

t1.start()
t2.start()
t3.start()

13. Timer (Intervall, Funktion)

Ein Timer-Thread führt eine Funktion nach einem angegebenen Intervall aus.

def delayed_function():
    print("Executed after delay")

timer = threading.Timer(3, delayed_function)
timer.start()  # Executes `delayed_function` after 3 seconds

14. setDaemon(True)

Daemon-Threads laufen im Hintergrund und werden automatisch beendet, wenn das Hauptprogramm beendet wird. Sie können einen Thread zu einem Daemon machen, indem Sie setDaemon(True) aufrufen oder daemon=True an den Thread-Konstruktor übergeben.

t = threading.Thread(target=print_numbers, daemon=True)
t.start()  # Daemon thread will exit when the main program ends

Abschluss

Das Threading-Modul ist ein leistungsstarkes Tool zur Handhabung der Parallelität in Python. Es bietet mehrere Klassen und Methoden zum Erstellen und Steuern von Threads und erleichtert so die parallele Ausführung von Code. Von der Verwendung grundlegender Thread-Objekte bis hin zur Verwaltung der Synchronisierung mit Lock und Semaphore ist dieses Modul für das Schreiben gleichzeitiger Python-Programme unerlässlich.