Ejecutar múltiples 'cat | Comandos zgrep' simultáneamente

En este script de Python, varios 'cat | Los comandos zgrep' se ejecutan secuencialmente en un servidor remoto y sus resultados se recopilan individualmente para su procesamiento. Sin embargo, para mejorar la eficiencia, nuestro objetivo es ejecutar estos comandos en paralelo.

Usar subprocesos sin subprocesos

Al contrario de usar multiprocesamiento o subprocesos, puede ejecutar subprocesos en paralelo utilizando el siguiente enfoque:

#!/usr/bin/env python
from subprocess import Popen

# create a list of subprocesses
processes = [Popen("echo {i:d}; sleep 2; echo {i:d}".format(i=i), shell=True) for i in range(5)]

# collect statuses of subprocesses
exitcodes = [p.wait() for p in processes]

Este código lanza cinco comandos de shell simultáneamente y recopila sus códigos de salida. Tenga en cuenta que el carácter & no es necesario en este contexto ya que Popen no espera a que se completen los comandos de forma predeterminada. Debes llamar explícitamente a .wait() para recuperar sus estados.

Subprocesos con recopilación de resultados

Aunque es conveniente recopilar resultados de los subprocesos de forma secuencial, también puedes usar subprocesos para la recopilación paralela si lo deseas. . Considere el siguiente ejemplo:

#!/usr/bin/env python
from multiprocessing.dummy import Pool # thread pool
from subprocess import Popen, PIPE, STDOUT

# create a list of subprocesses with output handling
processes = [Popen("echo {i:d}; sleep 2; echo {i:d}".format(i=i), shell=True,
                   stdin=PIPE, stdout=PIPE, stderr=STDOUT, close_fds=True)
             for i in range(5)]

# collect outputs in parallel
def get_lines(process):
    return process.communicate()[0].splitlines()

outputs = Pool(len(processes)).map(get_lines, processes)

Este código ejecuta subprocesos en paralelo y recopila sus salidas simultáneamente utilizando subprocesos.

Ejecución paralela basada en Asyncio

Para las versiones 3.8 y superiores de Python, asyncio ofrece una forma elegante de ejecutar subprocesos simultáneamente. Aquí hay un ejemplo:

#!/usr/bin/env python3
import asyncio
import sys
from subprocess import PIPE, STDOUT

async def get_lines(shell_command):
    p = await asyncio.create_subprocess_shell(
        shell_command, stdin=PIPE, stdout=PIPE, stderr=STDOUT
    )
    return (await p.communicate())[0].splitlines()


async def main():
    # create a list of coroutines for subprocess execution
    coros = [get_lines(f'"{sys.executable}" -c "print({i:d}); import time; time.sleep({i:d})"') for i in range(5)]

    # get subprocess outputs in parallel
    print(await asyncio.gather(*coros))

if __name__ == "__main__":
    asyncio.run(main())

Este código demuestra cómo ejecutar subprocesos simultáneamente dentro de un solo subproceso.

Al implementar estos enfoques, puede mejorar significativamente la eficiencia de su script ejecutando múltiples 'gato | Comandos zgrep' en paralelo en el servidor remoto.