Python: multitraitement.carte: Si un processus soulève une exception, pourquoi ne sont pas les autres processus " enfin des blocs?

Ma compréhension est que, finalement, les clauses doit *toujours* être exécuté si l'essai a été saisi.

import random

from multiprocessing import Pool
from time import sleep

def Process(x):
  try:
    print x
    sleep(random.random())
    raise Exception('Exception: ' + x)
  finally:
    print 'Finally: ' + x

Pool(3).map(Process, ['1','2','3'])

Résultat attendu est que pour chaque x qui est imprimé sur son propre par la ligne 8, il y doit être une occurrence de "Enfin x'.

Exemple de sortie:

$ python bug.py 
1
2
3
Finally: 2
Traceback (most recent call last):
  File "bug.py", line 14, in <module>
    Pool(3).map(Process, ['1','2','3'])
  File "/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/multiprocessing/pool.py", line 225, in map
    return self.map_async(func, iterable, chunksize).get()
  File "/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/multiprocessing/pool.py", line 522, in get
    raise self._value
Exception: Exception: 2

Il semble qu'une exception de terminaison d'un processus se termine, les parents et les frères et soeurs processus, même si il y a encore du travail nécessaire à faire dans d'autres processus.

Pourquoi ai-je tort? Pourquoi est-ce correct? Si cela est correct, comment devrait un en toute sécurité nettoyer les ressources en multi process Python?

InformationsquelleAutor Daniel Wagner-Hall | 2011-10-09
  1. 33

    Réponse courte: SIGTERM atouts finally.

    Réponse longue: Activer la journalisation avec mp.log_to_stderr():

    import random
import multiprocessing as mp
import time
import logging

logger=mp.log_to_stderr(logging.DEBUG)

def Process(x):
    try:
        logger.info(x)
        time.sleep(random.random())
        raise Exception('Exception: ' + x)
    finally:
        logger.info('Finally: ' + x)

result=mp.Pool(3).map(Process, ['1','2','3'])

    La sortie d'enregistrement comprend:

    [DEBUG/MainProcess] terminating workers

    Qui correspond à ce code dans multiprocessing.pool._terminate_pool:

        if pool and hasattr(pool[0], 'terminate'):
        debug('terminating workers')
        for p in pool:
            p.terminate()

    Chaque p dans pool est un multiprocessing.Process, et en appelant terminate (au moins sur la non-machines Windows) appels SIGTERM:

    de multiprocessing/forking.py:

    class Popen(object)
    def terminate(self):
        ...
            try:
                os.kill(self.pid, signal.SIGTERM)
            except OSError, e:
                if self.wait(timeout=0.1) is None:
                    raise

    Il descend donc à ce qui se passe quand un Python processus dans un try suite est envoyé un SIGTERM.

    Considérons l'exemple suivant (test.py):

    import time    
def worker():
    try:
        time.sleep(100)        
    finally:
        print('enter finally')
        time.sleep(2) 
        print('exit finally')    
worker()

    Si vous l'exécutez, puis de l'envoyer à un SIGTERM, puis le processus se termine immédiatement, sans entrer dans le finally suite, comme en témoigne pas de sortie, et aucun retard.

    Dans un terminal:

    % test.py

    En deuxième terminal:

    % pkill -TERM -f "test.py"

    Résultat dans le premier terminal:

    Terminated

    La comparer avec ce qui se passe lorsque le processus est envoyé un SIGINT (C-c):

    En deuxième terminal:

    % pkill -INT -f "test.py"

    Résultat dans le premier terminal:

    enter finally
exit finally
Traceback (most recent call last):
  File "/home/unutbu/pybin/test.py", line 14, in <module>
    worker()
  File "/home/unutbu/pybin/test.py", line 8, in worker
    time.sleep(100)        
KeyboardInterrupt

    Conclusion: SIGTERM atouts finally.

    InformationsquelleAutor unutbu
  2. 4

    La réponse de unutbu certainement explique pourquoi vous obtenir le comportement que vous observez. Cependant, il convient de souligner que SIGTERM est envoyé seulement à cause de la façon dont multiprocessing.pool._terminate_pool est mis en œuvre. Si vous pouvez éviter d'utiliser Pool, alors vous pouvez obtenir le comportement que vous désirez. Voici une emprunté exemple:

    from multiprocessing import Process
from time import sleep
import random

def f(x):
    try:
        sleep(random.random()*10)
        raise Exception
    except:
        print "Caught exception in process:", x
        # Make this last longer than the except clause in main.
        sleep(3)
    finally:
        print "Cleaning up process:", x

if __name__ == '__main__':
    processes = []
    for i in range(4):
        p = Process(target=f, args=(i,))
        p.start()
        processes.append(p)
    try:
        for process in processes:
            process.join()
    except:
        print "Caught exception in main."
    finally:
        print "Cleaning up main."

    Après l'envoi d'un SIGINT est, exemple de sortie est:

    Caught exception in process: 0
^C
Cleaning up process: 0
Caught exception in main.
Cleaning up main.
Caught exception in process: 1
Caught exception in process: 2
Caught exception in process: 3
Cleaning up process: 1
Cleaning up process: 2
Cleaning up process: 3

    Noter que le finally clause est couru pour tous les processus. Si vous avez besoin de la mémoire partagée, pensez à utiliser Queue, Pipe, Manager, ou certains magasin externe comme redis ou sqlite3.

    InformationsquelleAutor Tom
  3. 1

    finally re-soulève l'exception d'origine à moins que vous return à partir de ce. L'exception est alors soulevée par Pool.map et tue toute votre application. Le sous-processus sont terminés et vous ne voyez pas d'autres exceptions.

    Vous pouvez ajouter un return à avaler l'exception:

    def Process(x):
  try:
    print x
    sleep(random.random())
    raise Exception('Exception: ' + x)
  finally:
    print 'Finally: ' + x
    return

    Alors vous devriez avoir None dans votre map résultat lorsqu'une exception s'est produite.

    • C'est une solution utile, mais sûrement, en tout cas, le moteur d'exécution ne devraient pas être autorisés à être tués jusqu'à ce que tous les blocs ont été exécutés?
    • Wagner-Hall: Pool.map est modélisé d'après map, qui s'arrête également lorsque la fonction mappé soulève une exception. Peut-être (essayer) de l'enfant, les processus sont terminés normalement et réellement faire exécuter la finally - seulement parce que votre thread principal est tué en premier la sortie de l'enfant n'est pas en lire plus.
    InformationsquelleAutor Jochen Ritzel