Korzystanie z threading.Thread.join()

Question

Jestem nowy w wielowątkowość w python i próbuję nauczyć się wielowątkowości przy użyciu modułu wątków. Zrobiłem bardzo prosty program wielowątkowości i mam problem ze zrozumieniem metody threading.Thread.join.

Oto kod źródłowy programu zrobiłem

import threading 

val = 0 

def increment(): 
    global val 
    print "Inside increment" 
    for x in range(100): 
     val += 1 
    print "val is now {} ".format(val) 

thread1 = threading.Thread(target=increment, args=()) 
thread2 = threading.Thread(target=increment, args=()) 
thread1.start() 
#thread1.join() 
thread2.start() 
#thread2.join() 

Co to za różnica, czy używam

thread1.join() 
thread2.join() 

które pisali w powyższym kodzie? Uruchomiłem oba kody źródłowe (jeden z komentarzami i ten bez komentarzy), ale wynik jest taki sam.

Answer 1

Połączenie z numerem thread1.join() blokuje wątek, w którym nawiązujesz połączenie, do momentu zakończenia thread1. To jest jak wait_until_finished(thread1).

Na przykład:

import time 

def printer(): 
    for _ in range(3): 
     time.sleep(1.0) 
     print "hello" 

thread = Thread(target=printer) 
thread.start() 
thread.join() 
print "goodbye" 

drukuje

hello 
hello 
hello 
goodbye 

-bez zaproszenia .join(), goodbye przyjdzie, a potem 3 * hello.

Należy również pamiętać, że wątki w Pythonie nie zapewniają żadnej dodatkowej wydajności (pod względem mocy obliczeniowej procesora) z powodu czegoś zwanego Global Interpreter Lock, więc gdy są przydatne do odradzania potencjalnie blokowania (np. IO, sieć) i czasochłonne zadania (np. chrupanie numerów), aby główny wątek był wolny dla innych zadań, nie pozwalają one na wykorzystanie wielu rdzeni lub procesorów; w tym celu spójrz na multiprocessing, która używa podprocesów, ale udostępnia API równoważne z threading.

PLUG: ... i to jest również dla powyższego powodu, że, jeśli jesteś zainteresowany współbieżności, można również zajrzeć do drobnego biblioteki zwanej Gevent, które w istocie po prostu sprawia gwintem o wiele łatwiej używać, znacznie szybciej (gdy masz wiele równoczesnych działań) i mniej podatnych na błędy związane z współbieżnością, jednocześnie pozwalając ci zachować kodowanie w taki sam sposób, jak w przypadku "prawdziwych" wątków. Również Twisted, Eventlet, Tornado i wiele innych są równorzędne lub porównywalne. Ponadto, w każdym razie bym zdecydowanie wskazują przeczytaniu tych klasyków:

• Generator Tricks for Systems Programmers
• A Curious Course on Coroutines and Concurrency

Answer 2

Jako the relevant documentation stany, join sprawia, że ​​rozmówca czekać aż gwint kończy.

W twoim przypadku dane wyjściowe są takie same, ponieważ join nie zmienia zachowania programu - prawdopodobnie jest używane do całkowitego zamknięcia programu, tylko wtedy, gdy wszystkie wątki zostały zakończone.

Answer 3

Zmodyfikowałem kod, dzięki czemu zrozumiesz, jak dokładnie działa łączenie. więc uruchom ten kod z komentarzami i bez komentarzy i obserwuj dane wyjściowe dla obu.

val = 0 

def increment(msg,sleep_time): 
    global val 
    print "Inside increment" 
    for x in range(10): 
     val += 1 
     print "%s : %d\n" % (msg,val) 
     time.sleep(sleep_time) 

thread1 = threading.Thread(target=increment, args=("thread_01",0.5)) 
thread2 = threading.Thread(target=increment, args=("thread_02",1)) 
thread1.start() 
#thread1.join() 
thread2.start() 
#thread2.join()