Mehrere 'cat | ausführen zgrep'-Befehle gleichzeitig

In diesem Python-Skript werden mehrere 'cat | „zgrep“-Befehle werden nacheinander auf einem Remote-Server ausgeführt und ihre Ausgaben werden einzeln zur Verarbeitung gesammelt. Um die Effizienz zu steigern, möchten wir diese Befehle jedoch parallel ausführen.

Unterprozess ohne Threading verwenden

Im Gegensatz zur Verwendung von Multiprocessing oder Threading können Sie Unterprozesse mit dem folgenden Ansatz parallel ausführen:

#!/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]

Dieser Code startet fünf Shell-Befehle gleichzeitig und sammelt ihre Exit-Codes. Beachten Sie, dass das &-Zeichen in diesem Zusammenhang nicht erforderlich ist, da Popen standardmäßig nicht auf den Abschluss von Befehlen wartet. Sie müssen .wait() explizit aufrufen, um deren Status abzurufen.

Unterprozesse mit Ausgabesammlung

Obwohl es praktisch ist, die Ausgabe von Unterprozessen nacheinander zu sammeln, können Sie bei Bedarf auch Threads für die parallele Sammlung verwenden . Betrachten Sie das folgende Beispiel:

#!/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)

Dieser Code führt Unterprozesse parallel aus und sammelt ihre Ausgaben gleichzeitig mithilfe von Threads.

Asyncio-basierte parallele Ausführung

Für Python-Versionen 3.8 und höher bietet Asyncio eine elegante Möglichkeit, Unterprozesse gleichzeitig auszuführen. Hier ist ein Beispiel:

#!/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())

Dieser Code zeigt, wie Unterprozesse gleichzeitig in einem einzelnen Thread ausgeführt werden.

Durch die Implementierung dieser Ansätze können Sie die Effizienz Ihres Skripts erheblich verbessern, indem Sie mehrere ausführen 'Katze | zgrep'-Befehle parallel auf dem Remote-Server ausführen.