资讯专栏INFORMATION COLUMN

Python:线程之定位与销毁

Heier / 1361人阅读

摘要:而线程则是每秒通过输出当前进程内所有活跃的线程。如果使用强制手段干掉线程,那么很大几率出现意想不到的。只是通过来约束这些线程,来决定什么时候开始调度,比方说运行了多少个指令就交出,至于谁夺得花魁,得听操作系统的。

背景

开工前我就觉得有什么不太对劲,感觉要背锅。这可不,上班第三天就捅锅了。

我们有个了不起的后台程序,可以动态加载模块,并以线程方式运行,通过这种形式实现插件的功能。而模块更新时候,后台程序自身不会退出,只会将模块对应的线程关闭、更新代码再启动,6 得不行。

于是乎我就写了个模块准备大展身手,结果忘记写退出函数了,导致每次更新模块都新创建一个线程,除非重启那个程序,否则那些线程就一直苟活着。

这可不行啊,得想个办法清理呀,要不然怕是要炸了。

那么怎么清理呢?我能想到的就是两步走:

找出需要清理的线程号 tid;

销毁它们;

找出线程ID

和平时的故障排查相似,先通过 ps 命令看看目标进程的线程情况,因为已经是 setName 设置过线程名,所以正常来说应该是看到对应的线程的。 直接用下面代码来模拟这个线程:

Python 版本的多线程

</>复制代码

  1. #coding: utf8
  2. import threading
  3. import os
  4. import time
  5. def tt():
  6. info = threading.currentThread()
  7. while True:
  8. print "pid: ", os.getpid()
  9. print info.name, info.ident
  10. time.sleep(3)
  11. t1 = threading.Thread(target=tt)
  12. t1.setName("OOOOOPPPPP")
  13. t1.setDaemon(True)
  14. t1.start()
  15. t2 = threading.Thread(target=tt)
  16. t2.setName("EEEEEEEEE")
  17. t2.setDaemon(True)
  18. t2.start()
  19. t1.join()
  20. t2.join()

输出:

</>复制代码

  1. root@10-46-33-56:~# python t.py
  2. pid: 5613
  3. OOOOOPPPPP 139693508122368
  4. pid: 5613
  5. EEEEEEEEE 139693497632512
  6. ...

可以看到在 Python 里面输出的线程名就是我们设置的那样,然而 Ps 的结果却是令我怀疑人生:

</>复制代码

  1. root@10-46-33-56:~# ps -Tp 5613
  2. PID SPID TTY TIME CMD
  3. 5613 5613 pts/2 00:00:00 python
  4. 5613 5614 pts/2 00:00:00 python
  5. 5613 5615 pts/2 00:00:00 python

正常来说不该是这样呀,我有点迷了,难道我一直都是记错了?用别的语言版本的多线程来测试下:

C 版本的多线程

