Avviso di fine del supporto: il 31 maggio 2026, AWS terminerà il supporto per AWS Panorama. Dopo il 31 maggio 2026, non potrai più accedere alla AWS Panorama console o AWS Panorama alle risorse. Per ulteriori informazioni, consulta [AWS Panorama Fine del supporto](https://docs.aws.amazon.com/panorama/latest/dev/panorama-end-of-support.html). 

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Esecuzione di più thread
<a name="applications-threading"></a>

È possibile eseguire la logica dell'applicazione su un thread di elaborazione e utilizzare altri thread per altri processi in background. Ad esempio, è possibile creare un thread che [serva il traffico HTTP per il](applications-ports.md) debug o un thread che monitora i risultati dell'inferenza e invia i dati a. AWS

Per eseguire più thread, si utilizza il [modulo threading](https://docs.python.org/3/library/threading.html) della libreria standard Python per creare un thread per ogni processo. L'esempio seguente mostra il ciclo principale dell'applicazione di esempio del server di debug, che crea un oggetto applicativo e lo utilizza per eseguire tre thread.

**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) — Ciclo principale**  

```
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.')
```

Quando tutti i thread vengono chiusi, l'applicazione si riavvia automaticamente. Il `run_cv` loop elabora le immagini provenienti dai flussi della telecamera. Se riceve un segnale di arresto, interrompe il processo di debugger, che esegue un server HTTP e non può spegnersi da solo. Ogni thread deve gestire i propri errori. Se un errore non viene rilevato e registrato, il thread si chiude silenziosamente.

**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) — Ciclo di elaborazione**  

```
    # 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")
```

I thread comunicano tramite l'oggetto dell'applicazione. `self` Per riavviare il ciclo di elaborazione dell'applicazione, il thread del debugger chiama il metodo. `stop` Questo metodo imposta un `terminate` attributo che segnala agli altri thread di chiudersi.

**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) — Metodo Stop**  

```
    # 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)
```