이 글에 감사드립니다-나에게 많은 도움이되었습니다.

오늘 .join ()에 대해 배웠습니다.

이 스레드는 병렬로 실행됩니다.

d.start()
t.start()
d.join()
t.join()

그리고 이들은 순차적으로 실행됩니다 (원하는 것이 아님).

d.start()
d.join()
t.start()
t.join()

특히, 나는 영리하고 깔끔하게 노력했습니다.

class Kiki(threading.Thread):
    def __init__(self, time):
        super(Kiki, self).__init__()
        self.time = time
        self.start()
        self.join()

작동합니다! 그러나 순차적으로 실행됩니다. self.start ()를 __ init __에 넣을 수 있지만 self.join ()을 넣을 수는 없습니다. 모든 스레드가 시작된 후에 수행해야합니다 .

join ()은 메인 스레드가 스레드가 완료 될 때까지 대기하게하는 원인입니다. 그렇지 않으면 스레드가 자체적으로 실행됩니다.

따라서 메인 스레드에서 join ()을 “hold”로 생각하는 한 가지 방법은 메인 스레드를 계속하기 전에 스레드를 스레드 해제하고 메인 스레드에서 순차적으로 실행하는 것입니다. 메인 스레드가 앞으로 이동하기 전에 스레드가 완료되었는지 확인합니다. join ()을 호출하기 전에 스레드가 이미 완료된 경우 괜찮습니다. 기본 스레드는 join ()이 호출 될 때 즉시 해제됩니다.

사실, 메인 스레드가 스레드 d가 t.join ()으로 이동하기 전에 완료 될 때까지 d.join ()에서 대기합니다.

실제로 매우 명확하게 다음 코드를 고려하십시오.

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"

이 출력을 생성합니다 (인쇄 문이 서로 스레드되는 방식에 유의하십시오).

$ 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
$ 

t1.join ()이 메인 스레드를 잡고 있습니다. t1.join ()이 끝나기 전에 3 개의 스레드가 모두 완료되고 메인 스레드가 인쇄를 실행 한 다음 t2.join ()을 인쇄 한 다음 t3.join ()을 인쇄하고 인쇄합니다.

정정을 환영합니다. 또한 스레딩을 처음 사용합니다.

(참고 : 관심이 있으시면 DrinkBot 용 코드를 작성 중이며 성분 펌프를 순차적으로 실행하지 않고 동시에 실행하기 위해 스레딩이 필요합니다. 각 음료를 기다리는 시간이 짧습니다.)

답변

>>> from threading import Thread
>>> import time
>>> def sam():
...   print 'started'
...   time.sleep(10)
...   print 'waiting for 10sec'
...
>>> t = Thread(target=sam)
>>> t.start()
started

>>> t.join() # with join interpreter will wait until your process get completed or terminated
done?   # this line printed after thread execution stopped i.e after 10sec
waiting for 10sec
>>> done?

>>> t = Thread(target=sam)
>>> t.start()
started
>>> print 'yes done' #without join interpreter wont wait until process get terminated
yes done
>>> waiting for 10sec

#1 - Without Join():
import threading
import time
def loiter():
    print('You are loitering!')
    time.sleep(5)
    print('You are not loitering anymore!')

t1 = threading.Thread(target = loiter)
t1.start()
print('Hey, I do not want to loiter!')
'''
Output without join()-->
You are loitering!
Hey, I do not want to loiter!
You are not loitering anymore! #After 5 seconds --> This statement will be printed

'''
#2 - With Join():
import threading
import time
def loiter():
    print('You are loitering!')
    time.sleep(5)
    print('You are not loitering anymore!')

t1 = threading.Thread(target = loiter)
t1.start()
t1.join()
print('Hey, I do not want to loiter!')

'''
Output with join() -->
You are loitering!
You are not loitering anymore! #After 5 seconds --> This statement will be printed
Hey, I do not want to loiter!

'''