</>复制代码

  1. #include
  2. #include
  3. #include
  4. #include
  5. void *test(void *name)
  6. {
  7. pid_t pid, tid;
  8. pid = getpid();
  9. tid = syscall(__NR_gettid);
  10. char *tname = (char *)name;
  11. // 设置线程名字
  12. prctl(PR_SET_NAME, tname);
  13. while(1)
  14. {
  15. printf("pid: %d, thread_id: %u, t_name: %s
  16. ", pid, tid, tname);
  17. sleep(3);
  18. }
  19. }
  20. int main()
  21. {
  22. pthread_t t1, t2;
  23. void *ret;
  24. pthread_create(&t1, NULL, test, (void *)"Love_test_1");
  25. pthread_create(&t2, NULL, test, (void *)"Love_test_2");
  26. pthread_join(t1, &ret);
  27. pthread_join(t2, &ret);
  28. }

输出:

</>复制代码

  1. root@10-46-33-56:~# gcc t.c -lpthread && ./a.out
  2. pid: 5575, thread_id: 5577, t_name: Love_test_2
  3. pid: 5575, thread_id: 5576, t_name: Love_test_1
  4. pid: 5575, thread_id: 5577, t_name: Love_test_2
  5. pid: 5575, thread_id: 5576, t_name: Love_test_1
  6. ...

用 PS 命令再次验证:

</>复制代码

  1. root@10-46-33-56:~# ps -Tp 5575
  2. PID SPID TTY TIME CMD
  3. 5575 5575 pts/2 00:00:00 a.out
  4. 5575 5576 pts/2 00:00:00 Love_test_1
  5. 5575 5577 pts/2 00:00:00 Love_test_2

这个才是正确嘛,线程名确实是可以通过 Ps 看出来的嘛!

不过为啥 Python 那个看不到呢?既然是通过 setName 设置线程名的,那就看看定义咯:

</>复制代码

  1. [threading.py]
  2. class Thread(_Verbose):
  3. ...
  4. @property
  5. def name(self):
  6. """A string used for identification purposes only.
  7. It has no semantics. Multiple threads may be given the same name. The
  8. initial name is set by the constructor.
  9. """
  10. assert self.__initialized, "Thread.__init__() not called"
  11. return self.__name
  12. @name.setter
  13. def name(self, name):
  14. assert self.__initialized, "Thread.__init__() not called"
  15. self.__name = str(name)
  16. def setName(self, name):
  17. self.name = name
  18. ...

看到这里其实只是在 Thread 对象的属性设置了而已,并没有动到根本,那肯定就是看不到咯~

这样看起来,我们已经没办法通过 ps 或者 /proc/ 这类手段在外部搜索 python 线程名了,所以我们只能在 Python 内部来解决。

于是问题就变成了,怎样在 Python 内部拿到所有正在运行的线程呢?

threading.enumerate 可以完美解决这个问题!Why?

Because 在下面这个函数的 doc 里面说得很清楚了,返回所有活跃的线程对象,不包括终止和未启动的。

</>复制代码

  1. [threading.py]
  2. def enumerate():
  3. """Return a list of all Thread objects currently alive.
  4. The list includes daemonic threads, dummy thread objects created by
  5. current_thread(), and the main thread. It excludes terminated threads and
  6. threads that have not yet been started.
  7. """
  8. with _active_limbo_lock:
  9. return _active.values() + _limbo.values()

因为拿到的是 Thread 的对象,所以我们通过这个能到该线程相关的信息!

请看完整代码示例:

</>复制代码

  1. #coding: utf8
  2. import threading
  3. import os
  4. import time
  5. def get_thread():
  6. pid = os.getpid()
  7. while True:
  8. ts = threading.enumerate()
  9. print "------- Running threads On Pid: %d -------" % pid
  10. for t in ts:
  11. print t.name, t.ident
  12. print
  13. time.sleep(1)
  14. def tt():
  15. info = threading.currentThread()
  16. pid = os.getpid()
  17. while True:
  18. print "pid: {}, tid: {}, tname: {}".format(pid, info.name, info.ident)
  19. time.sleep(3)
  20. return
  21. t1 = threading.Thread(target=tt)
  22. t1.setName("Thread-test1")
  23. t1.setDaemon(True)
  24. t1.start()
  25. t2 = threading.Thread(target=tt)
  26. t2.setName("Thread-test2")
  27. t2.setDaemon(True)
  28. t2.start()
  29. t3 = threading.Thread(target=get_thread)
  30. t3.setName("Checker")
  31. t3.setDaemon(True)
  32. t3.start()
  33. t1.join()
  34. t2.join()
  35. t3.join()

输出:

</>复制代码

  1. root@10-46-33-56:~# python t_show.py
  2. pid: 6258, tid: Thread-test1, tname: 139907597162240
  3. pid: 6258, tid: Thread-test2, tname: 139907586672384
  4. ------- Running threads On Pid: 6258 -------
  5. MainThread 139907616806656
  6. Thread-test1 139907597162240
  7. Checker 139907576182528
  8. Thread-test2 139907586672384
  9. ------- Running threads On Pid: 6258 -------
  10. MainThread 139907616806656
  11. Thread-test1 139907597162240
  12. Checker 139907576182528
  13. Thread-test2 139907586672384
  14. ------- Running threads On Pid: 6258 -------
  15. MainThread 139907616806656
  16. Thread-test1 139907597162240
  17. Checker 139907576182528
  18. Thread-test2 139907586672384
  19. ------- Running threads On Pid: 6258 -------
  20. MainThread 139907616806656
  21. Checker 139907576182528
  22. ...

代码看起来有点长,但是逻辑相当简单,Thread-test1Thread-test2 都是打印出当前的 pid、线程 id 和 线程名字,然后 3s 后退出,这个是想模拟线程正常退出。

Checker 线程则是每秒通过 threading.enumerate 输出当前进程内所有活跃的线程。

可以明显看到一开始是可以看到 Thread-test1Thread-test2的信息,当它俩退出之后就只剩下 MainThreadChecker 自身而已了。

销毁指定线程

既然能拿到名字和线程 id,那我们也就能干掉指定的线程了!

假设现在 Thread-test2 已经黑化,发疯了,我们需要制止它,那我们就可以通过这种方式解决了:

在上面的代码基础上,增加和补上下列代码:

</>复制代码

  1. def _async_raise(tid, exctype):
  2. """raises the exception, performs cleanup if needed"""
  3. tid = ctypes.c_long(tid)
  4. if not inspect.isclass(exctype):
  5. exctype = type(exctype)
  6. res = ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, ctypes.py_object(exctype))
  7. if res == 0:
  8. raise ValueError("invalid thread id")
  9. elif res != 1:
  10. ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, None)
  11. raise SystemError("PyThreadState_SetAsyncExc failed")
  12. def stop_thread(thread):
  13. _async_raise(thread.ident, SystemExit)
  14. def get_thread():
  15. pid = os.getpid()
  16. while True:
  17. ts = threading.enumerate()
  18. print "------- Running threads On Pid: %d -------" % pid
  19. for t in ts:
  20. print t.name, t.ident, t.is_alive()
  21. if t.name == "Thread-test2":
  22. print "I am go dying! Please take care of yourself and drink more hot water!"
  23. stop_thread(t)
  24. print
  25. time.sleep(1)

