Aviso de fin de soporte: el 31 de mayo de 2026, AWS finalizará el soporte para AWS Panorama. Después del 31 de mayo de 2026, ya no podrás acceder a la AWS Panorama consola ni a AWS Panorama los recursos. Para obtener más información, consulta [AWS Panorama el fin del soporte](https://docs.aws.amazon.com/panorama/latest/dev/panorama-end-of-support.html). 

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Ejecutar múltiples subprocesos
<a name="applications-threading"></a>

Puede ejecutar la lógica de la aplicación en un subproceso de procesamiento y utilizar otros subprocesos para otros procesos en segundo plano. Por ejemplo, puede crear un hilo que [sirva al tráfico HTTP](applications-ports.md) para la depuración o un hilo que supervise los resultados de las inferencias y envíe datos a. AWS

Para ejecutar varios subprocesos, utilice el [módulo de subprocesos](https://docs.python.org/3/library/threading.html) de la biblioteca estándar de Python para crear un subproceso para cada proceso. El siguiente ejemplo muestra el bucle principal de la aplicación de muestra del servidor de depuración, que crea un objeto de aplicación y lo utiliza para ejecutar tres subprocesos.

**Example [packages/123456789012-DEBUG\$1SERVER-1.0/application.py](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/debug-server/packages/123456789012-DEBUG_SERVER-1.0/application.py): bucle principal**  

```
def main():
    panorama = panoramasdk.node()
    while True:
        try:
            # Instantiate application
            logger.info('INITIALIZING APPLICATION')
            app = Application(panorama)
            # Create threads for stream processing, debugger, and client
            app.run_thread = threading.Thread(target=app.run_cv)
            app.server_thread = threading.Thread(target=app.run_debugger)
            app.client_thread = threading.Thread(target=app.run_client)
            # Start threads
            logger.info('RUNNING APPLICATION')
            app.run_thread.start()
            logger.info('RUNNING SERVER')
            app.server_thread.start()
            logger.info('RUNNING CLIENT')
            app.client_thread.start()
            # Wait for threads to exit
            app.run_thread.join()
            app.server_thread.join()
            app.client_thread.join()
            logger.info('RESTARTING APPLICATION')
        except:
            logger.exception('Exception during processing loop.')
```

Cuando se cierran todos los subprocesos, la aplicación se reinicia automáticamente. El bucle `run_cv` procesa las imágenes de las transmisiones de la cámara. Si recibe una señal para detenerse, cierra el proceso de depuración, lo cual ejecuta un servidor HTTP y no puede apagarse solo. Cada subproceso debe gestionar sus propios errores. Si no se detecta ni registra un error, el subproceso se cierra silenciosamente.

**Example [packages/123456789012-DEBUG\$1SERVER-1.0/application.py](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/debug-server/packages/123456789012-DEBUG_SERVER-1.0/application.py): bucle de procesamiento**  

```
    # Processing loop
    def run_cv(self):
        """Run computer vision workflow in a loop."""
        logger.info("PROCESSING STREAMS")
        while not self.terminate:
            try:
                self.process_streams()
                # turn off debug logging after 15 loops
                if logger.getEffectiveLevel() == logging.DEBUG and self.frame_num == 15:
                    logger.setLevel(logging.INFO)
            except:
                logger.exception('Exception on processing thread.')
        # Stop signal received
        logger.info("SHUTTING DOWN SERVER")
        self.server.shutdown()
        self.server.server_close()
        logger.info("EXITING RUN THREAD")
```

Los subprocesos se comunican a través del objeto `self` de la aplicación. Para reiniciar el ciclo de procesamiento de la aplicación, el subproceso del depurador llama al método `stop`. Este método establece un atributo de `terminate` que indica a los demás subprocesos que se cierren.

**Example [packages/123456789012-DEBUG\$1SERVER-1.0/application.py](https://github.com/awsdocs/aws-panorama-developer-guide/blob/main/sample-apps/debug-server/packages/123456789012-DEBUG_SERVER-1.0/application.py): método de parada**  

```
    # Interrupt processing loop
    def stop(self):
        """Signal application to stop processing."""
        logger.info("STOPPING APPLICATION")
        # Signal processes to stop
        self.terminate = True
    # HTTP debug server
    def run_debugger(self):
        """Process debug commands from local network."""
        class ServerHandler(SimpleHTTPRequestHandler):
            # Store reference to application
            application = self
            # Get status
            def do_GET(self):
                """Process GET requests."""
                logger.info('Get request to {}'.format(self.path))
                if self.path == "/status":
                    self.send_200('OK')
                else:
                    self.send_error(400)
            # Restart application
            def do_POST(self):
                """Process POST requests."""
                logger.info('Post request to {}'.format(self.path))
                if self.path == '/restart':
                    self.send_200('OK')
                    ServerHandler.application.stop()
                else:
                    self.send_error(400)
```