Exécution de plusieurs threads - AWS Panorama

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Exécution de plusieurs threads

Vous pouvez exécuter la logique de votre application sur un thread de traitement et utiliser d'autres threads pour d'autres processus en arrière-plan. Par exemple, vous pouvez créer un thread qui diffuse le trafic HTTP à des fins de débogage, ou un thread qui surveille les résultats d'inférence et envoie des données à. AWS

Pour exécuter plusieurs threads, vous utilisez le module de threading de la bibliothèque standard Python afin de créer un thread pour chaque processus. L'exemple suivant montre la boucle principale de l'exemple d'application du serveur de débogage, qui crée un objet d'application et l'utilise pour exécuter trois threads.

Exemple Packages/123456789012-debug_server-1.0/application.py — Boucle 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.')

Lorsque tous les threads sont fermés, l'application redémarre d'elle-même. La run_cv boucle traite les images issues des flux de caméras. S'il reçoit un signal d'arrêt, il arrête le processus de débogage, qui exécute un serveur HTTP et ne peut pas s'arrêter tout seul. Chaque thread doit gérer ses propres erreurs. Si aucune erreur n'est détectée et enregistrée, le thread se ferme silencieusement.

Exemple Packages/123456789012-debug_server-1.0/application.py — Boucle de traitement
    # 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")

Les threads communiquent via l'selfobjet de l'application. Pour redémarrer la boucle de traitement de l'application, le thread du débogueur appelle la stop méthode. Cette méthode définit un terminate attribut qui indique aux autres threads de s'arrêter.

Exemple Packages/123456789012-debug_server-1.0/application.py — Méthode d'arrêt
    # 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)