Catch Ctrl+C / SIGINT et de sortie multiprocesses gracieusement en python

Comment puis-je attraper un Ctrl+C dans multi process programme en python et la sortie de tous les processus gracieusement, j'ai besoin de la solution de travailler à la fois sur windows et unix. J'ai essayé ce qui suit:

import multiprocessing
import time
import signal
import sys

jobs = []

def worker():
    signal.signal(signal.SIGINT, signal_handler)
    while(True):
        time.sleep(1.1234)
        print "Working..."

def signal_handler(signal, frame):
    print 'You pressed Ctrl+C!'
    # for p in jobs:
    #     p.terminate()
    sys.exit(0)

if __name__ == "__main__":
    for i in range(50):
        p = multiprocessing.Process(target=worker)
        jobs.append(p)
        p.start()

Et c'est le genre de travail, mais je ne pense pas que c'est la bonne solution.

EDIT:
Cela peut être un doublon de cette une

InformationsquelleAutor zenpoy | 2012-07-03
  1. 60

    préalablement accepté solution a des conditions de course et il ne fonctionne pas avec map et async fonctions.

    La bonne façon de gérer les touches Ctrl+C/SIGINT avec multiprocessing.Pool est de:

    1. Rendre le processus ignorer SIGINT avant un processus de Pool est créé. De cette façon, créé processus enfants héritent SIGINT gestionnaire.
    2. Restaurer l'original SIGINT gestionnaire dans le processus parent après une Pool a été créé.
    3. Utilisation map_async et apply_async au lieu de bloquer map et apply.
    4. Attendre le résultat avec délai d'attente parce que le blocage par défaut attend ignorer tous les signaux. C'est Python bug https://bugs.python.org/issue8296.

    De les mettre ensemble:

    #!/bin/env python
from __future__ import print_function

import multiprocessing
import os
import signal
import time

def run_worker(delay):
    print("In a worker process", os.getpid())
    time.sleep(delay)

def main():
    print("Initializng 2 workers")
    original_sigint_handler = signal.signal(signal.SIGINT, signal.SIG_IGN)
    pool = multiprocessing.Pool(2)
    signal.signal(signal.SIGINT, original_sigint_handler)
    try:
        print("Starting 2 jobs of 5 seconds each")
        res = pool.map_async(run_worker, [5, 5])
        print("Waiting for results")
        res.get(60) # Without the timeout this blocking call ignores all signals.
    except KeyboardInterrupt:
        print("Caught KeyboardInterrupt, terminating workers")
        pool.terminate()
    else:
        print("Normal termination")
        pool.close()
    pool.join()

if __name__ == "__main__":
    main()

    Comme @YakovShklarov noté, il y a une fenêtre de temps entre ignorant le signal et unignoring dans le processus parent, au cours de laquelle le signal peut être perdu. À l'aide de pthread_sigmask au lieu de bloquer temporairement la livraison du signal dans le processus parent serait d'empêcher que le signal de la perte, cependant, il n'est pas disponible en Python-2.

    • Cette réponse fonctionne dans Windows avec Python 2.7.11 si un SIGINT jette un long traceback. Dans 3.5.2 cette réponse ne fonctionne pas - SIGINT jamais sorties. Au lieu de cela, vous obtenez KeyboardInterrupt et Process SpawnPoolWorker de messages et de retraçage de l'multitraitement module et vous devez tuer les processus lancés manuellement. L'on a accepté la réponse ne présentent pas ce comportement.
    • Uniquement testé avec Python 2.7.x.
    • Fonctionne aussi sur Linux (Ubuntu 16.04) avec Python 2.7.11. Cela devrait vraiment être la accepté de répondre.
    • on dirait que vous avez à utiliser map_async, pas de carte, n'importe qui peut faire allusion qu'à la différence de traitement unique? (appelant .obtenir sur le map_async résultat ne me semble pas nécessaire non plus)
    • Cette réponse va ignorer un SIGINT qui est envoyé entre les deux appels à la fonction signal(). D'ailleurs, êtes-vous certain que les sous-processus hériter SIG_IGN? Peut-être que vous pourriez utiliser du signal.pthread_sigmask() de bloquer et de débloquer SIGINT au lieu de cela, et de définir SIG_IGN à partir d'un pool d'initialiseur de fonction.
    • l'idéal serait, toutefois, cette API est absent en Python 2. En ce qui concerne le signal de la disposition de l'héritage - le chercher, ce serait une chose intelligente à faire.
    • Oh, vous avez raison. Elle est implicite dans le comportement de la fourche().
    • Laquelle a été la solution retenue abord mentionné? C'est maintenant la solution retenue.
    • Auparavant accepté de répondre: stackoverflow.com/a/11312948/412080
    • Cela n'a pas fonctionné pour moi avec Python 3.6.1 sur Windows 10, KeyboardInterrupt n'est pas pris
    • Il n'a pas été testé en python 3, et ni dans Windows.
    • Je vous remercie pour cette. Est-il possible de récupérer quelque chose d'enfants lors de la réception de KeyboardInterrupt ?
    • Je ne suis pas sûr, on aurait besoin pour enquêter à ce sujet.
    • Cette solution n'est pas portable car il fonctionne uniquement sur Unix. En outre, il ne serait pas fonctionner si l'utilisateur définit la maxtasksperchild Piscine paramètre. Le nouveau processus créés héritent de la norme SIGINT gestionnaire de nouveau. Le galets bibliothèque désactive SIGINT par défaut pour l'utilisateur dès que le nouveau processus est créé.

    InformationsquelleAutor Maxim Egorushkin
  2. 34

    La solution est basée sur ce lien et ce lien et il a résolu le problème, j'ai déménagé à Pool si:

    import multiprocessing
