Python-Threading: Eine Einführung

In diesem Tutorial erfahren Sie, wie Sie die integrierte Python verwenden einfädeln -Modul zum Erkunden von Multithreading-Fähigkeiten in Python.

Beginnend mit den Grundlagen von processes and threads, you’ll learn how multithreading works in Python—while understanding the concepts of concurRenz und Parallelität. Anschließend erfahren Sie, wie Sie mithilfe der integrierten Funktion einen oder mehrere Threads in Python starten und ausführen threading Modul.

Fangen wir an.

Processes vs. Threads: Unterschiede

Was ist ein Process?

A process is jedem Instanz eines Programms, das ausgeführt werden muss.

Es kann alles sein – ein Python-Skript oder ein Web-Browsz. B. Chrome, in eine Videokonferenzanwendung integrieren. Wenn Sie das starten Task Manager auf Ihrem Gerät und navigieren Sieate zu Leistung -> CPU, Sie werden in der Lage sein, das zu sehen processEs und Threads, die derzeit auf Ihren CPU-Kernen ausgeführt werden.

Verstehenanding Processes und Threads

Internally, a process hat eine Widmungated Speicher, der den Code und die entsprechenden Daten speichert process.

A process besteht aus einem oder mehreren Themen. Ein Thread ist die kleinste Folge von Anweisungen, die das Betriebssystem ausführen kann, und stellt den Ausführungsfluss dar.

Jeder Thread hat seinen eigenen Stack und registriert sich aber nicht eine Widmungated Speicher. Alle zugehörigen Threadsated mit a process kann auf die Daten zugreifen. Daher werden Daten und Speicher von allen Threads eines a gemeinsam genutzt process.

In einer CPU mit N Kernen sind N processEs kann zum gleichen Zeitpunkt parallel ausgeführt werden. Allerdings zwei Threads des gleichen process kann niemals parallel ausgeführt werden – kann aber ausgeführt werden concurvermietet. Wir werden uns mit dem Konzept befassen concurRenz vs. Parallelität im nächsten Abschnitt.

Basierend auf dem, was wir bisher gelernt haben, fassen wir die Unterschiede zwischen a zusammen process und ein Thread.

Multithreading in Python

In Python ist das Globale Dolmetschersperre (GIL) versichert dass einziger Thread kann die Sperre erwerben und jederzeit ausgeführt werden. Alle Threads sollten diese Sperre erwerben, um ausgeführt zu werden. Dadurch wird sichergestellt, dass zu einem bestimmten Zeitpunkt nur ein einziger Thread ausgeführt werden kann, und es wird vermieden gleichzeitigneous Multithreading.

Betrachten Sie zum Beispiel zwei Threads, t1 und t2, von dem selben process. Weil Threads dieselben Daten teilen, wann t1 liest einen bestimmten Wert k, t2 kann denselben Wert ändern k. Dies kann zu Deadlocks und unerwünschten Ergebnissen führen. Aber nur einer der Threads kann die Sperre erwerben und zu einem beliebigen Zeitpunkt ausgeführt werden. Dafür sorgt auch GIL Gewindesicherheit.

Wie erreichen wir also Multithreading-Fähigkeiten in Python? Um dies zu verstehen, diskutieren wir die Konzepte von concurRenz und Parallelität.

ConcurRenz vs. Parallelität: Ein Überblick

Stellen Sie sich eine CPU mit mehr als einem Kern vor. In der Abbildung unten hat die CPU vier Kerne. Das bedeutet, dass wir zu jedem Zeitpunkt vier verschiedene Operationen parallel ausführen können.

Wenn es vier sind processes, dann jeder der processEs kann unabhängig und gleichzeitig ausgeführt werdenneoNormalerweise auf jedem der vier Kerne. Nehmen wir an, dass jeder process hat zwei Threads.

Um zu verstehen, wie Threading funktioniert, wechseln wir von Multicore zu Single-Core processoder Architektur. Wie bereits erwähnt, kann bei einer bestimmten Ausführungsinstanz nur ein einzelner Thread aktiv sein; aber die processoder der Kern kann zwischen den Threads wechseln. 

