什么是python线程

Question

我有几个关于Python线程的问题。

1. Python线程是Python还是OS实现？
2. 当我使用htop时，多线程脚本有多个条目-相同的内存消耗，相同的命令，但不同的PID。这是否意味着[Python]线程实际上是一种特殊的进程？（我知道htop中有一个设置将这些线程显示为一个进程-Hide userland threads）
3. Documentation说：

A thread can be flagged as a “daemon thread”. The significance of this flag is that the entire Python program exits when only daemon threads are left.

我的理解是：主线程在所有非守护进程线程终止时终止。

所以，如果“整个python程序在只剩下守护进程线程时退出”，python守护进程线程就不是python程序的一部分了？

Answer 1

1. Python线程在我知道的所有实现（C Python、PyPy和Jython）中都是使用OS线程实现的。对于每个Python线程，都有一个底层OS线程。

2. 一些操作系统（Linux就是其中之一）在所有运行进程的列表中显示由同一可执行文件启动的所有不同线程。这是操作系统的实现细节，而不是Python的实现细节。在其他一些操作系统上，列出所有进程时可能看不到这些线程。

3. 当最后一个非守护进程线程完成时，进程将终止。此时，所有守护进程线程都将终止。因此，这些线程是进程的一部分，但并不阻止它终止（而常规线程将阻止它）。这是用纯Python实现的。当调用系统_exit函数（它将杀死所有线程）时，进程终止；当主线程终止（或调用sys.exit）时，Python解释器检查是否有另一个非守护进程线程正在运行。如果没有，则调用_exit，否则等待非守护进程线程完成。

---

守护进程线程标志由threading模块在纯Python中实现。加载模块时，将创建一个表示主线程的Thread对象，并将其_exitfunc方法注册为atexit挂钩。

此函数的代码为：

class _MainThread(Thread):

    def _exitfunc(self):
        self._Thread__stop()
        t = _pickSomeNonDaemonThread()
        if t:
            if __debug__:
                self._note("%s: waiting for other threads", self)
        while t:
            t.join()
            t = _pickSomeNonDaemonThread()
        if __debug__:
            self._note("%s: exiting", self)
        self._Thread__delete()

当调用sys.exit或主线程终止时，Python解释器将调用此函数。当函数返回时，解释器将调用系统_exit函数。当只有守护进程线程在运行时（如果有的话），函数将终止。

当调用_exit函数时，操作系统将终止所有进程线程，然后终止进程。在完成所有非守护进程线程之前，Python运行时不会调用_exit函数。

所有线程都是进程的一部分。

---

My interpretation/understanding was: main thread terminates when all non-daemon threads are terminated.

So python daemon threads are not part of python program if "the entire Python program exits when only daemon threads are left"?

你的理解不正确。对于OS，进程由许多线程组成，所有线程都是相等的（除了C运行时在main函数的末尾添加对_exit的调用之外，OS的主线程没有什么特殊之处）。操作系统不知道守护进程线程。这纯粹是一个Python概念。

Python解释器使用本机线程来实现Python线程，但必须记住创建的线程列表。并且使用它的atexit钩子，它确保_exit函数仅在最后一个非守护进程线程终止时返回操作系统。当使用“整个Python程序”时，文档指的是整个过程。

---

以下程序有助于理解守护进程线程和普通线程之间的区别：

import sys
import time
import threading

class WorkerThread(threading.Thread):

    def run(self):
        while True:
            print 'Working hard'
            time.sleep(0.5)

def main(args):
    use_daemon = False
    for arg in args:
        if arg == '--use_daemon':
            use_daemon = True
    worker = WorkerThread()
    worker.setDaemon(use_daemon)
    worker.start()
    time.sleep(1)
    sys.exit(0)

if __name__ == '__main__':
    main(sys.argv[1:])

如果您使用“--use嫒daemon”执行此程序，您将看到该程序将只打印少量的Working hard行。如果没有这个标志，程序即使在主线程完成时也不会终止，并且程序将打印Working hard行，直到它被终止。

Answer 2

我不熟悉实现，所以让我们做一个实验：

import threading
import time

def target():
    while True:
        print 'Thread working...'
        time.sleep(5)

NUM_THREADS = 5

for i in range(NUM_THREADS):
    thread = threading.Thread(target=target)
    thread.start()

1. 使用ps -o cmd,nlwp <pid>报告的线程数是NUM_THREADS+1（主线程多一个），因此只要OS工具检测到线程数，它们就应该是OS线程。我尝试了使用cpython和jython，尽管在jython中还有一些其他线程在运行，但是对于我添加的每个额外线程，ps会将线程计数增加一。

2. 我不确定htop的行为，但ps似乎是一致的。

3. 我在启动线程之前添加了以下行：

   thread.daemon = True
   

   当我执行using-cpython时，程序几乎立即终止，并且使用ps找不到进程，所以我的猜测是程序与线程一起终止。在jython中，程序以相同的方式工作（它没有终止），因此可能还有一些来自jvm的其他线程阻止程序终止，或者不支持守护进程线程。

注意：我在java1.6.0圮23上使用了Ubuntu 11.10和python 2.7.2+以及jython2.2.1

Answer 3

1. Python线程实际上是一个解释器实现，因为所谓的全局解释器锁（GIL），即使它在技术上使用os级线程机制。在*nix上，它使用了pthreads，但是GIL有效地使它成为应用程序级线程范例的一个混合障碍。因此，您将在ps/top输出中多次在*nix系统上看到它，但它的行为（性能方面）仍然像软件实现的线程。

2. 不，您只是看到了操作系统的底层线程实现。这种行为被*nix pthread（类似于线程）所公开，甚至我也知道windows确实是这样实现线程的。

3. 当程序关闭时，它也会等待所有线程完成。如果您有线程，这可能会无限延迟退出，那么最好将这些线程标记为“守护进程”，并允许您的程序完成，即使这些线程仍在运行。

一些您可能感兴趣的参考资料：

• Linux Gazette: Understanding Threading in Python。
• Doug Hellman: Multi-processing techniques in Python
• David Beazley: PyCon 2010:Understanding the Python GIL(Video-presentation)