#!/usr/bin/env python                                                                                                                               
                                                                                                                                                    
import threading                                                                                                                                    
import time                                                                                                                                         
from random import randint                                                                                                                          
                                                                                                                                                    
#print time.strftime('%Y.%m.%d',time.localtime(time.time()))                                                                                        
print("主程序启动时间：%s"%(time.ctime()))                                                                                                          
def function(i):                                                                                                                                    
    sleep_time = randint(1,5)                                                                                                                       
    time.sleep(sleep_time)             #子线程会同步启动,为了区分,每个子线程延迟一个随机秒数.                                                       
    if i in [1, 4]:                                                                                                                                 
        print('-'*3+"Start第%s个子线程%s,设定为守护线程,启动后睡眠了%s秒,开始工作时间是：%s"%(i+1,threading.current_thread().name,sleep_time,time.st
rftime('%H:%M:%S')))                                                                                                                                
    elif i == 2:                                                                                                                                    
        print('-'*3+"Start第%s个子线程%s,阻塞了主线程1秒,启动后睡眠了%s秒,开始工作时间是：%s"%(i+1,threading.current_thread().name,sleep_time,time.s
trftime('%H:%M:%S')))                                                                                                                               
    elif i == 3:                                                                                                                                    
        print('-'*3+"Start第%s个子线程%s,阻塞主线程到本子线程运行结束,启动后睡眠了%s秒,开始工作时间是：%s"%(i+1,threading.current_thread().name,slee
p_time,time.strftime('%H:%M:%S')))                                                                                                                  
    else:                                                                                                                                           
        print('-'*3+"Start第%s个子线程%s,启动后睡眠了%s秒,开始工作时间是：%s"%(i+1,threading.current_thread().name,sleep_time,time.strftime('%H:%M:%
S')))                                                                                                                                               
    run_time = randint(3,10)                                                                                                                        
    time.sleep(run_time)               #模拟子线程运行一个随机时长                                                                                  
    print('*'*3+"End第%s个子线程,工作了%s秒,结束时间是：%s"%(i+1,run_time,time.strftime('%H:%M:%S')))                                               
                                                                                                                                                    
# 列表解析生成5个子线程列表                                                                                                                         
threads=[threading.Thread(target=function,name='worker_'+str(i+1),args=(i,) ) for i in range(5)]                                                    
#print(threads)                                                                                                                                     
#print(threads[2])                                                                                                                                  
print('#'*3+"同步启动子线程.开始启动时间是：%s"%(time.strftime('%H:%M:%S')))                                                                        
for i,t in enumerate(threads):                                                                                                                      
    if i == 0:                                                                                                                                      
        t.start()                    #该子线程能正常运行到结束,不受主线程是否结束影响.                                                              
    elif i == 2:                                                                                                                                    
        t.start()                                                                                                                                   
        t.join(1)                    #阻塞主线程及后面的for循环1秒,join给定时间参数,就阻塞相应的秒数,没给定就阻塞到当前子线程终止.                  
    elif i == 3:                                                                                                                                    
        t.start()                                                                                                                                   
        t.join()                     #阻塞主线程,使与当前子线程同步,需等当前子线程结束后才可以回到主线程继续后面的for循环.                          
    else:                                                                                                                                           
        t.setDaemon(True)            #设置主线程为守护线程,即主线程结束时,该子线程也立马结束,若还未启动,则不会启动;该设置需要在start()之前设置.     
        t.start()                                                                                                                                   
print("我是主线程,回到主线程时间是：%s"%(time.ctime()))

$ ./python_threading_join.py                                                                                                                        
主程序启动时间：Thu Nov 28 23:10:21 2019                                                                                                            
###同步启动子线程.开始启动时间是：23:10:21                                                                                                          
---Start第2个子线程worker_2,设定为守护线程,启动后睡眠了1秒,开始工作时间是：23:10:22                                                                 
---Start第3个子线程worker_3,阻塞了主线程1秒,启动后睡眠了1秒,开始工作时间是：23:10:22                                                                
---Start第1个子线程worker_1,启动后睡眠了5秒,开始工作时间是：23:10:26                                                                                
---Start第4个子线程worker_4,阻塞主线程到本子线程运行结束,启动后睡眠了4秒,开始工作时间是：23:10:26                                                   
***End第2个子线程,工作了7秒,结束时间是：23:10:29                                                                                                    
***End第3个子线程,工作了7秒,结束时间是：23:10:29                                                                                                    
***End第4个子线程,工作了4秒,结束时间是：23:10:30                                                                                                    
我是主线程,回到主线程时间是：Thu Nov 28 23:10:30 2019                                                                                               
---Start第5个子线程worker_5,设定为守护线程,启动后睡眠了2秒,开始工作时间是：23:10:32                                                                 
***End第1个子线程,工作了10秒,结束时间是：23:10:36