blocks|key|152496|text|演示该机制的一个有点笨拙的ascii艺术：join()大概是由主线程调用的。它也可以由另一个线程调用，但会不必要地使图表复杂化。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|152497|join-calling应该放在主线程的轨道中，但为了表达线程关系并使其尽可能简单，我选择将其放在子线程中。|152498|without+join:
%2B---%2B---%2B------------------+++++++++++++++++++++main-thread
++++%7C+++%7C
++++%7C+++%2B...........++++++++++++++++++++++++++++child-thread(short)
++++%2B..................................+++++++++child-thread(long)

with+join
%2B---%2B---%2B------------------***********%2B###++++++main-thread
++++%7C+++%7C+++++++++++++++++++++++++++++%7C
++++%7C+++%2B...........join()++++++++++++%7C+++++++++child-thread(short)
++++%2B......................join()......+++++++++child-thread(long)

with+join+and+daemon+thread
%2B-%2B--%2B---%2B------------------***********%2B###+++++parent-thread
++%7C++%7C+++%7C+++++++++++++++++++++++++++++%7C
++%7C++%7C+++%2B...........join()++++++++++++%7C++++++++child-thread(short)
++%7C++%2B......................join()......++++++++child-thread(long)
++%2B,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,+++++child-thread(long+%2B+daemonized)

'-'+main-thread/parent-thread/main-program+execution
'.'+child-thread+execution
'#'+optional+parent-thread+execution+after+join()-blocked+parent-thread+could+
++++continue
'*'+main-thread+'sleeping'+in+join-method,+waiting+for+child-thread+to+finish
','+daemonized+thread+-+'ignores'+lifetime+of+other+threads;
++++terminates+when+main-programs+exits;+is+normally+meant+for+
++++join-independent+tasks|code-block|syntax|javascript|152499|所以你看不到任何变化的原因是因为你的主线程在你的join之后不做任何事情。您可以说join+(仅)与主线程的执行流相关。|152500|例如，如果您想并发下载一组页面以将它们连接成一个大页面，您可以使用线程开始并发下载，但需要等到最后一个页面/线程完成后才能开始组装多个页面中的单个页面。这就是你使用join()的时候。|152501|entityMap^0|L|6|0|0|4|0|0|O|4|15|4|0|2A|6|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|V|8|@$9|W|A|X|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|Y|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|Z|8|@$9|10|A|11|B|C]|$9|12|A|13|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|14|8|@$9|15|A|16|B|C]]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|17|8|@]|D|@]|E|$]]]|R|$]]

A somewhat clumsy ascii-art to demonstrate the mechanism:
The <code>join()</code> is presumably called by the main-thread. It could also be called by another thread, but would needlessly complicate the diagram.

<code>join</code>-calling should be placed in the track of the main-thread, but to express thread-relation and keep it as simple as possible, I choose to place it in the child-thread instead.

<pre><code>without join:
+---+---+------------------ main-thread
 | |
 | +........... child-thread(short)
 +.................................. child-thread(long)

with join
+---+---+------------------***********+### main-thread
 | | |
 | +...........join() | child-thread(short)
 +......................join()...... child-thread(long)

with join and daemon thread
+-+--+---+------------------***********+### parent-thread
 | | | |
 | | +...........join() | child-thread(short)
 | +......................join()...... child-thread(long)
 +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, child-thread(long + daemonized)

'-' main-thread/parent-thread/main-program execution
'.' child-thread execution
'#' optional parent-thread execution after join()-blocked parent-thread could 
 continue
'*' main-thread 'sleeping' in join-method, waiting for child-thread to finish
',' daemonized thread - 'ignores' lifetime of other threads;
 terminates when main-programs exits; is normally meant for 
 join-independent tasks
</code></pre>

So the reason you don't see any changes is because your main-thread does nothing after your <code>join</code>.
You could say <code>join</code> is (only) relevant for the execution-flow of the main-thread.

If, for example, you want to concurrently download a bunch of pages to concatenate them into a single large page, you may start concurrent downloads using threads, but need to wait until the last page/thread is finished before you start assembling a single page out of many. That's when you use <code>join()</code>.

blocks|key|370798|text|当同时为非守护程序线程和守护程序线程创建join(t)函数时，主线程(或主进程)应该等待t秒，然后才能继续处理它自己的进程。在t秒的等待时间内，两个子线程都应该做它们能做的事情，比如打印出一些文本。在t秒之后，如果非守护程序线程仍然没有完成它的作业，并且它仍然可以在主进程完成它的作业之后完成它，但是对于守护程序线程，它刚刚错过了它的机会窗口。但是，它最终会在python程序退出后终止。如果有什么问题，请纠正我。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|370799|entityMap^0|K|7|18|1|1R|1|2S|1|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|G|$]]

When making <code>join(t)</code> function for both non-daemon thread and daemon thread, the main thread (or main process) should wait <code>t</code> seconds, then can go further to work on its own process. During the <code>t</code> seconds waiting time, both of the children threads should do what they can do, such as printing out some text. After the <code>t</code> seconds, if non-daemon thread still didn't finish its job, and it still can finish it after the main process finishes its job, but for daemon thread, it just missed its opportunity window. However, it will eventually die after the python program exits. Please correct me if there is something wrong.

