Déclencheur

Il y avait beaucoup d'histoires similaires (traduction officielle / réédition?) De l'exécution asynchrone de Python. C'est difficile pour un vieil homme qui a la tête dure, alors j'ai cherché des exemples et regardé des sites dans plusieurs langues, et finalement ému par essais et erreurs, alors j'ai essayé de résumer uniquement mon cœur.

Aperçu

Tous les exemples sont des modèles d'exécution de commandes externes sous Windows Il n'y a presque pas de commentaire.

Vérifier avec PID

Facile et agréable. C'est ce qu'Ojisan a proposé.

`pid.py`


import subprocess
from time import sleep
procs = {}
for h in servers:
    p = subprocess.Popen(["some", "command"], ...)
    # subprocess.courir vers stdout=Cela semble fonctionner avec PIPE, mais il n'a pas été étudié
    procs[p.pid] = p

while procs:
    for pid in list(procs):
        if procs[pid].poll in not None:
            del procs[pid]
    sleep(x)

procs peut être une liste de p à partir de la fin, Mon préféré est qu'il sera vide à la fin.

Parallèle 1 (aucun STDOUT requis)

C'est OK si la cible à exécuter génère quelque chose. La fonction d'exécution est une cible d'exécution asynchrone. Quand je l'ai fait pour la première fois, je l'ai appelé avec run_until_complete, donc je me demandais s'il attendrait simplement avec create_subprocess_shell.

`async1.py`


import asyncio
from asyncoio.subprocess import DEVNULL

async def run(param):
    #L'une ou l'autre des deux œuvres suivantes
    p = await asyncio.create_subprocess_exec(*["some", "command", param],
           stdout=DEVNULL, ...)
    p = await asyncio.create_subprocess_shell("some command %s" % param,
           stdout=DEVNULL, ...)

    await p.wait()

if sys.platform.startswith('win'):
    loop = asyncio.ProactorEventLoop()
    asyncio.set_event_loop(loop)
else:
    loop = asyncio.get_event_loop()

funcs = asyncio.gather(*[run(p) for p in parameters])
loop.run_until_complete(funcs)

Parallèle 2 (STDOUT requis)

C'est l'endroit pour faire quelque chose en utilisant la sortie standard à exécuter. Cependant, les résultats seront renvoyés au ret principal dans l'ordre de fin, vous devez donc l'endurer.

`async_stdout.py`


import asyncio
from asyncoio.subprocess import PIPE
import sys

async def run(param):
    p = await asyncio.create_subprocess_shell("some command %s"  param,
            stdout=PIPE, ...)
    return await (p.communicate())[0].decode('code').splitlines()

async def main():
    funcs = asyncio.gather(*[run(p) for p in parameters]*)
    for f in asyncio.as_completed(funcs):
        ret = await f

if sys.platform.startswith('win'):
    loop = asyncio.ProactorEventLoop()
    asyncio.set_event_loop(loop)
else:
    loop = asyncio.get_event_loop()

loop.run_until_complete(main())

Remarques

J'ai l'impression d'écrire quelque chose de similaire. Vais-je écrire sur openpyxl ensuite?

mémorandum d'exécution parallèle / asynchrone python