Co dokładnie robi metoda wieloprocesorowa modułu .join () Pythona?

Poznanie wieloprocesorowości w Pythonie (z artykułu PMOTW ) i chciałbym uzyskać wyjaśnienie, co dokładnie join()robi ta metoda.

W starym samouczku z 2008 roku stwierdza się, że bez p.join()wywołania w poniższym kodzie „proces potomny będzie siedział bezczynnie i nie zostanie zakończony, stając się zombie, którego należy ręcznie zabić”.

from multiprocessing import Process

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

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

Dodałem wydruk PID, a także time.sleepdo badania i ile mogę powiedzieć tego, zakończone jest proces na własną rękę:

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()

w ciągu 20 sekund:

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

po 20 sekundach:

947 ttys001    0:00.13 -bash

Zachowanie jest takie samo w przypadku p.join()dodania z powrotem na końcu pliku. Python Module of the Week oferuje bardzo czytelne wyjaśnienie modułu ; „Aby poczekać, aż proces zakończy swoją pracę i zakończy pracę, użyj metody join ().”, Ale wygląda na to, że przynajmniej OS X to robił.

Zastanawiam się też nad nazwą metody. Czy .join()metoda coś tutaj łączy? Czy łączy proces z jego zakończeniem? A może po prostu ma taką samą nazwę jak natywna .join()metoda Pythona ?

join()Metoda, gdy używana z threadinglub multiprocessingnie jest związane str.join()- to nie jest faktycznie złączenie wszystko razem. Oznacza raczej po prostu „poczekaj na zakończenie tego [wątku / procesu]”. Nazwa joinjest używana, ponieważ multiprocessinginterfejs API modułu ma wyglądać podobnie do threadinginterfejsu API modułu, a threadingmoduł używa joindla swojego Threadobiektu. Używając terminujoin oznaczającego „czekanie na zakończenie wątku” jest powszechne w wielu językach programowania, więc Python również go przyjął.

Powodem, dla którego widzisz 20-sekundowe opóźnienie zarówno z wywołaniem, jak i bez niego, join()jest to, że domyślnie, gdy proces główny jest gotowy do zakończenia, niejawnie wywoła join()wszystkie uruchomione multiprocessing.Processinstancje. W dokumentach nie jest to tak jasno określone, multiprocessingjak powinno, ale zostało to wspomniane w sekcji Wskazówki dotyczące programowania :

Pamiętaj również, że procesy inne niż demoniczne zostaną automatycznie połączone.

Możesz zmienić to zachowanie, ustawiając daemonflagę na Processto Trueprzed rozpoczęciem procesu:

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

Jeśli to zrobisz, proces potomny zostanie zakończony, gdy tylko zakończy się proces główny :

demon

Flaga demona procesu, wartość logiczna. Należy to ustawić przed wywołaniem metody start ().

Wartość początkowa jest dziedziczona z procesu tworzenia.

Kiedy proces kończy pracę, próbuje zakończyć wszystkie swoje demoniczne procesy potomne.

Bez tego join()główny proces może zakończyć się przed procesem potomnym. Nie jestem pewien, w jakich okolicznościach prowadzi to do zombieizmu.

Głównym celem join()jest zapewnienie, że proces podrzędny został zakończony, zanim proces główny zrobi cokolwiek, co zależy od pracy procesu podrzędnego.

Etymologia join()jest taka, że ​​jest przeciwieństwem fork, co jest powszechnym terminem w systemach operacyjnych z rodziny Unix do tworzenia procesów potomnych. Pojedynczy proces „dzieli się” na kilka, a następnie „łączy” z powrotem w jeden.

Nie zamierzam szczegółowo wyjaśniać, co to joinrobi, ale oto etymologia i intuicja, która za tym stoi, co powinno pomóc ci łatwiej zapamiętać jego znaczenie.

Chodzi o to, że wykonanie „ rozwidla ” wiele procesów, z których jeden jest panem, a pozostali pracownicy (lub „niewolnicy”). Kiedy robotnicy skończą, „dołączają” do kapitana, aby można było wznowić seryjną egzekucję.

joinMetoda powoduje, że proces główny czekać na pracownika do niej przyłączyć. Metoda mogłaby być lepiej nazwana „wait”, ponieważ takie właśnie zachowanie powoduje w masterze (i tak nazywa się w POSIX, chociaż wątki POSIX nazywają ją również „join”). Łączenie następuje tylko w wyniku prawidłowej współpracy nici, nie jest to coś, co robi mistrz .

Nazwy „fork” i „join” są używane w tym znaczeniu w przetwarzaniu wieloprocesowym od 1963 roku .

join()służy do oczekiwania na zakończenie procesu roboczego. Należy zadzwonić close()lub terminate()przed użyciem join().

Podobnie jak @Russell wspomniany łączenie jest przeciwieństwem forka (który wywołuje podprocesy).

Aby dołączyć do uruchomienia, musisz uruchomić, close()co zapobiegnie przesyłaniu kolejnych zadań do puli i wyjdzie po zakończeniu wszystkich zadań. Alternatywnie bieganieterminate() zakończy się natychmiastowym zatrzymaniem wszystkich procesów roboczych.

"the child process will sit idle and not terminate, becoming a zombie you must manually kill" jest to możliwe, gdy proces główny (nadrzędny) kończy pracę, ale proces potomny nadal działa, a po zakończeniu nie ma procesu nadrzędnego, do którego mógłby zwrócić swój kod zakończenia.

Te join(), zapewnia połączenia że kolejne linie kodu nie są wywoływane przed wieloprocesorowe wszystkie procesy są zakończone.

Na przykład bez tego join()poniższy kod zostanie wywołany restart_program()jeszcze przed zakończeniem procesów, co jest podobne do asynchronicznego i nie jest tym, czego chcemy (możesz spróbować):

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()

Aby poczekać, aż proces zakończy swoją pracę i zakończy działanie, użyj metody join ().

i

Uwaga Ważne jest, aby dołączyć () do procesu po jego zakończeniu, aby dać maszynom działającym w tle czas na zaktualizowanie stanu obiektu w celu odzwierciedlenia zakończenia.

To dobry przykład pomógł mi to zrozumieć: tutaj

Osobiście zauważyłem, że mój główny proces został wstrzymany, dopóki dziecko nie zakończyło swojego procesu przy użyciu metody join (), która pokonała cel, w jakim używałem multiprocessing.Process()w pierwszej kolejności.