Manejo de la excepción de un hilo en el hilo de la persona que llama en Python

El subprocesamiento múltiple en Python se puede lograr mediante el uso de la biblioteca de subprocesos. Para invocar un subproceso, el subproceso que llama crea un objeto de subproceso y llama al método de inicio en él. Una vez que se llama al método de unión, inicia su ejecución y ejecuta el método de ejecución del objeto de clase. 

Para el manejo de excepciones, se utilizan bloques de prueba y excepción que detectan las excepciones generadas en el bloque de prueba y se manejan en consecuencia en el bloque de excepción.

Ejemplo:

# Importing the modules
import threading
import sys
 
# Custom Thread Class
class MyThread(threading.Thread):
    def someFunction(self):
        print("Hello World")
    def run(self):
          self.someFunction()
    def join(self):
        threading.Thread.join(self)
 
# Driver function
def main():
    t = MyThread()
    t.start()
    t.join()
 
# Driver code
if __name__ == '__main__':
    main()

Producción:

Hello World

Para capturar y manejar la excepción de un subproceso en el subproceso que llama, usamos una variable que almacena la excepción generada (si la hay) en el subproceso llamado, y cuando el subproceso llamado se une, la función de unión verifica si el valor de exc es Ninguno, si entonces no se genera ninguna excepción, de lo contrario, la excepción generada que se almacena en exc se genera nuevamente. Esto sucede en el subproceso de la persona que llama y, por lo tanto, se puede manejar en el propio subproceso de la persona que llama.

Ejemplo: el ejemplo crea un subproceso t de tipo MyThread, el método run() para el subproceso llama al método someFunction(), que genera MyException, por lo tanto, cada vez que se ejecuta el subproceso, generará una excepción. Para capturar la excepción en el subproceso que llama, mantenemos una variable separada exc, que se establece en la excepción generada cuando el subproceso llamado genera una excepción. Este exc finalmente se verifica en el método join() y si no es Ninguno, entonces join simplemente genera la misma excepción. Por lo tanto, la excepción detectada se genera en el subproceso de la persona que llama, ya que la combinación regresa en el subproceso de la persona que llama (Aquí, el subproceso principal) y, por lo tanto, se maneja de manera correspondiente.

# Importing the modules
import threading
import sys
 
# Custom Exception Class
class MyException(Exception):
    pass
 
# Custom Thread Class
class MyThread(threading.Thread):
     
  # Function that raises the custom exception
    def someFunction(self):
        name = threading.current_thread().name
        raise MyException("An error in thread "+ name)
 
    def run(self):
       
        # Variable that stores the exception, if raised by someFunction
        self.exc = None           
        try:
            self.someFunction()
        except BaseException as e:
            self.exc = e
       
    def join(self):
        threading.Thread.join(self)
        # Since join() returns in caller thread
        # we re-raise the caught exception
        # if any was caught
        if self.exc:
            raise self.exc
 
# Driver function
def main():
   
    # Create a new Thread t
    # Here Main is the caller thread
    t = MyThread()
    t.start()
     
    # Exception handled in Caller thread
    try:
        t.join()
    except Exception as e:
        print("Exception Handled in Main, Details of the Exception:", e)
 
# Driver code
if __name__ == '__main__':
    main()

Producción:

Excepción manejada en Main, detalles de la excepción: un error en el subproceso Subproceso-1