怎么杀死子线程啊

盖茨他爹

1. #!/usr/bin/python
   
2. # -*- coding: UTF-8 -*-
   
3. 
   
4. import time
   
5. import thread
   
6. 
   
7. def son(xxx,yyy):
   
8.     time.sleep(10000)
   
9. 
   
10. def father():
    
11.     thread.start_new_thread(son,(1,2))
    
12.     time.sleep(10)
    
13.     #10秒钟后杀死子线程，在这里怎么操作啊
    
14. 
    
15. if __name__ == "__main__":
    
16.     father()

复制代码

假定子线程是持续执行的，没有循环(没法让son自己thread.exit())，怎么在子线程外部杀死它啊，也就是在父线程father()里面进行怎样的操作才能杀死son啊，如果thread不行用threading也行，高手支个招啊，在Google和百度上搜了一晚上的资料了{:3_184:}

luffy.deng

setDaemon(True)

marryton007

setDaemon() 是可以退出，但不能干净的退出，如果子线程中正在进行某项关键性的任务，也许需要在退出前做一些保存或清理工作，这时用setDaemon就不太合适了，比如：

1. 
   
2. #!/usr/bin/python
   
3. # -*- coding: utf-8 -*-
   
4. 
   
5. import time
   
6. import threading
   
7. 
   
8. 
   
9. def son(xxx,yyy):
   
10.     fd = None
    
11.     try:
    
12.         fd = open('/tmp/axx.txt', 'w')
    
13.         while 1:
    
14.             time.sleep(1)
    
15.             fd.write("I am aliving\n")
    
16.     except Exception,ex:
    
17.         raise
    
18.     finally:
    
19.         print "close the open file"
    
20.         if fd:
    
21.             fd.close()
    
22.         
    
23. 
    
24. 
    
25. def father():
    
26.     t = threading.Thread(target=son,args=(1,2))
    
27.     t.setDaemon(True)
    
28.     t.start()
    
29.     time.sleep(10)
    
30.     #10秒钟后杀死子线程，在这里怎么操作啊
    
31. 
    
32. 
    
33. if __name__ == "__main__":
    
34.     father()
    
35. 
    

复制代码

盖茨他爹

抱歉，忘了交代一点，把子线程杀死以后父线程还要继续进行，我在网上查了很多资料说Python不支持杀死子线程，是不是真的没法实现啊

盖茨他爹

刚才用子线程又建了一个孙线程，企图用子线程结束的方式结束孙线程，结果发现孙线程并不会随着子线程的退出而退出，而是随着父线程的退出而退出{:3_188:}

1. #!/usr/bin/python
   
2. # -*- coding: UTF-8 -*-
   
3. 
   
4. import time
   
5. import thread
   
6. import threading
   
7. 
   
8. flag = 0
   
9. 
   
10. def grandson(xxx,yyy):
    
11.     for i in range(0,20):
    
12.         time.sleep(1)
    
13.         print "grandson"
    
14. 
    
15. 
    
16. def son(xxx,yyy):
    
17.     global flag
    
18.     u = threading.Thread(target=grandson,args=(1,2))
    
19.     u.setDaemon(True)
    
20.     u.start()
    
21.     while True:
    
22.         if flag == 1:
    
23.             break
    
24.         time.sleep(1)
    
25.         print "son"
    
26. 
    
27. def father():
    
28.     global flag
    
29.     t = threading.Thread(target=son,args=(1,2))
    
30.     t.setDaemon(True)
    
31.     t.start()
    
32.     i = 0
    
33.     while True:
    
34.         if i == 5:
    
35.             flag = 1
    
36.         time.sleep(1)
    
37.         i = i + 1
    
38.         print "father"
    
39. 
    
40. if __name__ == "__main__":
    
41.     father()

复制代码

盖茨他爹

如果需要被杀死的那个子线程里面有循环就好了，可以在子线程里面检测全局变量的变化，然后自己结束，但是这个子线程是持续的，怎么在父线程不结束的情况下掐断它呢{:3_199:}

盖茨他爹

Python 不支持杀死子线程
http://blog.solrex.org/articles/python-thread-cancel.html

很遗憾啊，如果实在没办法只能用进程了

smallfish_xy

呵呵，是不可以的。

luffy.deng

回复 7# 盖茨他爹

可以设置一个全局变量，通知子线程结束，比如

1. import threading  
   
2. import time
   
3. flag=1
   
4. class timer(threading.Thread):
   
5.     def run(self):
   
6.         global flag
   
7.         while flag==1:
   
8.             print flag
   
9.             print 'Thread Object (%d), Time:%s'%(1,time.ctime())   
   
10.             time.sleep(1)
    
11. 
    
12. def test():
    
13.     global flag
    
14.     threadone=timer()   
    
15.     threadone.start()
    
16.     time.sleep(5)
    
17.     flag=0
    
18.       
    
19. if __name__=='__main__':   
    
20.     test()  

复制代码

盖茨他爹

回复 9# luffy.deng


    需要被杀死的那个子线程是持续的，没有循环的(比如一个HttpServer服务)，所以子线程也没有机会去循环取读那个全局变量，我在5楼用子线程建了一个孙线程，用孙线程来执行那个持续的任务，用子线程去循环取读那个全局变量，但是子线程退出了孙线程并没有随着子线程退出