blocks|key|370814|text|此示例演示.join()操作：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|370815|import+threading
import+time

def+threaded_worker():
++++for+r+in+range(10):
++++++++print('Other:+',+r)
++++++++time.sleep(2)

thread_+=+threading.Timer(1,+threaded_worker)
thread_.daemon+=+True++#+If+the+main+thread+is+killed,+this+thread+will+be+killed+as+well.+
thread_.start()

flag+=+True

for+i+in+range(10):
++++print('Main:+',+i)
++++time.sleep(2)
++++if+flag+and+i+>+4:
++++++++print(
++++++++++++'''
++++++++++++Threaded_worker()+joined+to+the+main+thread.+
++++++++++++Now+we+have+a+sequential+behavior+instead+of+concurrency.
++++++++++++''')
++++++++thread_.join()
++++++++flag+=+False|code-block|syntax|javascript|370816|370817|输出：|370818|Main:++0
Other:++0
Main:++1
Other:++1
Main:++2
Other:++2
Main:++3
Other:++3
Main:++4
Other:++4
Main:++5
Other:++5

++++++++++++Threaded_worker()+joined+to+the+main+thread.+
++++++++++++Now+we+have+a+sequential+behavior+instead+of+concurrency.
++++++++++++
Other:++6
Other:++7
Other:++8
Other:++9
Main:++6
Main:++7
Main:++8
Main:++9|370819|entityMap^0|5|7|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|U|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|V|8|@]|D|@]|E|$]]|$1|L|3|M|5|6|7|W|8|@]|D|@]|E|$]]|$1|N|3|O|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|P|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|Q|$]]

This example demonstrate the <code>.join()</code> action:
<pre><code>import threading
import time

def threaded_worker():
 for r in range(10):
 print('Other: ', r)
 time.sleep(2)

thread_ = threading.Timer(1, threaded_worker)
thread_.daemon = True # If the main thread is killed, this thread will be killed as well. 
thread_.start()

flag = True

for i in range(10):
 print('Main: ', i)
 time.sleep(2)
 if flag and i &gt; 4:
 print(
 '''
 Threaded_worker() joined to the main thread. 
 Now we have a sequential behavior instead of concurrency.
 ''')
 thread_.join()
 flag = False
</code></pre>
<hr />
Out:
<pre><code>Main: 0
Other: 0
Main: 1
Other: 1
Main: 2
Other: 2
Main: 3
Other: 3
Main: 4
Other: 4
Main: 5
Other: 5

 Threaded_worker() joined to the main thread. 
 Now we have a sequential behavior instead of concurrency.
 
Other: 6
Other: 7
Other: 8
Other: 9
Main: 6
Main: 7
Main: 8
Main: 9
</code></pre>

blocks|key|370851|text|在python3.x中，join()用于连接线程和主线程，也就是说，当join()用于特定线程时，主线程将停止执行，直到连接的线程执行完毕。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|370852|#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!+

'''|code-block|syntax|javascript|370853|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

In python 3.x join() is used to join a thread with the main thread i.e. when join() is used for a particular thread the main thread will stop executing until the execution of joined thread is complete.

<pre><code>#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()--&gt; 
You are loitering!
Hey, I do not want to loiter!
You are not loitering anymore! #After 5 seconds --&gt; 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() --&gt;
You are loitering!
You are not loitering anymore! #After 5 seconds --&gt; This statement will be printed
Hey, I do not want to loiter! 

'''
</code></pre>

I was studying the python threading and came across <a href="http://docs.python.org/2/library/threading.html#threading.Thread.join" rel="noreferrer"><code>join()</code></a>.

The author told that if thread is in daemon mode then i need to use <code>join()</code> so that thread can finish itself before main thread terminates.

but I have also seen him using <code>t.join()</code> even though <code>t</code> was not <code>daemon</code>

example code is this

<pre><code>import threading
import time
import logging

logging.basicConfig(level=logging.DEBUG,
 format='(%(threadName)-10s) %(message)s',
 )

def daemon():
 logging.debug('Starting')
 time.sleep(2)
 logging.debug('Exiting')

d = threading.Thread(name='daemon', target=daemon)
d.setDaemon(True)

def non_daemon():
 logging.debug('Starting')
 logging.debug('Exiting')

t = threading.Thread(name='non-daemon', target=non_daemon)

d.start()
t.start()

d.join()
t.join()
</code></pre>

i don't know what is use of <code>t.join()</code> as it is not daemon and i can see no change even if i remove it

What is the use of join() in Python threading?

我在研究python线程的时候偶然发现了。作者告诉我，如果线程处于守护进程模式，那么我需要使用join()，这样线程就可以在主线程终止之前完成自己的工作。但我也见过他使用t.join()，尽管t不是daemon示例代码是这样的import threadingimport timeimport loggingloggin...

问在Python线程中join()的用途是什么？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Python线程中join()的用途是什么？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Python线程中join()的用途是什么？
EN