Invocación de subproceso sin bloqueo

Al ejecutar scripts externos usando subprocess.call, mantener un flujo de trabajo sin bloqueo es esencial para evitar detener el programa principal. Este artículo presenta una solución integral para lograr este objetivo.

Enfoque utilizando subprocess.Popen

El método principal para ejecutar un subproceso sin bloqueo es emplear subprocess.Popen en lugar de subprocess.call. Esta alternativa no bloquea el programa principal, permitiéndole continuar sus operaciones mientras el subproceso se ejecuta de forma independiente. Aquí hay un ejemplo:

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

Ejemplo completo

Para una demostración completa de las llamadas a subprocesos sin bloqueo, considere el siguiente código:

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)

Este código ejecuta el comando 'dormir' de forma asincrónica, comprobando periódicamente su estado hasta que se completa.

Alternativa Enfoque asincrónico

Para las versiones 3.5 y superiores de Python, un enfoque más moderno y eficiente implica el uso de asyncio. Permite una verdadera concurrencia, lo que permite ejecutar múltiples tareas simultáneamente. Aquí hay un ejemplo:

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

Este enfoque garantiza que tanto el subproceso como el programa principal se ejecuten simultáneamente, maximizando el rendimiento y la capacidad de respuesta.