Können Threads in Python abrupt beendet werden, und wenn ja, welche Einschränkungen gibt es?

Gibt es eine Möglichkeit, einen Thread abrupt zu beenden?

Das Beenden eines laufenden Threads, ohne sich auf Flags oder Semaphoren zu verlassen, wird in Python im Allgemeinen nicht empfohlen aufgrund möglicher Konsequenzen. In bestimmten Szenarien, wie unten beschrieben, kann jedoch das erzwungene Beenden eines Threads erforderlich sein.

Unkontrollierte Thread-Beendigung

Das abrupte Beenden eines Threads kann zu Problemen führen. wie zum Beispiel:

• Halten kritischer Ressourcen, die ordnungsgemäß bereinigt werden müssen
• Erstellen mehrerer Threads, die ebenfalls beendet werden müssen

Im Idealfall sollten Threads so gestaltet sein, dass sie beim Empfang eines Beendigungsanforderungssignals ordnungsgemäß beendet werden. Dies kann durch ein gemeinsames Flag erreicht werden, das der Thread regelmäßig überprüft, um festzustellen, ob er beendet werden soll.

Beispiel:

import threading

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

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

    def stopped(self):
        return self._stop_event.is_set()

Erzwungene Thread-Beendigung

In bestimmten Szenarien, beispielsweise beim Umgang mit externen Bibliotheken, kann es notwendig sein, einen Thread zwangsweise zu beenden. Dies kann mit dem folgenden Code erreicht werden, der das Auslösen einer Ausnahme in einem bestimmten Thread ermöglicht:

def _async_raise(tid, exctype):
    if not inspect.isclass(exctype):
        raise TypeError("Only types can be raised (not instances)")
    res = ctypes.pythonapi.PyThreadState_SetAsyncExc(ctypes.c_long(tid),
                                                     ctypes.py_object(exctype))
    if res == 0:
        raise ValueError("invalid thread id")
    elif res != 1:
        ctypes.pythonapi.PyThreadState_SetAsyncExc(ctypes.c_long(tid), None)
        raise SystemError("PyThreadState_SetAsyncExc failed")

class ThreadWithExc(threading.Thread):
    def _get_my_tid(self):
        if not self.is_alive():
            raise threading.ThreadError("the thread is not active")

        if hasattr(self, "_thread_id"):
            return self._thread_id

        for tid, tobj in threading._active.items():
            if tobj is self:
                self._thread_id = tid
                return tid

        raise AssertionError("could not determine the thread's id")

    def raise_exc(self, exctype):
        _async_raise( self._get_my_tid(), exctype )

Einschränkungen der erzwungenen Thread-Beendigung

Diese Methode hat Einschränkungen und funktioniert möglicherweise nicht, wenn der Thread Code außerhalb des Python-Interpreters ausführt. Für eine zuverlässige Bereinigung wird empfohlen, dass der Thread eine bestimmte Ausnahme abfängt und entsprechende Aktionen ausführt.

Das obige ist der detaillierte Inhalt vonKönnen Threads in Python abrupt beendet werden, und wenn ja, welche Einschränkungen gibt es?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!