Comment exécuter des sous-processus non bloquants en Python ?

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 :

<code class="python">subprocess.Popen(["python", "slave.py"] + sys.argv[1:])</code>

Exemple complet

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

<code class="python">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)</code>

Ce code exécute le 'sleep' de manière asynchrone, en vérifiant périodiquement son état jusqu'à ce qu'elle soit terminée.

Approche asynchrone alternative

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

<code class="python">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()</code>

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

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!