Python Thread beenden
- Auslösen von Ausnahmen in einem Thread zum Beenden eines Threads in Python
-
Verwendung von
trace
zum Beenden eines Threads in Python - Erstellen/Zurücksetzen eines Stop-Flags zum Beenden eines Threads in Python
-
Verwenden Sie das
multiprocessing
-Modul, um einen Thread in Python zu beenden - Den gegebenen Thread als Daemon-Thread festlegen, um einen Thread in Python zu beenden
-
Verwenden Sie die versteckte
_stop()
-Funktion, um einen Thread in Python zu 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 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