Sauber Python-Multiprozess-Kündigung abhängig von einer exit-flag

Ich bin versucht, erstellen Sie ein Programm mit mehreren Prozessen, und ich würde gerne sauber beenden Sie alle Prozesse hervorgebracht, wenn Fehler auftreten. unten habe ich geschrieben, einige pseudo-Art code für das, was ich glaube ich tun muss, aber ich weiß nicht, was der beste Weg ist, zu kommunizieren, um alle Prozesse, bei denen ein Fehler aufgetreten ist und beendet werden soll.

Ich denke, ich sollte mit Klassen für diese Art der Sache, aber ich bin ganz neu bei Python, so dass ich versuche nur, in meinen Kopf zu kriegen zuerst die Grundlagen. 

#imports

exitFlag = True

# Function for threads to process   
def url_thread_worker( ):   
# while exitFlag:
    try:
        # do something
    except:
        # we've ran into a problem, we need to kill all the spawned processes and cleanly exit the program
        exitFlag = False

def processStarter( ):

    process_1 = multiprocessing.Process( name="Process-1", target=url_thread_worker, args=( ) ) 
    process_2 = multiprocessing.Process( name="Process-2", target=url_thread_worker, args=( ) ) 

    process_1.start()
    process_2.start()


if __name__ == '__main__':
     processStarter( )

Vielen Dank im Voraus

InformationsquelleAutor Daniel Pilch | 2013-11-14
  1. 4

    Hier ist mein Vorschlag:

    import multiprocessing
import threading
import time

def good_worker():   
    print "[GoodWorker] Starting"
    time.sleep(4)
    print "[GoodWorker] all good"

def bad_worker():
    print "[BadWorker] Starting"
    time.sleep(2)
    raise Exception("ups!")

class MyProcManager(object):
    def __init__(self):
        self.procs = []
        self.errors_flag = False
        self._threads = []
        self._lock = threading.Lock()

    def terminate_all(self):
        with self._lock:
            for p in self.procs:
                if p.is_alive():
                    print "Terminating %s" % p
                    p.terminate()

    def launch_proc(self, func, args=(), kwargs= {}):
        t = threading.Thread(target=self._proc_thread_runner,
                             args=(func, args, kwargs))
        self._threads.append(t)
        t.start()

    def _proc_thread_runner(self, func, args, kwargs):
        p = multiprocessing.Process(target=func, args=args, kwargs=kwargs)
        self.procs.append(p)
        p.start()
        while p.exitcode is None:
            p.join()
        if p.exitcode > 0:
            self.errors_flag = True
            self.terminate_all()

    def wait(self):
        for t in self._threads:
            t.join()

if __name__ == '__main__':
    proc_manager = MyProcManager()
    proc_manager.launch_proc(good_worker) 
    proc_manager.launch_proc(good_worker) 
    proc_manager.launch_proc(bad_worker) 
    proc_manager.wait()
    if proc_manager.errors_flag:
        print "Errors flag is set: some process crashed"
    else:
        print "Everything closed cleanly"

    Müssen Sie ein wrapper-thread für jeden Prozess ausführen, und wartet, für deren Ende.
    Wenn ein Prozess beendet wird, überprüfen Sie den exitcode: wenn > 0, d.h. es hob einige nicht behandelte Ausnahme. Jetzt rufen terminate_all (), um zu schließen Sie alle verbleibenden aktiven Prozesse.
    Die wrapper-threads werden auch zu beenden, wie Sie abhängig sind, den Prozess ausführen.

    Außerdem in Ihrem code, den Sie sind völlig frei, zu nennen proc_manager.terminate_all (), Wann immer Sie wollen. Sie können die überprüfung für einige flags in einem anderen thread oder sowas..

    Hoffe, es ist gut für Ihren Fall.

    PS: btw.. in deinem ursprünglichen code hast du so etwas wie eine Globale exit_flag: Sie können nie ein "global" exit_flag in multiprocessing, weil es einfach ist nicht global, wie Sie mit getrennte Verfahren mit getrennten Speicherbereichen. Das funktioniert nur in der threaded-Umgebungen, in denen der Staat geteilt werden können. Wenn Sie es brauchen, in multiprocessing dann müssen Sie explizite Kommunikation zwischen Prozessen (Rohr und Warteschlange erreichen, dass) oder so etwas wie shared memory Objekte

    • Dies ist ein schönes Beispiel und sehr geholfen hat. Ich danke Ihnen sehr.
    • Sie entschied sich für den "leichten Teil" - wenn Kinder stirbt. Aber was ist, wenn ein Elternteil stirbt? Als Sie mit der linken verwaiste Prozesse (Arbeitnehmer). Die, zumindest für mich, ist ein großes problem.
    • Das ist eine wesentlich verschiedene Fälle zu lösen, und nicht wirklich Häufig, IMHO. Sie sollten den code Ihres Systems, um sicherzustellen, dass die Eltern die elastisch ist, um Fehler und es kann, zumindest kündigen die Kind-Prozesse, wenn ein problem Auftritt.
    InformationsquelleAutor abranches
  2. 1

    Wenn Sie möchten, dass Ihre Kind-Prozesse werden automatisch beendet, wenn der Vaterprozess beendet; man könnte Sie dem dämonischen (set .daemon=True vor .start()), d.h., wenn die Eltern einen Fehler erkennt; es kann nur beenden -- die Kinder wird gesorgt sein.

    Wenn Sie möchten, dass Kinder, die zu bereinigen nach sich selbst; Sie könnte verwenden Sie multiprocessing.Event() als ein globales flag:

    import multiprocessing

def event_func(event):
    print '\t%r is waiting' % multiprocessing.current_process()
    event.wait()
    print '\t%r has woken up' % multiprocessing.current_process()

if __name__ == '__main__':
    event = multiprocessing.Event()

    processes = [multiprocessing.Process(target=event_func, args=(event,))
                 for i in range(5)]

    for p in processes:
        p.start()

    print 'main is sleeping'
    time.sleep(2)

    print 'main is setting event'
    event.set()

    for p in processes:
        p.join()
    InformationsquelleAutor jfs
Schreibe einen Kommentar