输出

</>复制代码

  1. root@10-46-33-56:~# python t_show.py
  2. pid: 6362, tid: 139901682108160, tname: Thread-test1
  3. pid: 6362, tid: 139901671618304, tname: Thread-test2
  4. ------- Running threads On Pid: 6362 -------
  5. MainThread 139901706389248 True
  6. Thread-test1 139901682108160 True
  7. Checker 139901661128448 True
  8. Thread-test2 139901671618304 True
  9. Thread-test2: I am go dying. Please take care of yourself and drink more hot water!
  10. ------- Running threads On Pid: 6362 -------
  11. MainThread 139901706389248 True
  12. Thread-test1 139901682108160 True
  13. Checker 139901661128448 True
  14. Thread-test2 139901671618304 True
  15. Thread-test2: I am go dying. Please take care of yourself and drink more hot water!
  16. pid: 6362, tid: 139901682108160, tname: Thread-test1
  17. ------- Running threads On Pid: 6362 -------
  18. MainThread 139901706389248 True
  19. Thread-test1 139901682108160 True
  20. Checker 139901661128448 True
  21. // Thread-test2 已经不在了

一顿操作下来,虽然我们这样对待 Thread-test2,但它还是关心着我们:多喝热水

PS: 热水虽好,八杯足矣,请勿贪杯哦。

书回正传,上述的方法是极为粗暴的,为什么这么说呢?

