Execução de vários threads

Você pode executar a lógica da aplicação em um thread de processamento e usar outros thread para outros processos em segundo plano. Por exemplo, você pode criar um thread que veicule tráfego HTTP para depuração ou um thread que monitore os resultados da inferência e envie dados para a AWS.

Para executar vários threads, use o módulo de thread da biblioteca padrão do Python para criar um thread para cada processo. O exemplo a seguir mostra o loop principal da aplicação de exemplo do servidor de depuração, que cria um objeto de aplicação e o usa para executar três threads.

exemplo packages/123456789012-DEBUG_SERVER-1.0/application.py: loop 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.')

Quando todos os threads são encerrados, a aplicação se reinicia sozinha. O loop run_cv processa imagens de streams de câmera. Se ele receber um sinal para parar, ele desliga o processo do depurador, que executa um servidor HTTP e não consegue se desligar sozinho. Cada thread deve lidar com seus próprios erros. Se um erro não for detectado e registrado em log, o thread será encerrado silenciosamente.

exemplo packages/123456789012-DEBUG_SERVER-1.0/application.py: Loop de processamento

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

Os threads se comunicam por meio do objeto self da aplicação. Para reiniciar o loop de processamento da aplicação, o thread do depurador chama o método stop. Esse método define um atributo terminate que sinaliza que os outros threads sejam encerrados.

exemplo 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)