Python unter Windows - Wie kann ich auf mehrere untergeordnete Prozesse warten?

Wie zu warten, bis mehrere Kind-Prozesse in Python unter Windows, ohne aktives warten (polling)? So etwas fast funktioniert bei mir:

proc1 = subprocess.Popen(['python','mytest.py'])
proc2 = subprocess.Popen(['python','mytest.py'])    
proc1.wait()
print "1 finished"
proc2.wait()
print "2 finished"

Das problem ist, dass wenn proc2 beendet, bevor proc1, der übergeordnete Prozess wird noch warten proc1. Unter Unix würde man mit waitpid(0) in einer Schleife, um die Kind-Prozesse " return-codes, wie Sie beenden - wie um etwas zu erreichen, wie dies in Python auf Windows?

Kommentar zu dem Problem - Öffnen
können Sie beschreiben, waitpid(0), die Sie verwenden würden, auf unix? Kommentarautor: Gregg Lind
docs.python.org/library/os.html#os.waitpid waitpid(0) auf unix-wartet (es sei denn, WNOHANG ist in der option) für jeden Kind-status und liefert (Prozess-id,status) - Tupel. Kommentarautor: Rafał Dowgird

InformationsquelleAutor der Frage Rafał Dowgird | 2008-09-19

  1. 13

    Könnte es scheinen übertrieben, aber hier geht es:

    import Queue, thread, subprocess

results= Queue.Queue()
def process_waiter(popen, description, que):
    try: popen.wait()
    finally: que.put( (description, popen.returncode) )
process_count= 0

proc1= subprocess.Popen( ['python', 'mytest.py'] )
thread.start_new_thread(process_waiter,
    (proc1, "1 finished", results))
process_count+= 1

proc2= subprocess.Popen( ['python', 'mytest.py'] )
thread.start_new_thread(process_waiter,
    (proc2, "2 finished", results))
process_count+= 1

# etc

while process_count > 0:
    description, rc= results.get()
    print "job", description, "ended with rc =", rc
    process_count-= 1

    InformationsquelleAutor der Antwort tzot

  2. 5

    Verdreht hat eine asynchroner Prozess -, Laich-API die funktioniert auch auf Windows. Es gibt tatsächlich mehrere verschiedene Implementierungen, von denen viele nicht so toll, aber man kann zwischen Ihnen wechseln, ohne änderung des Codes.

    InformationsquelleAutor der Antwort Glyph

  3. 5

    Gebäude auf zseil Antwort, Sie können dies tun mit einer Mischung von Teilprozess und win32-API-Aufrufe. Ich benutzte gerade ctypes, da meine Python nicht passieren, win32api installiert. Ich bin gerade laichen sleep.exe von MSYS hier als Beispiel, aber klar könnten Sie laichen jeden Prozess, den Sie möchten. Ich benutze OpenProcess (), um ein HANDLE vom Prozess " PID, und dann WaitForMultipleObjects-warten auf die Prozess fertig zu stellen.

    import ctypes, subprocess
from random import randint
SYNCHRONIZE=0x00100000
INFINITE = -1
numprocs = 5
handles = {}

for i in xrange(numprocs):
    sleeptime = randint(5,10)
    p = subprocess.Popen([r"c:\msys\1.0\bin\sleep.exe", str(sleeptime)], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=False)
    h = ctypes.windll.kernel32.OpenProcess(SYNCHRONIZE, False, p.pid)
    handles[h] = p.pid
    print "Spawned Process %d" % p.pid

while len(handles) > 0:
    print "Waiting for %d children..." % len(handles)
    arrtype = ctypes.c_long * len(handles)
    handle_array = arrtype(*handles.keys())
    ret = ctypes.windll.kernel32.WaitForMultipleObjects(len(handle_array), handle_array, False, INFINITE)
    h = handle_array[ret]
    ctypes.windll.kernel32.CloseHandle(h)
    print "Process %d done" % handles[h]
    del handles[h]
print "All done!"

    InformationsquelleAutor der Antwort Ted Mielczarek

  4. 4

    Verdreht unter Windows ausgeführt werden wird, ein aktives warten, unter der Decke. Wenn Sie nicht möchten, verwenden Sie threads, verwenden Sie die win32-API zu vermeiden polling. So etwas wie dieses:

    import win32process
import win32event

# Note: CreateProcess() args are somewhat cryptic, look them up on MSDN
proc1, thread1, pid1, tid1 = win32process.CreateProcess(...)
proc2, thread2, pid2, tid2 = win32process.CreateProcess(...)
thread1.close()
thread2.close()

processes = {proc1: "proc1", proc2: "proc2"}

while processes:
    handles = processes.keys()
    # Note: WaitForMultipleObjects() supports at most 64 processes at a time
    index = win32event.WaitForMultipleObjects(handles, False, win32event.INFINITE)
    finished = handles[index]
    exitcode = win32process.GetExitCodeProcess(finished)
    procname = processes.pop(finished)
    finished.close()
    print "Subprocess %s finished with exit code %d" % (procname, exitcode)

    InformationsquelleAutor der Antwort user23475

  5. 2

    Können Sie psutil:

    >>> import subprocess
>>> import psutil
>>> 
>>> proc1 = subprocess.Popen(['python','mytest.py'])
>>> proc2 = subprocess.Popen(['python','mytest.py'])    
>>> ls = [psutil.Process(proc1.pid), psutil.Process(proc2.pid)]
>>>
>>> gone, alive = psutil.wait_procs(ls, timeout=3)

    'Weg' und 'lebendig' sind Listen anzeigt, welche Prozesse gegangen sind und welche noch am Leben sind.

    Optional können Sie einen callback, die aufgerufen wird jedes mal, wenn eine der überwachten Prozesse beendet:

    >>> def on_terminate(proc):
...     print "%s terminated" % proc
...
>>> gone, alive = psutil.wait_procs(ls, timeout=3, callback=on_terminate)

    InformationsquelleAutor der Antwort Giampaolo Rodolà

Schreibe einen Kommentar