Exécuter un processus et de quitter sans attendre qu'il

En Python sous Windows: j'ai besoin d'exécuter du code dans un processus séparé. Et je ne veux pas que les parents en attente pour elle à la fin. Essayé ceci:

from multiprocessing import Process
from time import sleep

def count_sheeps(number):
    """Count all them sheeps."""
    for sheep in range(number):
        sleep(1)

if __name__ == "__main__":
    p = Process(target=count_sheeps, args=(5,))
    p.start()
    print("Let's just forget about it and quit here and now.")
    exit()

qui commence le processus de l'enfant et continue l'exécution. Toutefois, lorsque le parent atteint la fin, il attend encore pour l'enfant à la sortie.

Est-il un moyen de laisser le parent quitter, même lorsque l'enfant est en cours d'exécution? Bien sûr, je pourrais juste de lancer une nouvelle interpréteur python à l'aide de subprocess.Popen et nourrir les moutons à compter comme un script séparé.

Encore, il y a ce module entier pour jouer avec des processus de code Python, donc j'aimerais en profiter au lieu de piratage sur le système d'exploitation. Aussi, ce serait génial si le même code fonctionné partout où Python n'a, pas seulement sur Windows.

Ici j'ai l'habitude de voir le problème inverse.

OriginalL'auteur Tomas Sedovic | 2009-11-11

  1. 4

    Utiliser le subprocess module que d'autres sous-processus les méthodes de contrôle (système d'exploitation.système os.spawn*, os.popen*, popen2., commandes.) sont désapprouvées:

    from subprocess import Popen
Popen( [ "foo.exe", "arg1", "arg2", "arg3" )

    Voir le Python doco, en particulier P_NOWAIT exemple.

    Vous devrez commencer un nouvel interpréteur Python dans le processus secondaire, de sorte que "foo.exe" ci-dessus sera probablement "python.exe".

    EDIT:

    Juste après avoir examiné la documentation du module multiprocessing:

    join_thread(): Rejoindre l'arrière-plan
    fil de discussion. Ce ne peut être utilisé après
    close() a été appelé. Il bloque
    jusqu'à ce que le thread d'arrière-plan des sorties, des
    veiller à ce que toutes les données dans la mémoire tampon
    a été vidées à la pipe.

    Par défaut si un processus n'est pas
    créateur de la file d'attente puis sur quitter
    va tenter de rejoindre la file d'attente du
    thread d'arrière-plan. Le processus peut
    appel cancel_join_thread() à faire
    join_thread() ne rien faire.

    cancel_join_thread(): Prévenir
    join_thread() de blocage. Dans
    en particulier, ce qui empêche le
    thread d'arrière-plan de joint
    automatiquement lorsque le processus s'arrête –
    voir join_thread().

    Il semble que vous devriez être en mesure d'appeler cancel_join_thread() pour obtenir le comportement que vous désirez. Je n'ai jamais utilisé cette méthode (et n'avait pas conscience de son existence jusqu'à il y a une minute!), donc, assurez-vous de laissez-nous savoir si cela fonctionne pour vous.

    Merci de ne pas import *.
    Assurez-vous - suppression de l'importation *
    cancel_join_thread() semble être quelque chose d'autre: de sorte que le processus peut sortir même lorsqu'une file d'attente qu'il utilise n'est pas vide. Toutefois, à moins qu'il existe une file d'attente en silence créé et comblé dans mon exemple, je ne pense pas que cela pourrait m'aider ici.
    Et merci pour le Popen exemples. J'ai déjà connaître et utiliser les sous-processus.Popen objet. C'est juste que j'espérais que cela pourrait être fait en utilisant le module multiprocessing à la place.

    OriginalL'auteur Daniel Paull

  2. 3

    Vous pouvez déclarer le processus de démon avec p.daemon = True. Comme http://docs.python.org/2/library/threading.html#thread-objects dit: "La signification de ce drapeau, c'est que l'ensemble du programme en Python ferme lorsque seuls les fils de démon sont de gauche."

    from multiprocessing import Process
from time import sleep

def count_sheeps(number):
    """Count all them sheeps."""
    for sheep in range(number):
        sleep(1)

if __name__ == "__main__":
    p = Process(target=count_sheeps, args=(5,))
    p.daemon = True
    p.start()
    print("Let's just forget about it and quit here and now.")
    exit()

    OriginalL'auteur ketorin

  3. 1

    Sous Linux, vous pourriez fork mais cela ne fonctionne pas sur Windows. Je pense que le plus simple est d'exécuter un nouveau Python processus, en mettant votre count_sheeps dans un autre fichier et Popen('python count_sheeps.py')

    Convenu - la seule difficulté est d'ordonnancement des arguments à la méthode. Assez facile pour count_sheeps( nombre ), où le "nombre" est un nombre entier. Pour des arguments complexes, le traitement multiple.Méthode de processus est une approche astucieuse!
    Ouais, c'est dommage, la fourche n'est pas sur Windows. Semble que je vais avoir à aller dans cette voie.

    OriginalL'auteur Jochen Ritzel

  4. -2

    Vous pouvez toujours commencer un nouveau fil de discussion, et de l'appeler myNewThread.démon(Vrai) avant de l'appeler la méthode start ().

    Ce thread va continuer à s'exécuter lorsque le processus s'arrête.

    Merci, mais pas vraiment. Les fils de démon sont tués lorsque le programme se termine. La differece de non-démoniaque threads, c'est que le programme les tue au lieu de les attendre à la fin de leur propre chef.
    AFAICT fil de démon est exactement ce qui est nécessaire dans la question d'origine. Il est vrai cependant que le fils de démon ne sont pas de gauche en cours d'exécution, qui était incorrect dans cette réponse.

    OriginalL'auteur richo