python-multiprocessing-pool beenden

Arbeite ich auf einer renderfarm, und ich brauche meine Kunden, um in der Lage zu starten mehrerer Instanzen eines Renderers, ohne zu blockieren, so kann der Kunde erhalten neue Befehle. Ich habe, dass die Arbeit richtig, aber ich habe Probleme mit dem beenden der Prozesse erstellt.

Auf globaler Ebene definiere ich mein pool (so dass ich zugreifen kann, können Sie aus jeder Funktion):

p = Pool(2)

Ich dann meinen renderer mit apply_async:

for i in range(totalInstances):
    p.apply_async(render, (allRenderArgs[i],args[2]), callback=renderFinished)
p.close()

Dass die Funktion abgeschlossen ist, startet die Prozesse im hintergrund, und wartet auf neue Befehle. Ich habe einen einfachen Befehl, töten den client und stoppen Sie die macht:

def close():
'close this client instance'
tn.write ("say "+USER+" is leaving the farm\r\n")
try:
    p.terminate()
except Exception,e:
    print str(e)
    sys.exit()
sys.exit()

Scheint es nicht zu geben einen Fehler (es drucken würde, der den Fehler), die python beendet, aber der hintergrund-Prozesse ausgeführt werden. Kann jemand empfehlen, einen besseren Weg, die Kontrolle dieser Programme gestartet?

  • Versuchen, aktivieren Sie die debug-Protokollierung mit from multiprocessing import util; util.get_logger().setLevel(util.DEBUG) und fügen Sie die Ausgabe.
  • Ich habe gesehen, Verhalten, wie dies vor, aber kann es nicht reproduzieren...jetzt Frage ich mich, wenn ein Aufruf von p.join() helfen würde, nach dem Aufruf von p.terminate()? Ich Frage mich auch, wenn Sie noch brauchen, um Anruf zu beenden und wenn Sie nur das tut, sys.exit() wird ordnungsgemäß Müll sammeln, den Pool und alle seine Prozesse.
  • wenn ich versuche zum aktivieren der Protokollierung, ich bin immer dies in der Konsole:" Kein Handler gefunden werden konnte, der für den logger "multiprocessing". Leider, p.join() nach p.terminate() nicht einen Unterschied machen, und sys.exit() schließt die python lässt aber die Prozesse im hintergrund laufen.
  • versuchen multiprocessing.log_to_stderr().setLevel(logging.DEBUG). Tut render() starten weiterer Prozesse, z.B. mit subprocess Modul?
InformationsquelleAutor tk421storm | 2013-05-06
  1. 7

    Fand ich die Lösung: stoppen Sie den pool in einem separaten thread, wie diesem:

    def close_pool():
    global pool
    pool.close()
    pool.terminate()
    pool.join()

def term(*args,**kwargs):
    sys.stderr.write('\nStopping...')
    # httpd.shutdown()
    stophttp = threading.Thread(target=httpd.shutdown)
    stophttp.start()
    stoppool=threading.Thread(target=close_pool)
    stoppool.daemon=True
    stoppool.start()


signal.signal(signal.SIGTERM, term)
signal.signal(signal.SIGINT, term)
signal.signal(signal.SIGQUIT, term)

    Funktioniert gut, und immer habe ich getestet.

    InformationsquelleAutor eri
  2. 5

    Wenn Sie das Problem weiterhin Auftritt, könntest du versuchen, die Simulation einer Pool mit dämonischen Prozesse (vorausgesetzt, Sie starten die pool - /Prozesse, die von einer nicht-dämonischen Prozess). Ich bezweifle, das ist die beste Lösung, da es scheint, wie Ihre Pool Prozesse beenden, aber das alles konnte ich mit kommen. Ich weiß nicht, was Ihr Rückruf nicht, also bin ich nicht sicher, wo-in meinen Beispiel unten.

    Ich auch vorschlagen, versuchen, zu erstellen Ihre Pool im __main__ aufgrund meiner Erfahrung (und der Dokumentation) mit Verrücktheit, die Auftritt, wenn Prozesse, die erzeugt werden, weltweit. Dies gilt insbesondere, wenn Sie in Windows: http://docs.python.org/2/library/multiprocessing.html#windows

    from multiprocessing import Process, JoinableQueue