E/A-gebundene Threads warten beispielsweise häufig auf E/A-Operationen: Einlesen von Benutzereingaben, Datenbanklesevorgänge und Dateioperationen. Während dieser Wartezeit können I/O-gebundene Threads Release die Sperre, damit der andere Thread ausgeführt werden kann. Die Wartezeit kann auch eine einfache Operation wie Schlafen sein n Sekunden.

Zusammenfassend: Während Wartevorgängen gibt der Thread die Sperre frei und ermöglicht so die processoder core, um zu einem anderen Thread zu wechseln. Der frühere Thread nimmt die Ausführung wieder auf, nachdem die Wartezeit abgelaufen ist. Das process, Wobei die processoder Kernschalter zwischen den Threads concurvermietet, erleichtertates Multithreading. ✅

Wenn Sie umsetzen möchten process-Level-Parallelität in Ihrer Anwendung, erwägen Sie die Verwendung MultiprocessIng. stattdessen.

Python-Threading-Modul: Erste Schritte

Python wird mit a threading -Modul, das Sie in das Python-Skript importieren können.

import threading

Create Ein Thread-Objekt in Python, das Sie verwenden können Thread Konstrukteur: threading.Thread(...). Dies ist die generische Syntax, die für die meisten Threading-Implementierungen ausreicht:

threading.Thread(target=...,args=...)

Hier

• target ist das Schlüsselwortargument, das eine aufrufbare Python-Datei bezeichnet
• args ist das Argumenttupel, das das Ziel aufnimmt.

Sie benötigen Python 3.x, um die Codebeispiele in diesem Tutorial auszuführen. Laden Sie den Code herunter und folge mit.

Threads in Python definieren und ausführen

Lassen Sie uns einen Thread definieren, der eine Zielfunktion ausführt.

Die Zielfunktion ist some_func.

import threading
import time

def some_func():
    print("Running some_func...")
    time.sleep(2)
    print("Finished running some_func.")

thread1 = threading.Thread(target=some_func)
thread1.start()
print(threading.active_count())

Lassen Sie uns analysieren, was das obige Code-Snippet tut:

• Es importiert die threading und dem time Module.
• Die Funktion some_func hat descriptIVE print() stateFunktionen und beinhaltet einen Schlafvorgang für zwei Sekunden: time.sleep(n) bewirkt, dass die Funktion schläft n Sekunden.
• Als nächstes definieren wir einen Thread thread_1 mit dem Ziel als some_func. threading.Thread(target=...) CREatesa Thread-Objekt.
• Hinweis: Geben Sie den Namen der Funktion und keinen Funktionsaufruf an; verwenden some_func und nicht some_func().
• Erstellen eines Thread-Objekts nicht Starten Sie einen Thread; Aufruf der start() Methode auf dem Thread-Objekt tut.
• Um die Anzahl der aktiven Threads zu erhalten, verwenden wir die active_count() Funktion.

Das Python-Skript wird im Hauptthread ausgeführt, und wir erstellen einen weiteren Thread (thread1), um die Funktion auszuführen some_func; Die Anzahl der aktiven Threads beträgt also zwei, wie in der Ausgabe zu sehen ist:

# Output
Running some_func...
2
Finished running some_func.

Wenn wir uns die Ausgabe genauer ansehen, sehen wir das beim Start thread1, der erste Druck statement läuft. Aber während des Schlafbetriebs wird die processoder wechselt zum Hauptthread und gibt die Anzahl der aktiven Threads aus – ohne darauf zu warten thread1 Ausführung zu beenden.

Warten, bis Threads die Ausführung beenden

Wenn Sie möchten, thread1 Um die Ausführung zu beenden, können Sie die aufrufen join() Methode darauf nach dem Starten des Threads. Dies wird warten thread1 um die Ausführung zu beenden, ohne zum Hauptthread zu wechseln.

import threading
import time

def some_func():
    print("Running some_func...")
    time.sleep(2)
    print("Finished running some_func.")

thread1 = threading.Thread(target=some_func)
thread1.start()
thread1.join()
print(threading.active_count())

Jetzt, thread1 die Ausführung beendet hat, bevor wir die Anzahl der aktiven Threads ausgeben. Es läuft also nur der Haupt-Thread, was bedeutet, dass die Anzahl der aktiven Threads eins ist. ✅

# Output
Running some_func...
Finished running some_func.
1

So führen Sie mehrere Threads in Python aus

Als nächstes erstellen wirate zwei Threads, um zwei verschiedene Funktionen auszuführen. 

