Python Thread beenden

Vaibhhav Khetarpal 30 Januar 2023
  1. Auslösen von Ausnahmen in einem Thread zum Beenden eines Threads in Python
  2. Verwendung von trace zum Beenden eines Threads in Python
  3. Erstellen/Zurücksetzen eines Stop-Flags zum Beenden eines Threads in Python
  4. Verwenden Sie das multiprocessing-Modul, um einen Thread in Python zu beenden
  5. Den gegebenen Thread als Daemon-Thread festlegen, um einen Thread in Python zu beenden
  6. Verwenden Sie die versteckte _stop()-Funktion, um einen Thread in Python zu beenden
Python Thread beenden

Obwohl es unter Programmierern als schlechte Programmierpraxis bezeichnet wird, kann es dennoch notwendig sein, manchmal einen Thread in Python zu beenden. Dieses Tutorial demonstriert die verschiedenen Mittel, mit denen wir einen Thread in Python beenden können.

Der Nachteil, einer Bedrohung abrupt ein Ende zu bereiten, kann dazu führen, dass eine Aufgabe im Hintergrund offen bleibt und zu einem Problem führt.

Darüber hinaus bietet Python keine Möglichkeit, einen Thread in Python direkt zu beenden, was bedeutet, Schlupflöcher und indirekte Wege zu finden, um diese wesentliche Aufgabe zu implementieren.

Jetzt werden wir uns auf die verschiedenen Möglichkeiten konzentrieren und erklären, wie wir einen Thread in Python beenden können.

Auslösen von Ausnahmen in einem Thread zum Beenden eines Threads in Python

Diese Methode verwendet die Funktion PyThreadState_SetAsyncExc(), die asynchron eine Ausnahme im angegebenen Thread auslöst.

Der folgende Code löst eine Ausnahme in einem Thread aus, um einen Thread in Python zu beenden.

import threading
import ctypes
import time


class twe(threading.Thread):
    def __init__(self, name):
        threading.Thread.__init__(self)
        self.name = name

    def run(self):
        try:
            while True:
                print("running " + self.name)
        finally:
            print("ended")

    def get_id(self):
        if hasattr(self, "_thread_id"):
            return self._thread_id
        for id, thread in threading._active.items():
            if thread is self:
                return id

    def raise_exception(self):
        thread_id = self.get_id()
        resu = ctypes.pythonapi.PyThreadState_SetAsyncExc(
            thread_id, ctypes.py_object(SystemExit)
        )
        if resu > 1:
            ctypes.pythonapi.PyThreadState_SetAsyncExc(thread_id, 0)
            print("Failure in raising exception")


x = twe("Thread A")
x.start()
time.sleep(2)
x.raise_exception()
x.join()

Wenn der Code ausgeführt wird und sobald er eine Ausnahme auslöst, wird die run()-Funktion beendet, da die Programmsteuerung den try-Block des Exception-Handlers umgehen kann.

Die Funktion join() wird dann aufgerufen, um den letzten Schlag zu versetzen und die Funktion run() zu töten.

Verwendung von trace zum Beenden eines Threads in Python

Eine andere Möglichkeit, dieselbe Aufgabe zum Beenden eines Threads in Python zu implementieren, besteht darin, einen trace im angegebenen Thread zu installieren und die Ausführung des Threads zu ändern.

Der folgende Code verwendet Ablaufverfolgungen, um einen Thread in Python zu beenden.

import sys
import time
import threading
import trace


class KThread(threading.Thread):
    def __init__(self, *args, **keywords):
        threading.Thread.__init__(self, *args, **keywords)
        self.killed = False

    def start(self):
        self.__run_backup = self.run
        self.run = self.__run
        threading.Thread.start(self)

    def __run(self):
        sys.settrace(self.globaltrace)
        self.__run_backup()
        self.run = self.__run_backup

    def globaltrace(self, frame, why, arg):
        if why == "call":
            return self.localtrace
        else:
            return None

    def localtrace(self, frame, why, arg):
        if self.killed:
            if why == "line":
                raise SystemExit()
        return self.localtrace

    def kill(self):
        self.killed = True


