Wie fängt man Ausnahmen ab, die in untergeordneten Threads in Python ausgelöst werden?

Abfangen einer Thread-Ausnahme im Aufrufer-Thread

In Python stellt die Multithread-Programmierung Herausforderungen bei der Behandlung von Ausnahmen dar, die in untergeordneten Threads auftreten. Wenn Ausnahmen in einem untergeordneten Thread auftreten, bleiben sie auf diesen Thread beschränkt, was es für den Aufrufer-Thread schwierig macht, sie zu erfassen und zu verarbeiten.

Kernproblem und Begründung

Das Hauptproblem liegt in der Unmittelbarkeit der Methode thread_obj.start(). Diese Methode initiiert die Ausführung des untergeordneten Threads in seinem eigenen Kontext und Stapel. Folglich werden alle Ausnahmen, die innerhalb des untergeordneten Threads auftreten, nicht an den Aufrufer-Thread zurückgegeben.

Überwindung des Problems

Um dieses Problem anzugehen, besteht eine wirksame Technik darin, Folgendes zu verwenden: Nachrichtenübermittlung. Bei diesem Ansatz wird ein Kommunikationskanal zwischen dem untergeordneten Thread und dem Aufrufer-Thread eingerichtet, der es dem untergeordneten Thread ermöglicht, Ausnahmeinformationen an seinen übergeordneten Thread zu übermitteln.

Implementierung

Unten finden Sie eine Beispiel, das zeigt, wie Ausnahmen von untergeordneten Threads erfasst und im Aufrufer angezeigt werden Thread:

import sys
import threading
import queue

class ExcThread(threading.Thread):

    def __init__(self, bucket):
        threading.Thread.__init__(self)
        self.bucket = bucket

    def run(self):
        try:
            raise Exception('An error occured here.')
        except Exception:
            self.bucket.put(sys.exc_info())


def main():
    bucket = queue.Queue()
    thread_obj = ExcThread(bucket)
    thread_obj.start()

    while True:
        try:
            exc = bucket.get(block=False)
        except queue.Empty:
            pass
        else:
            exc_type, exc_obj, exc_trace = exc
            # deal with the exception
            print exc_type, exc_obj
            print exc_trace

        thread_obj.join(0.1)
        if thread_obj.isAlive():
            continue
        else:
            break


if __name__ == '__main__':
    main()

Erklärung

In diesem Beispiel fungiert die ExcThread-Klasse als untergeordneter Thread, der für die Generierung einer Ausnahme verantwortlich ist. Die Funktion main() dient als Aufrufer-Thread. Ein Kommunikationskanal wird mithilfe des queue.Queue()-Objekts (im Code Bucket genannt) eingerichtet.

Innerhalb der run()-Methode des ExcThread wird jede auftretende Ausnahme in den Bucket gestellt. Der Aufrufthread überprüft den Bucket kontinuierlich in einer Schleife. Wenn eine Ausnahme im Bucket verfügbar ist, wird sie abgerufen und die Details der Ausnahme (Typ, Objekt und Traceback) werden ausgedruckt.

Dieser Ansatz überbrückt effektiv die Kommunikationslücke zwischen dem untergeordneten Thread und dem Aufrufer-Thread , wodurch Letzteres in der Lage ist, in Ersterem generierte Ausnahmen abzufangen und zu behandeln.

Das obige ist der detaillierte Inhalt vonWie fängt man Ausnahmen ab, die in untergeordneten Threads in Python ausgelöst werden?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!