Nicht blockierender Unterprozessaufruf

Beim Ausführen externer Skripte mit subprocess.call ist die Aufrechterhaltung eines nicht blockierenden Workflows unerlässlich, um ein Abwürgen des Hauptprogramms zu vermeiden. Dieser Artikel stellt eine umfassende Lösung zum Erreichen dieses Ziels vor.

Ansatz mit subprocess.Popen

Die primäre Methode zum Ausführen eines nicht blockierenden Unterprozesses ist die Verwendung von subprocess.Popen anstelle von subprocess.call. Diese Alternative blockiert das Hauptprogramm nicht und ermöglicht ihm, seine Operationen fortzusetzen, während der Unterprozess unabhängig ausgeführt wird. Hier ist ein Beispiel:

subprocess.Popen(["python", "slave.py"]   sys.argv[1:])

Umfassendes Beispiel

Betrachten Sie für eine vollständige Demonstration nicht blockierender Unterprozessaufrufe den folgenden Code:

import subprocess
import time

p = subprocess.Popen(['sleep', '5'])

while p.poll() is None:
    print('Still sleeping')
    time.sleep(1)

print('Not sleeping any longer.  Exited with returncode %d' % p.returncode)

Dieser Code führt den Befehl „sleep“ asynchron aus und überprüft regelmäßig seinen Status, bis er abgeschlossen ist.

Alternative Asynchroner Ansatz

Für Python-Versionen 3.5 und höher ist die Verwendung von Asyncio ein modernerer und effizienterer Ansatz. Es ermöglicht echte Parallelität und ermöglicht die gleichzeitige Ausführung mehrerer Aufgaben. Hier ist ein Beispiel:

import asyncio

async def do_subprocess():
    print('Subprocess sleeping')
    proc = await asyncio.create_subprocess_exec('sleep', '5')
    returncode = await proc.wait()
    print('Subprocess done sleeping.  Return code = %d' % returncode)

async def sleep_report(number):
    for i in range(number   1):
        print('Slept for %d seconds' % i)
        await asyncio.sleep(1)

loop = asyncio.get_event_loop()

tasks = [
    asyncio.ensure_future(do_subprocess()),
    asyncio.ensure_future(sleep_report(5)),
]

loop.run_until_complete(asyncio.gather(*tasks))
loop.close()

Dieser Ansatz stellt sicher, dass sowohl der Unterprozess als auch das Hauptprogramm gleichzeitig ausgeführt werden, wodurch Leistung und Reaktionsfähigkeit maximiert werden.