def exfu():
    print("The function begins")
    for i in range(1, 100):
        print(i)
        time.sleep(0.2)
    print("The function ends")


x = KThread(target=exfu)
x.start()
time.sleep(1)
x.kill()

Der obige Code liefert die folgende Ausgabe.

The function begins
1
2
3
4
5

Hier verwenden wir die Klasse KThread, eine Teilmenge der ursprünglichen Klasse threading.Thread. Die Klasse KThread sorgt dafür, dass die Funktion kill() im Code implementiert wird.

Erstellen/Zurücksetzen eines Stop-Flags zum Beenden eines Threads in Python

Im Code kann ein Stopp-Flag deklariert werden, wodurch die Ausführung des Threads gestoppt wird, wenn der Thread darauf stößt.

Der folgende Code erstellt ein Stopp-Flag, um einen Thread in Python zu beenden.

import threading
import time


def frun():
    while True:
        print("thread running")
        global stop_threads
        if stop_threads:
            break


stop_threads = False
x = threading.Thread(target=frun)
x.start()
time.sleep(1)
stop_threads = True
x.join()
print("killed the thread.")

Verwenden Sie das multiprocessing-Modul, um einen Thread in Python zu beenden

Das multiprocessing-Modul ermöglicht das Spawnen von Prozessen, wobei die Methode und Funktionsweise ähnlich dem threading-Modul ist, da beide eine API verwenden.

Das terminate() kann einen bestimmten Prozess beenden, was relativ sicherer und weniger komplex ist, als einen Thread selbst zu beenden.

Der folgende Code verwendet das multiprocessing-Modul, um einen Thread in Python zu beenden.

import multiprocessing
import time


def cp():
    while True:
        for i in range(20):
            print("Process: ", i)
            time.sleep(0.05)


x = multiprocessing.Process(target=cp)
x.start()
time.sleep(0.5)
x.terminate()
print("Terminated the child process")

Den gegebenen Thread als Daemon-Thread festlegen, um einen Thread in Python zu beenden

Daemon-Threads sind Threads, die automatisch beendet werden, wenn das Hauptprogramm beendet wird. Wir können einen bestimmten Thread als Daemon-Thread festlegen, um den bestimmten Thread in Python zu beenden.

Der folgende Code legt den angegebenen Thread als Daemon-Thread fest, um einen Thread in Python zu beenden.

import threading
import time
import sys


def exfu():
    while True:
        time.sleep(0.5)
        print("Thread alive, but it will die on program termination")


x = threading.Thread(target=exfu)
x.daemon = True
x.start()
time.sleep(2)
sys.exit()

Verwenden Sie die versteckte _stop()-Funktion, um einen Thread in Python zu beenden

Obwohl nicht dokumentiert, kann eine versteckte _stop()-Funktion die Aufgabe implementieren, einen Thread in Python zu beenden.

Der folgende Code verwendet die versteckte Funktion _stop(), um einen Thread in Python zu beenden.

import time
import threading


class th1(threading.Thread):
    def __init__(self, *args, **kwargs):
        super(th1, self).__init__(*args, **kwargs)
        self._stop = threading.Event()

    def stop(self):
        self._stop.set()

    def stopped(self):
        return self._stop.isSet()

    def run(self):
        while True:
            if self.stopped():
                return
            print("Hello, world!")
            time.sleep(1)


x = th1()
x.start()
time.sleep(5)
x.stop()
x.join()
Vaibhhav Khetarpal avatar Vaibhhav Khetarpal avatar

Vaibhhav is an IT professional who has a strong-hold in Python programming and various projects under his belt. He has an eagerness to discover new things and is a quick learner.

LinkedIn

Verwandter Artikel - Python Thread