Invocation de sous-processus non bloquant

Lors de l'exécution de scripts externes à l'aide de subprocess.call, le maintien d'un flux de travail non bloquant est essentiel pour éviter de bloquer le programme principal. Cet article présente une solution complète pour atteindre cet objectif.

Approche utilisant subprocess.Popen

La principale méthode pour exécuter un sous-processus non bloquant consiste à utiliser subprocess.Popen au lieu de subprocess.call. Cette alternative ne bloque pas le programme principal, lui permettant de poursuivre ses opérations pendant que le sous-processus s'exécute de manière indépendante. Voici un exemple :

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

Exemple complet

Pour une démonstration complète des appels de sous-processus non bloquants, considérez le code suivant :

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)

Ce code exécute la commande 'sleep' de manière asynchrone, vérifiant périodiquement son état jusqu'à ce qu'elle se termine.

Alternative Approche asynchrone

Pour les versions 3.5 et supérieures de Python, une approche plus moderne et efficace consiste à utiliser asyncio. Il permet une véritable concurrence, permettant à plusieurs tâches de s'exécuter simultanément. Voici un exemple :

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

Cette approche garantit que le sous-processus et le programme principal s'exécutent simultanément, maximisant ainsi les performances et la réactivité.