Hier count_down ist eine Funktion, die eine Zahl als Argument annimmt und von dieser Zahl bis herunterzählt zero.

def count_down(n):
    for i in range(n,-1,-1):
        print(i)

Wir definieren den count_up, eine weitere Python-Funktion, die zählt zero bis zu einer bestimmten Anzahl.

def count_up(n):
    for i in range(n+1):
        print(i)

📑 Bei Verwendung der range() Funktion mit der Syntax range(start, stop, step), der Endpunkt stop ist standardmäßig ausgeschlossen.

– Um von einer bestimmten Zahl bis herunterzuzählen zero, können Sie ein Negativ verwenden step Wert von -1 und setzen Sie die stop Wert auf -1, damit zero ist im Lieferumfang enthalten.

– Ebenso bis zu zählen n, müssen Sie das einstellen stop Wert zu n + 1. Da die Standardwerte von start und step 0 bzw. 1 sind, können Sie verwenden range(n + 1) um die Folge 0 bis n zu erhalten.

Als nächstes definieren wir zwei Threads, thread1 und thread2 um die Funktionen auszuführen count_down und count_up, beziehungsweise. Wir fügen hinzu print statemente und sleep Operationen für beide Funktionen.

Beachten Sie beim Erstellen der Thread-Objekte, dass die Argumente für die Zielfunktion als Tupel angegeben werden sollten – für die args Parameter. Da beide Funktionen (count_down und count_up) ein Argument aufnehmen, müssen Sie explizit ein Komma nach dem Wert einfügen. Dadurch wird sichergestellt, dass das Argument weiterhin als Tupel übergeben wird, da die nachfolgenden Elemente als abgeleitet werden None.

import threading
import time

def count_down(n):
    for i in range(n,-1,-1):
        print("Running thread1....")
        print(i)
        time.sleep(1)


def count_up(n):
    for i in range(n+1):
        print("Running thread2...")
        print(i)
        time.sleep(1)

thread1 = threading.Thread(target=count_down,args=(10,))
thread2 = threading.Thread(target=count_up,args=(5,))
thread1.start()
thread2.start()

In der Ausgabe:

• Die Funktion count_up läuft auf thread2 und zählt bei 5 beginnend bis 0. 
• Der count_down Funktion läuft weiter thread1 zählt von 10 auf 0 herunter.

# Output
Running thread1....
10
Running thread2...
0
Running thread1....
9
Running thread2...
1
Running thread1....
8
Running thread2...
2
Running thread1....
7
Running thread2...
3
Running thread1....
6
Running thread2...
4
Running thread1....
5
Running thread2...
5
Running thread1....
4
Running thread1....
3
Running thread1....
2
Running thread1....
1
Running thread1....
0

Sie können sehen, dass thread1 und thread2 alternativ ausführen, da beide eine Warteoperation (sleep) beinhalten. Einmal die count_up Funktion hat das Zählen bis 5 beendet, thread2 ist nicht mehr aktiv. Wir erhalten also nur die entsprechende Ausgabe thread1.

Summieren

In diesem Lernprogramm haben Sie gelernt, wie Sie das integrierte Threading-Modul von Python verwenden, um Multithreading zu implementieren. Hier ist eine Zusammenfassung der wichtigsten Takeaways:

• Der Gewinde Der Konstruktor kann zum Erstellen verwendet werdenate ein Thread-Objekt. Benutzen Threading.Thread(Ziel= ,args=( )) CREatesa Thread, der das ausführt Ziel aufrufbar mit den in angegebenen Argumenten args.
• Das Python-Programm läuft auf einem Haupt-Thread, also den Thread-Objekten, die Sie erstellenate sind zusätzliche Threads. Du kannst anrufen active_count() Die Funktion gibt die Anzahl der aktiven Threads zu jeder Instanz zurück.
• Sie können einen Thread mit starten Start() -Methode für das Thread-Objekt und warten Sie, bis die Ausführung mit der beendet ist beitreten() Methode.

Sie können nur dann Code zusätzliche Beispiele durch Optimieren der Wartezeiten, Versuchen einer anderen E/A-Operation und mehr. Achten Sie darauf, Multithreading in Ihrem nächsten zu implementieren Python-Projekte. Viel Spaß beim Programmieren!🎉