Obrigado por esta discussão - também me ajudou muito.
Eu aprendi algo sobre .join () hoje.
Esses threads são executados em paralelo:
d.start()
t.start()
d.join()
t.join()
e estes são executados sequencialmente (não o que eu queria):
d.start()
d.join()
t.start()
t.join()
Em particular, eu estava tentando ser inteligente e arrumado:
class Kiki(threading.Thread):
def __init__(self, time):
super(Kiki, self).__init__()
self.time = time
self.start()
self.join()
Isso funciona! Mas é executado seqüencialmente. Eu posso colocar o self.start () em __ init __, mas não o self.join (). Isso tem que ser feito depois cada encadeamento.
join () é o que faz com que o thread principal aguarde o término do thread. Caso contrário, seu encadeamento será executado sozinho.
Portanto, uma maneira de pensar em join () como um "hold" no thread principal - meio que desassocia seu thread e é executado sequencialmente no thread principal, antes que o thread principal possa continuar. Assegura que seu encadeamento esteja completo antes que o encadeamento principal avance. Observe que isso significa que está tudo bem se o seu encadeamento já estiver concluído antes de você chamar o join () - o encadeamento principal é liberado imediatamente quando o join () é chamado.
De fato, agora me ocorre que o thread principal aguarda em d.join () até o thread d terminar antes de passar para t.join ().
De fato, para ser bem claro, considere este código:
import threading
import time
class Kiki(threading.Thread):
def __init__(self, time):
super(Kiki, self).__init__()
self.time = time
self.start()
def run(self):
print self.time, " seconds start!"
for i in range(0,self.time):
time.sleep(1)
print "1 sec of ", self.time
print self.time, " seconds finished!"
t1 = Kiki(3)
t2 = Kiki(2)
t3 = Kiki(1)
t1.join()
print "t1.join() finished"
t2.join()
print "t2.join() finished"
t3.join()
print "t3.join() finished"
Produz essa saída (observe como as instruções de impressão são encadeadas uma na outra.)
$ python test_thread.py
32 seconds start! seconds start!1
seconds start!
1 sec of 1
1 sec of 1 seconds finished!
21 sec of
3
1 sec of 3
1 sec of 2
2 seconds finished!
1 sec of 3
3 seconds finished!
t1.join() finished
t2.join() finished
t3.join() finished
$
O t1.join () está mantendo o encadeamento principal. Todos os três encadeamentos são concluídos antes que o t1.join () termine e o encadeamento principal prossiga para executar a impressão, depois t2.join () e, em seguida, imprima e t3.join () e depois imprima.
Correções são bem-vindas. Eu também sou novo no segmento.
(Observação: caso você esteja interessado, estou escrevendo um código para um DrinkBot e preciso executar rosqueamentos para executar as bombas de ingredientes simultaneamente e não sequencialmente - menos tempo para aguardar cada bebida.)