python多线程ctrl-c退出问题

场景：

经常会遇到下述问题：很多io busy的应用采取多线程的方式来解决，但这时候会发现python命令行不响应ctrl-c 了，而对应的java代码则没有问题：

1. public class Test {
2. public static void main(String[] args) throws Exception {
3. new Thread(new Runnable() {
4. public void run() {
5. long start = System.currentTimeMillis();
6. while (true) {
7. try {
8. Thread.sleep(1000);
9. } catch (Exception e) {
10. }
11. System.out.println(System.currentTimeMillis());
12. if (System.currentTimeMillis() - start > 1000 * 100) break;
13. }
14. }
15. }).start();
16. }
17. }

java Test

ctrl-c则会结束程序

而对应的python代码：

1. # -*- coding: utf-8 -*-
2. import time
3. import threading
4. start=time.time()
5. def foreverLoop():
6. start=time.time()
7. while 1:
8. time.sleep(1)
9. print time.time()
10. if time.time()-start>100:
11. break
12. thread_=threading.Thread(target=foreverLoop)
13. #thread_.setDaemon(True)
14. thread_.start()

python p.py

后ctrl-c则完全不起作用了。

不成熟的分析：

首先单单设置 daemon 为 true 肯定不行，就不解释了。当daemon为 false 时，导入python线程库后实际上，threading会在主线程执行完毕后，检查是否有不是 daemon 的线程，有的化就wait，等待线程结束了，在主线程等待期间，所有发送到主线程的信号也会被阻测，可以在上述代码加入signal模块验证一下：

1. def sigint_handler(signum,frame):
2. print "main-thread exit"
3. sys.exit()
4. signal.signal(signal.SIGINT,sigint_handler)

在100秒内按下ctrl－c没有反应，只有当子线程结束后才会出现打印 "main-thread exit",可见 ctrl-c被阻测了

threading 中在主线程结束时进行的操作：

1. _shutdown = _MainThread()._exitfunc
2. def _exitfunc(self):
3. self._Thread__stop()
4. t = _pickSomeNonDaemonThread()
5. if t:
6. if __debug__:
7. self._note("%s: waiting for other threads", self)
8. while t:
9. t.join()
10. t = _pickSomeNonDaemonThread()
11. if __debug__:
12. self._note("%s: exiting", self)
13. self._Thread__delete()

对所有的非daemon线程进行join等待，其中join中可自行察看源码，又调用了wait，同上文分析 ，主线程等待到了一把锁上。

不成熟的解决：

只能把线程设成daemon才能让主线程不等待，能够接受ctrl－c信号，但是又不能让子线程立即结束，那么只能采用传统的轮询方法了，采用sleep间歇省点cpu吧：

1. # -*- coding: utf-8 -*-
2. import time,signal,traceback
3. import sys
4. import threading
5. start=time.time()
6. def foreverLoop():
7. start=time.time()
8. while 1:
9. time.sleep(1)
10. print time.time()
11. if time.time()-start>5:
12. break
13. thread_=threading.Thread(target=foreverLoop)
14. thread_.setDaemon(True)
15. thread_.start()
16. #主线程wait住了,不能接受信号了
17. #thread_.join()
18. def _exitCheckfunc():
19. print "ok"
20. try:
21. while 1:
22. alive=False
23. if thread_.isAlive():
24. alive=True
25. if not alive:
26. break
27. time.sleep(1)
28. #为了使得统计时间能够运行，要捕捉  KeyboardInterrupt :ctrl-c
29. except KeyboardInterrupt, e:
30. traceback.print_exc()
31. print "consume time :",time.time()-start
32. threading._shutdown=_exitCheckfunc

缺点：轮询总会浪费点cpu资源，以及battery.

有更好的解决方案敬请提出。

ps1: 进程监控解决方案 ：

用另外一个进程来接受信号后杀掉执行任务进程，牛

1. # -*- coding: utf-8 -*-
2. import time,signal,traceback,os
3. import sys
4. import threading
5. start=time.time()
6. def foreverLoop():
7. start=time.time()
8. while 1:
9. time.sleep(1)
10. print time.time()
11. if time.time()-start>5:
12. break
13. class Watcher:
14. """this class solves two problems with multithreaded
15. programs in Python, (1) a signal might be delivered
16. to any thread (which is just a malfeature) and (2) if
17. the thread that gets the signal is waiting, the signal
18. is ignored (which is a bug).
19. The watcher is a concurrent process (not thread) that
20. waits for a signal and the process that contains the
21. threads.  See Appendix A of The Little Book of Semaphores.
22. http://greenteapress.com/semaphores/
23. I have only tested this on Linux.  I would expect it to
24. work on the Macintosh and not work on Windows.
25. """
26. def __init__(self):
27. """ Creates a child thread, which returns.  The parent
28. thread waits for a KeyboardInterrupt and then kills
29. the child thread.
30. """
31. self.child = os.fork()
32. if self.child == 0:
33. return
34. else:
35. self.watch()
36. def watch(self):
37. try:
38. os.wait()
39. except KeyboardInterrupt:
40. # I put the capital B in KeyBoardInterrupt so I can
41. # tell when the Watcher gets the SIGINT
42. print 'KeyBoardInterrupt'
43. self.kill()
44. sys.exit()
45. def kill(self):
46. try:
47. os.kill(self.child, signal.SIGKILL)
48. except OSError: pass
49. Watcher()
50. thread_=threading.Thread(target=foreverLoop)
51. thread_.start()

 注意 watch()一定要放在线程创建前，原因未知。。。。，否则立刻就结束