import time
import signal
import sys

def init_worker():
    signal.signal(signal.SIGINT, signal.SIG_IGN)

def worker():
    while(True):
        time.sleep(1.1234)
        print "Working..."

if __name__ == "__main__":
    pool = multiprocessing.Pool(50, init_worker)
    try:
        for i in range(50):
            pool.apply_async(worker)

        time.sleep(10)
        pool.close()
        pool.join()

    except KeyboardInterrupt:
        print "Caught KeyboardInterrupt, terminating workers"
        pool.terminate()
        pool.join()
    • C'est un peu trop tard: il y a une condition de concurrence fenêtre entre fork() de retour dans le processus de l'enfant et signal() appel. Le signal doit être bloqué avant de bifurquer.
    • le signal est bloqué dans init_worker qui est appelé avant la apply_async - est-ce que vous parlez?
    • Ce que je veux dire, c'est que le signal doit être bloqué avant que le processus enfant est fourchue et débloqué après. De cette façon, l'enfant hérite du masque de signal et n'a aucune chance de recevoir le signal.
    • Il n'est pas trop tard du tout. Aussi, init_worker n'est pas appelé avant apply_asyc. Ce qui se passe, init_worker fonction (comme objet) est passé à la Piscine de l'objet. Puis la piscine.apply_async est appelé et appelle en interne la init_worker fonction juste avant que l'enfant est fourchue. Pas sûr que la façon dont Piscine traite de déblocage du signal.
    • Cela ne fonctionne que parce que de temps en temps.sommeil. Si vous essayez de get() les résultats de la map_async appel au lieu de cela, l'interruption est retardée jusqu'à ce que le traitement est terminé.
    • J'obtiens: ValueError: le signal ne fonctionne que dans le thread principal
    • C'est une mauvaise réponse. Réponse correcte: stackoverflow.com/a/35134329/412080
    • Cette réponse fonctionne dans Windows avec Python 2.7.11 et 3.5.2.
    • Pool fourches, le nombre d'enfants des processus de l'exécution de init_worker premier et une fois par le processus enfant. Cela se produit avant async l'application de worker fonctions (du piscine mis à disposition) les processus enfants. Cela signifie que le SIG_IGN est appliqué à l'intérieur de chaque processus enfant et il n'est pas nécessaire pour piscine à traiter avec le déblocage du signal car il n'affecte pas le parent (@ChrisKoston). On peut vérifier avec print(os.getpid()) dans les deux init_worker et travailleur et prenez note de chaque travailleur pid aura eu un init_worker exécuter au préalable dans le processus avec le même pid.
    • Sûr qu'il fonctionne. Mais c'est faux. À partir de la documentation: "chaque travailleur processus d'appel d'initialiseur(*initargs) lorsqu'il démarre." C'est "quand", pas "avant". Donc: une condition de course. Voici ce qui peut arriver: Le sous-processus est créé, mais avant de signal.signal() se termine, SIGINT est envoyé! Le sous-processus s'interrompt avec une uncaught KeyboardInterrupt. C'est rare, mais il n'existe aucune garantie qu'il ne se produira pas. (En fait, il pourrait ne pas être si rare, si vous êtes à la ponte des tonnes de travailleurs.) Si vous ne bloquez pas, la pire chose qui puisse arriver, semble être juste crud sur votre terminal. Encore, c'est une mauvaise pratique.

    InformationsquelleAutor zenpoy
  3. 12

    Simplement manipuler KeyboardInterrupt-SystemExit des exceptions dans votre processus de travail:

    def worker():
    while(True):
        try:
            msg = self.msg_queue.get()
        except (KeyboardInterrupt, SystemExit):
            print("Exiting...")
            break
    • Pour les signaux qui font Python élever SystemExit, c'est en effet efficace, sur Python 3.6, trop. Je me demande bien, ce que les signaux qui ne comprennent? Je suppose SIGKILL et SIGTERM ...?
    • Vous pouvez facilement vérifier les signaux qui comprend et la réponse est: je pense que aucun. SystemExit n'est soulevée par sys.sortie en fonction de la documentation. Juste exécuter try: time.sleep(60) except BaseException as e: print(e) et vous verrez si un signal est pris (ime seulement SIGINT). C'est ce que la page de manuel unis aussi.
    InformationsquelleAutor derkan