Python-Threading-Warteschlange

1. Threads in Python
2. Begrenzen Sie Threads mit einer Warteschlange in Python

In diesem Tutorial wird die Begrenzung der Anzahl aktiver Threads in Python erläutert.

Threads in Python

Threading in Python ermöglicht die gleichzeitige Ausführung mehrerer Ausführungs-Threads in einem einzigen Prozess. Jeder Thread wird unabhängig von den anderen ausgeführt, was eine gleichzeitige Ausführung und verbesserte Leistung ermöglicht.

Threading ist besonders nützlich für die Ausführung von Aufgaben, die E/A-gebunden sind oder eine lange Ausführungszeit haben, da es anderen Threads ermöglicht, die Ausführung fortzusetzen, während ein Thread blockiert ist.

Python bietet ein eingebautes threading-Modul zum Erstellen und Verwalten von Threads. Die Klasse Thread innerhalb des Moduls kann verwendet werden, um einen neuen Ausführungsthread zu erstellen, und die Methode start() kann verwendet werden, um die Ausführung des Threads zu beginnen.

Die Methode join() kann verwendet werden, um darauf zu warten, dass ein Thread seine Ausführung beendet.

Python stellt neben dem Modul threading auch das Modul concurrent.futures zur Verfügung, das eine übergeordnete Schnittstelle für die asynchrone Ausführung von Callables bereitstellt. Dieses Modul stellt die Klasse ThreadPoolExecutor bereit, mit der ein Pool von Worker-Threads erstellt werden kann, mit denen Callables parallel ausgeführt werden können.

Threading kann ein leistungsfähiges Werkzeug zur Verbesserung der Leistung von Python-Programmen sein, sollte jedoch mit Vorsicht verwendet werden, da es auch zu Komplexität und dem Potenzial für Race Conditions und andere Synchronisierungsprobleme führen kann.

Begrenzen Sie Threads mit einer Warteschlange in Python

Die Klasse Queue in Python bietet eine Thread-sichere und FIFO-Datenstruktur (first-in, first-out) zum Speichern von Elementen, die von mehreren Threads verarbeitet werden müssen. Es kann verwendet werden, um den Datenfluss zwischen Threads zu koordinieren und die Anzahl der Threads zu begrenzen, die gleichzeitig ausgeführt werden können.

Wenn wir die Anzahl der Threads begrenzen möchten, die gleichzeitig mit einer Warteschlange ausgeführt werden können, können wir den Parameter maxsize innerhalb der Klasse Queue verwenden. Hier ist ein Beispiel für die Verwendung einer Warteschlange, um die Gesamtzahl der Threads zu begrenzen.

import threading
import queue
from queue import Queue
from threading import Thread


def function_to_be_executed():
    print(f"Thread {threading.get_ident()} is working")
    return


q = Queue(maxsize=3)

for i in range(10):
    try:
        thread = Thread(target=function_to_be_executed)
        q.put(thread, block=False)
    except queue.Full:
        q.get().join(timeout=0)
        thread = Thread(target=function_to_be_executed)
        q.put(thread, block=False)
    thread = q.get()
    thread.start()
while not q.empty():
    thread = q.get()
    thread.join(timeout=1)

Ausgang:

Thread 140368505984768 is working
Thread 140368497592064 is working
Thread 140368505984768 is working
Thread 140368497592064 is working
Thread 140368505984768 is working
Thread 140368497592064 is working
Thread 140368514377472 is working
Thread 140368497592064 is working
Thread 140368497592064 is working
Thread 140368497592064 is working

Der obige Code erstellt ein Queue-Objekt mit einer maximalen Größe von 3, was bedeutet, dass sich zu einem bestimmten Zeitpunkt nur 3 Threads in der Warteschlange befinden können. Dann werden 10 Threads erstellt und mit der Methode put() der Warteschlange hinzugefügt.

Die while-Schleife startet die Threads in der Warteschlange nacheinander, und die join()-Methode wird verwendet, um zu warten, bis alle Threads beendet sind.

In diesem Beispiel laufen nur 3 Threads gleichzeitig; Der Rest wartet in der Warteschlange, bis er die Möglichkeit hat zu rennen. Wir können die maximale Größe der Warteschlange und die Anzahl der Threads an unsere eigenen Bedürfnisse anpassen.