因为它的原理是:利用 Python 内置的 API,触发指定线程的异常,让其可以自动退出;

万不得已真不要用这种方法,有一定概率触发不可描述的问题。切记!别问我为什么会知道...

为什么停止线程这么难

多线程本身设计就是在进程下的协作并发,是调度的最小单元,线程间分食着进程的资源,所以会有许多锁机制和状态控制。

如果使用强制手段干掉线程,那么很大几率出现意想不到的bug。 而且最重要的锁资源释放可能也会出现意想不到问题。

我们甚至也无法通过信号杀死进程那样直接杀线程,因为 kill 只有对付进程才能达到我们的预期,而对付线程明显不可以,不管杀哪个线程,整个进程都会退出!

而因为有 GIL,使得很多童鞋都觉得 Python 的线程是Python 自行实现出来的,并非实际存在,Python 应该可以直接销毁吧?

然而事实上 Python 的线程都是货真价实的线程!

什么意思呢?Python 的线程是操作系统通过 pthread 创建的原生线程。Python 只是通过 GIL 来约束这些线程,来决定什么时候开始调度,比方说运行了多少个指令就交出 GIL,至于谁夺得花魁,得听操作系统的。

如果是单纯的线程,其实系统是有办法终止的,比如: pthread_exit,pthread_killpthread_cancel, 详情可看:https://www.cnblogs.com/Creat...

很可惜的是: Python 层面并没有这些方法的封装!我的天,好气!可能人家觉得,线程就该温柔对待吧。

如何温柔退出线程

想要温柔退出线程,其实差不多就是一句废话了~

要么运行完退出,要么设置标志位,时常检查标记位,该退出的就退出咯。

扩展

《如何正确的终止正在运行的子线程》:https://www.cnblogs.com/Creat...
《不要粗暴的销毁python线程》:http://xiaorui.cc/2017/02/22/...

欢迎各位大神指点交流, QQ讨论群: 258498217
转载请注明来源: https://segmentfault.com/a/11...

文章版权归作者所有,未经允许请勿转载,若此文章存在违规行为,您可以联系管理员删除。

转载请注明本文地址:https://www.ucloud.cn/yun/43192.html

相关文章

  • python

    Python装饰器为什么难理解? 无论项目中还是面试都离不开装饰器话题,装饰器的强大在于它能够在不修改原有业务逻辑的情况下对代码进行扩展,权限校验、用户认证、日志记录、性能测试、事务处理、缓存等都是装饰器的绝佳应用场景,它能够最大程度地对代码进行复用。 但为什么初学者对装饰器的理解如此困难,我认为本质上是对Py… Python 实现车牌定位及分割 作者用 Python 实现车牌定位及分割的实践。 ...

    chenatu 评论0 收藏0
  • Python

    摘要:最近看前端都展开了几场而我大知乎最热语言还没有相关。有关书籍的介绍,大部分截取自是官方介绍。但从开始,标准库为我们提供了模块,它提供了和两个类,实现了对和的进一步抽象,对编写线程池进程池提供了直接的支持。 《流畅的python》阅读笔记 《流畅的python》是一本适合python进阶的书, 里面介绍的基本都是高级的python用法. 对于初学python的人来说, 基础大概也就够用了...

    dailybird 评论0 收藏0
  • 通读Python官方文档Threading

    摘要:但现在线程没有优先级,没有线程组,不能被销毁停止暂停开始和打断。守护线程也会结束,并强行终止整个程序。在中,他是目前可用的最底层的同步原语,由模块提供。当处于状态时,方法可以将状态变为,并立即返回。否则会抛出错误。对象实现某些服务的共进退。 Python的threading模块松散地基于Java的threading模块。但现在线程没有优先级,没有线程组,不能被销毁、停止、暂停、开始和打...

    jasperyang 评论0 收藏0

发表评论

0条评论

最新活动
阅读需要支付1元查看
<