# the function for each process in our pool
def pool_func(q):
    while True:
        allRenderArg, otherArg = q.get() # blocks until the queue has an item
        try:
            render(allRenderArg, otherArg)
        finally: q.task_done()

# best practice to go through main for multiprocessing
if __name__=='__main__':
    # create the pool
    pool_size = 2
    pool = []
    q = JoinableQueue()
    for x in range(pool_size):
        pool.append(Process(target=pool_func, args=(q,)))

    # start the pool, making it "daemonic" (the pool should exit when this proc exits)
    for p in pool:
        p.daemon = True
        p.start()

    # submit jobs to the queue
    for i in range(totalInstances):
        q.put((allRenderArgs[i], args[2]))

    # wait for all tasks to complete, then exit
    q.join()
    • interessant! schöne Spitze zum definieren in der main statt Global. Ich baute auf diese Weise, und es hat nicht mein problem zu lösen (siehe unten), aber ich mag die Konstruktion besser. Danke!
    InformationsquelleAutor mdscruggs
  3. 0
    # -*- coding:utf-8 -*-
import multiprocessing
import time
import sys
import threading
from functools import partial


#> work func
def f(a,b,c,d,e):
    print('start')
    time.sleep(4)
    print(a,b,c,d,e)

###########> subProcess func
#1. start a thead for work func
#2. waiting thead with a timeout
#3. exit the subProcess
###########
def mulPro(f, *args, **kwargs):
    timeout = kwargs.get('timeout',None)

    #1. 
    t = threading.Thread(target=f, args=args)
    t.setDaemon(True)
    t.start()
    #2. 
    t.join(timeout)
    #3. 
    sys.exit()

if __name__ == "__main__":

    p = multiprocessing.Pool(5)
    for i in range(5):
        #1. process the work func with "subProcess func"
        new_f = partial(mulPro, f, timeout=8)
        #2. fire on
        p.apply_async(new_f, args=(1,2,3,4,5),)

        # p.apply_async(f, args=(1,2,3,4,5), timeout=2)
    for i in range(10):
        time.sleep(1)
        print(i+1,"s")

    p.close()
    # p.join()
    InformationsquelleAutor rodemon
  4. -5

    Fand die Antwort auf meine eigene Frage. Das primäre problem war, dass ich den Aufruf einer Drittanbieter-Anwendung anstatt einer Funktion. Wenn ich den Aufruf des Unterprozess [entweder call() oder Popen()] erzeugt eine neue Instanz von python, deren einziger Zweck es ist, rufen Sie die neue Anwendung. Allerdings, wenn python verlässt, tötet diese neue Instanz von python und lassen Sie die Anwendung laufen.

    Die Lösung ist, es zu tun die harte Weise, indem die pid des python-Prozess, der erstellt wird, bekommen die Kinder, die pid -, und tötet Sie. Dieser code ist spezifisch für osx; es ist einfacher code (das sich nicht auf grep) für linux verfügbar.

    for process in pool:
    processId = process.pid
    print "attempting to terminate "+str(processId)
    command = " ps -o pid,ppid -ax | grep "+str(processId)+" | cut -f 1 -d \" \" | tail -1"
    ps_command = Popen(command, shell=True, stdout=PIPE)
    ps_output = ps_command.stdout.read()
    retcode = ps_command.wait()
    assert retcode == 0, "ps command returned %d" % retcode
    print "child process pid: "+ str(ps_output)
    os.kill(int(ps_output), signal.SIGTERM)
    os.kill(int(processId), signal.SIGTERM)
    InformationsquelleAutor tk421storm
Schreibe einen Kommentar