Que fait exactement la méthode .join () du module de multitraitement Python?

En savoir plus sur le multitraitement Python (à partir d'un article de PMOTW ) et j'aimerais avoir des éclaircissements sur ce que fait exactement la join()méthode.

Dans un ancien tutoriel de 2008, il indique que sans l' p.join()appel dans le code ci-dessous, "le processus enfant restera inactif et ne se terminera pas, devenant un zombie que vous devez tuer manuellement".

from multiprocessing import Process

def say_hello(name='world'):
    print "Hello, %s" % name

p = Process(target=say_hello)
p.start()
p.join()

J'ai ajouté une impression du PIDainsi qu'un time.sleeppour tester et pour autant que je sache, le processus se termine tout seul:

from multiprocessing import Process
import sys
import time

def say_hello(name='world'):
    print "Hello, %s" % name
    print 'Starting:', p.name, p.pid
    sys.stdout.flush()
    print 'Exiting :', p.name, p.pid
    sys.stdout.flush()
    time.sleep(20)

p = Process(target=say_hello)
p.start()
# no p.join()

dans les 20 secondes:

936 ttys000    0:00.05 /Library/Frameworks/Python.framework/Versions/2.7/Reso
938 ttys000    0:00.00 /Library/Frameworks/Python.framework/Versions/2.7/Reso
947 ttys001    0:00.13 -bash

après 20 secondes:

947 ttys001    0:00.13 -bash

Le comportement est le même avec l' p.join()ajout à la fin du fichier. Le module Python de la semaine offre une explication très lisible du module ; "Pour attendre qu'un processus ait terminé son travail et se soit arrêté, utilisez la méthode join ().", Mais il semble qu'au moins OS X le fasse de toute façon.

Je me demande aussi le nom de la méthode. La .join()méthode concatène-elle quelque chose ici? S'agit-il de concaténer un processus avec sa fin? Ou partage-t-il simplement un nom avec la .join()méthode native de Python ?

La join()méthode, lorsqu'elle est utilisée avec threadingou multiprocessing, n'est pas liée à str.join()- elle ne concatène en fait rien. Au contraire, cela signifie simplement "attendez que ce [thread / processus] se termine". Le nom joinest utilisé car l' multiprocessingAPI du module est censée ressembler à l' threadingAPI du threadingmodule et que le module utilise joinpour son Threadobjet. Utiliser le terme joinpour signifier «attendre qu'un thread se termine» est courant dans de nombreux langages de programmation, donc Python vient de l'adopter également.

Maintenant, la raison pour laquelle vous voyez le délai de 20 secondes avec et sans l'appel à join()est que par défaut, lorsque le processus principal est prêt à quitter, il appellera implicitement join()toutes les multiprocessing.Processinstances en cours d'exécution . Ce n'est pas aussi clairement indiqué dans la multiprocessingdocumentation qu'il devrait l'être, mais il est mentionné dans la section Directives de programmation :

Souvenez-vous également que les processus non démoniaques seront automatiquement joints.

Vous pouvez remplacer ce comportement en définissant l' daemonindicateur sur le Processà Trueavant de démarrer le processus:

p = Process(target=say_hello)
p.daemon = True
p.start()
# Both parent and child will exit here, since the main process has completed.

Si vous faites cela, le processus enfant sera terminé dès que le processus principal sera terminé :

démon

L'indicateur de démon du processus, une valeur booléenne. Ceci doit être défini avant l'appel de start ().

La valeur initiale est héritée du processus de création.

Lorsqu'un processus se termine, il tente de mettre fin à tous ses processus enfants démoniaques.

Sans le join(), le processus principal peut se terminer avant le processus enfant. Je ne sais pas dans quelles circonstances cela conduit au zombieisme.

L'objectif principal de join()est de s'assurer qu'un processus enfant est terminé avant que le processus principal ne fasse quoi que ce soit qui dépend du travail du processus enfant.

L'étymologie de join()est que c'est l'opposé de fork, qui est le terme courant dans les systèmes d'exploitation de la famille Unix pour créer des processus enfants. Un seul processus "fourche" en plusieurs, puis "rejoint" en un seul.

Je ne vais pas expliquer en détail ce que joinfait, mais voici l'étymologie et l'intuition derrière cela, ce qui devrait vous aider à vous souvenir plus facilement de sa signification.

L'idée est que l'exécution " fourche " en plusieurs processus dont l'un est le maître, les autres ouvriers (ou "esclaves"). Lorsque les nœuds de calcul ont terminé, ils «rejoignent» le maître afin que l'exécution en série puisse reprendre.

La joinméthode oblige le processus maître à attendre qu'un travailleur le rejoigne. La méthode aurait mieux été appelée "wait", puisque c'est le comportement réel qu'elle provoque dans le maître (et c'est ce qu'elle appelle dans POSIX, bien que les threads POSIX l'appellent aussi "join"). La jonction se produit uniquement comme un effet des fils qui coopèrent correctement, ce n'est pas quelque chose que le maître fait .

Les noms «fork» et «join» sont utilisés dans ce sens dans le multiprocessing depuis 1963 .

join()est utilisé pour attendre la fermeture des processus de travail. Il faut appeler close()ou terminate()avant d'utiliser join().

Comme @Russell l'a mentionné, la jointure est comme l'opposé de fork (qui génère des sous-processus).

Pour que la jointure s'exécute, vous devez exécuter, close()ce qui empêchera toute autre tâche d'être soumise au pool et quittera une fois toutes les tâches terminées. Sinon, l'exécution se terminate()terminera simplement en arrêtant immédiatement tous les processus de travail.

"the child process will sit idle and not terminate, becoming a zombie you must manually kill" cela est possible lorsque le processus principal (parent) se termine mais que le processus enfant est toujours en cours d'exécution et qu'une fois terminé, il n'a pas de processus parent auquel retourner son état de sortie.

L' join()appel garantit que les lignes suivantes de votre code ne sont pas appelées avant que tous les processus de multitraitement ne soient terminés.

Par exemple, sans le join(), le code suivant sera appelé restart_program()avant même la fin des processus, ce qui est similaire à asynchrone et n'est pas ce que nous voulons (vous pouvez essayer):

num_processes = 5

for i in range(num_processes):
    p = multiprocessing.Process(target=calculate_stuff, args=(i,))
    p.start()
    processes.append(p)
for p in processes:
    p.join() # call to ensure subsequent line (e.g. restart_program) 
             # is not called until all processes finish

restart_program()

Pour attendre qu'un processus ait terminé son travail et quitte, utilisez la méthode join ().

et

Remarque Il est important de joindre () le processus après l'avoir terminé afin de donner à la machine d'arrière-plan le temps de mettre à jour le statut de l'objet pour refléter l'arrêt.

Ceci est un bon exemple m'a aidé à le comprendre: ici

Une chose que j'ai remarquée personnellement, c'est que mon processus principal a été mis en pause jusqu'à ce que l'enfant ait terminé son processus en utilisant la méthode join () qui a vaincu le point de moi d'utiliser multiprocessing.Process()en premier lieu.