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:
Python3
# 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.
Python3
# 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
Publicación traducida automáticamente
Artículo escrito por suchetaggarwal4 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA