Hinweis zum Ende des Supports: Am 31. Mai 2026 AWS endet der Support für AWS Panorama. Nach dem 31. Mai 2026 können Sie nicht mehr auf die AWS Panorama Konsole oder AWS Panorama die Ressourcen zugreifen. Weitere Informationen finden Sie unter [AWS Panorama Ende des Supports](https://docs.aws.amazon.com/panorama/latest/dev/panorama-end-of-support.html). 

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Mehrere Threads ausführen
<a name="applications-threading"></a>

Sie können Ihre Anwendungslogik auf einem Verarbeitungsthread ausführen und andere Threads für andere Hintergrundprozesse verwenden. Sie können beispielsweise einen Thread erstellen, der [HTTP-Verkehr zum Debuggen bereitstellt](applications-ports.md), oder einen Thread, der Inferenzergebnisse überwacht und Daten an diese sendet. AWS

Um mehrere Threads auszuführen, verwenden Sie das [Threading-Modul](https://docs.python.org/3/library/threading.html) aus der Python-Standardbibliothek, um für jeden Prozess einen Thread zu erstellen. Das folgende Beispiel zeigt die Hauptschleife der Beispielanwendung Debug-Server, die ein Anwendungsobjekt erstellt und es zum Ausführen von drei Threads verwendet.

**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) — Hauptschleife**  

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

Wenn alle Threads beendet sind, startet sich die Anwendung selbst neu. Die `run_cv` Schleife verarbeitet Bilder aus Kamerastreams. Wenn sie ein Signal zum Stoppen empfängt, beendet sie den Debugger-Prozess, der auf einem HTTP-Server läuft und sich nicht selbst herunterfahren kann. Jeder Thread muss seine eigenen Fehler behandeln. Wenn ein Fehler nicht abgefangen und protokolliert wird, wird der Thread im Hintergrund beendet.

**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) — Verarbeitungsschleife**  

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

Threads kommunizieren über das Objekt der Anwendung. `self` Um die Verarbeitungsschleife der Anwendung neu zu starten, ruft der Debugger-Thread die `stop` Methode auf. Diese Methode setzt ein `terminate` Attribut, das den anderen Threads signalisiert, dass sie heruntergefahren werden sollen.

**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) — Stopp-Methode**  

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