Invocação de subprocesso sem bloqueio

Ao executar scripts externos usando subprocess.call, manter um fluxo de trabalho sem bloqueio é essencial para evitar a paralisação do programa principal. Este artigo apresenta uma solução abrangente para atingir esse objetivo.

Abordagem usando subprocess.Popen

O método principal para executar um subprocesso sem bloqueio é empregar subprocess.Popen em vez de subprocess.call. Esta alternativa não bloqueia o programa principal, permitindo-lhe continuar as suas operações enquanto o subprocesso é executado de forma independente. Aqui está um exemplo:

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

Exemplo abrangente

Para uma demonstração completa de chamadas de subprocessos sem bloqueio, considere o seguinte 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 executa o comando 'sleep' de forma assíncrona, verificando periodicamente seu status até que seja concluído.

Alternativa Abordagem assíncrona

Para Python versões 3.5 e superiores, uma abordagem mais moderna e eficiente envolve o uso de asyncio. Ele permite simultaneidade real, permitindo que várias tarefas sejam executadas simultaneamente. Aqui está um exemplo:

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

Essa abordagem garante que tanto o subprocesso quanto o programa principal sejam executados simultaneamente, maximizando o desempenho e a capacidade de resposta.