thread - futures result python

Python: Espera en todos los futuros de `concurrent.futures.ThreadPoolExecutor`

Question

He asignado concurrent.futures.ThreadPoolExecutor un montón de tareas, y quiero esperar hasta que se hayan completado antes de continuar con el flujo. ¿Cómo puedo hacer eso, sin tener que guardar todos los futuros y llamar en wait ? (Quiero una acción sobre el ejecutor.)

Answer 1

La respuesta de Bakuriu es correcta. Sólo para extender un poco. Como todos sabemos, un administrador de contexto tiene el método __enter__ y __exit__ . Aquí es cómo se define la class Executor ( clase base ThreadPoolExecutor )

class Executor(object):

    # other methods

    def shutdown(self, wait=True):
        """Clean-up the resources associated with the Executor.

        It is safe to call this method several times. Otherwise, no other
        methods can be called after this one.

        Args:
            wait: If True then shutdown will not return until all running
                futures have finished executing and the resources used by the
                executor have been reclaimed.
        """
        pass

    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.shutdown(wait=True)
        return False

Y es ThreadPoolExecutor que realmente define el método de shutdown

class ThreadPoolExecutor(_base.Executor):
    def shutdown(self, wait=True):
        with self._shutdown_lock:
            self._shutdown = True
            self._work_queue.put(None)
        if wait:
            for t in self._threads:
                t.join()

Answer 2

Simplemente llame a Executor.shutdown :

shutdown(wait=True)

Indique al ejecutor que debe liberar todos los recursos que esté utilizando cuando se hayan ejecutado los futuros pendientes . Las llamadas a Executor.submit() y Executor.map() realizadas después del cierre generarán RuntimeError .

Si la espera es True , este método no volverá hasta que todos los futuros pendientes se hayan ejecutado y los recursos asociados con el ejecutor hayan sido liberados.

Sin embargo, si mantiene un registro de sus futuros en una lista, puede evitar apagar el ejecutor para utilizarlo en el futuro utilizando la función futures.wait() :

concurrent.futures.wait(fs, timeout=None, return_when=ALL_COMPLETED)

Espere a que se completen las instancias Future (posiblemente creadas por diferentes instancias de Executor ) dadas por fs . Devuelve un conjunto de 2 tuplas de conjuntos. El primer conjunto, con el nombre hecho, contiene los futuros que se completaron (terminaron o se cancelaron) antes de que se completara la espera. El segundo conjunto, llamado not_done, contiene futuros no completados.

tenga en cuenta que si no proporciona un timeout espera, espera hasta que se hayan completado todos los futuros.

También puedes usar futures.as_completed() lugar, sin embargo deberías iterar sobre él.