python 多线程中的 join 和 daemon

淡淡的烟草味﹌ 2022-09-04 15:50 177阅读 0赞

### 文章目录 ###

*   *  第一关：简单的 join()
     *  第二关：join(timeout)
     *  第三关：setDaemon(True)

## 第一关：简单的 join() ##

import threading
    import time
    
    
    def run():
        time.sleep(2)
        print('当前线程的名字是： ', threading.current_thread().name)
        time.sleep(2)
    
    
    if __name__ == '__main__':
        print('这是主线程：', threading.current_thread().name)
        thread_list = []
        
        for i in range(5):
            t = threading.Thread(target=run)
            thread_list.append(t)
            
        for t in thread_list:
            t.start()
            
        start_time = time.time()
        thread_list[0].join()
       
        print('一共用时：', time.time() - start_time)
        print('主线程结束！', threading.current_thread().name)

执行结果是：

这是主线程： MainThread
    当前线程的名字是：  Thread-1
    当前线程的名字是：  Thread-5当前线程的名字是：  Thread-4当前线程的名字是： 当前线程的名字是：  
     
    Thread-2
    Thread-3
    一共用时： 4.014104843139648
    主线程结束！ MainThread

为了弄清楚 join() 的作用，我关注代码 23 行的用时。

第 23 行，主线程阻塞，直到 thread\_list\[0\] 退出后才往下执行。

看打印结果第 7 行，用时 4s，这是好理解的，因为 thread\_list\[0\] 大概用 4s。说明主线程确实阻塞了，一直阻塞到 thread\_list\[0\] 执行完毕。

我们把代码修改一下，把 run() 函数的 sleep 时间增加。

def run():
        time.sleep(5)
        print('当前线程的名字是： ', threading.current_thread().name)
        time.sleep(5)

预期结果是主线称大约阻塞 10s

执行结果是：

这是主线程： MainThread
    当前线程的名字是： 当前线程的名字是：  Thread-5当前线程的名字是：   Thread-1当前线程的名字是：  Thread-3
    当前线程的名字是：  Thread-2
    
    Thread-4
    
    一共用时： 10.009864091873169
    主线程结束！ MainThread

和预期相符。

如果把 run 函数改成死循环，比如

def run():
        while(True):
            time.sleep(2)
            print('当前线程的名字是： ', threading.current_thread().name)
            time.sleep(2)

那么主线程就会一直阻塞，根本不会打印 “一共用时：…”，而是一直打印 “当前线程的名字是：…”

这也印证了主线程确实阻塞了，等待子线程退出，如果不退出就一直阻塞。

## 第二关：join(timeout) ##

在上面的例子中，如果子线程不返回，父线程就一直阻塞。如果需求是父线程阻塞一段时间，时间到了以后，就算子线程不返回，父线程也可以继续向下执行，那么我们可以给 join() 传入一个时间参数。意思是**最多**等待这么多，等不到我就继续往下执行了。

实验代码是：

import threading
    import time
    
    
    def run():
        time.sleep(2)
        print('当前线程的名字是： ', threading.current_thread().name)
        time.sleep(2)
    
    
    if __name__ == '__main__':
        print('这是主线程：', threading.current_thread().name)
        thread_list = []
    
        for i in range(5):
            t = threading.Thread(target=run)
            thread_list.append(t)
    
        for t in thread_list:
            t.start()
    
        start_time = time.time()
        thread_list[0].join(2)
    
        print('一共用时：', time.time() - start_time)
        print('主线程结束！', threading.current_thread().name)

第 23 行：父线程最多等待 2s，等不到就继续执行

打印结果是：

这是主线程： MainThread
    一共用时： 2.0001044273376465
    主线程结束！ MainThread
    当前线程的名字是：  当前线程的名字是：  当前线程的名字是：  Thread-2
    Thread-3
    Thread-1
    当前线程的名字是：  Thread-4
    当前线程的名字是：  Thread-5

可以看到，父线程确实只阻塞了 2s。需要强调的是，主线程阻塞，不会对子线程造成任何影响，子线程依然执行自己的代码，根本不存在什么“主线程等待一段时间然后杀死子线程”，这是谬论。

当然，如果你传入参数是 10，主线程不一定非要等 10s，如果子线程执行了 3s 就返回了，那么主线程会立刻往下执行，而不是继续等待 7s。

例如把代码第 23 行改成

thread_list[0].join(6)

执行结果是：

这是主线程： MainThread
    当前线程的名字是： 当前线程的名字是：  Thread-2 Thread-3当前线程的名字是： 当前线程的名字是： 
    
     当前线程的名字是：  Thread-1
     Thread-4
    Thread-5
    一共用时： 4.028920888900757
    主线程结束！ MainThread

## 第三关：setDaemon(True) ##

先上代码：

import threading
    import time
    
    
    def run():
        time.sleep(2)
        print('当前线程的名字是： ', threading.current_thread().name)
        time.sleep(2)
    
    
    if __name__ == '__main__':
        print('这是主线程：', threading.current_thread().name)
        thread_list = []
    
        for i in range(5):
            t = threading.Thread(target=run)
            t.setDaemon(True)
            thread_list.append(t)
    
        for t in thread_list:
            t.start()
    
        start_time = time.time()
    
        print('一共用时：', time.time() - start_time)
        print('主线程结束！', threading.current_thread().name)

和之前不一样的是第 17 行，多加了 `t.setDaemon(True)`，这句话的意思是把线程的 daemon 属性设成 True。daemon 有守护神的意思，也可以说把 t 设置为守护线程，守护谁呢？守护父线程吗？咱们后面会分析。

网上充斥着这样的解释：如果一个子线程的 daemon 被设为 True，那么父线程结束了，这个子线程就立刻被干掉。是不是这样呢？我们看执行结果：

这是主线程： MainThread
    一共用时： 0.0
    主线程结束！ MainThread

似乎是这样，主线程一执行完，子线程就被杀死了，连打印都来不及。

我们把 15-18 行代码改一下：

for i in range(5):
            t = threading.Thread(target=run)
            # t.setDaemon(True)
            thread_list.append(t)
        thread_list[0].setDaemon(True)

也就是说，仅仅设置 thread\_list\[0\] 的 daemon 为 True。预期结果是主线程一结束，thread\_list\[0\] 就被杀死了，其余的子线程会继续执行。

结果是：

这是主线程： MainThread
    一共用时： 0.0
    主线程结束！ MainThread
    当前线程的名字是：  Thread-3当前线程的名字是：  Thread-2
    
    当前线程的名字是：  当前线程的名字是：  Thread-5
    当前线程的名字是： Thread-4
     Thread-1

这就奇怪了，不是 Thread-1 被杀死了吗，怎么后面还有打印呢？

肯定是我们的理解有问题。实际上，官方是这样解释 daemon 的：

> 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**.

以上摘自 https://docs.python.org/3/library/threading.html，黑体字是我加的。

也就是说，如果父线程执行完毕，剩下的都是守护线程，那么这些守护线程也不用再执行了，直接强制退出；如果父线程执行完毕，剩下了 3 个守护线程和 1 个非守护线程，那么这 3 个守护线程还会继续执行，当非守护线程结束的时候，这些守护线程才会强制退出。

我们做个实验：

import threading
    import time
    
    
    def run(cnt):
        while cnt:
            time.sleep(1)
            print('当前线程的名字是： ', threading.current_thread().name)
            time.sleep(1)
            cnt = cnt - 1
        print(threading.current_thread().name, ' 退出')
    
    if __name__ == '__main__':
        print('这是主线程：', threading.current_thread().name)
        thread_list = []
        cnt_list = [2, 4, 4, 4, 4]
    
        for i in range(5):
            t = threading.Thread(target=run, args=(cnt_list[i],))
            t.setDaemon(True)
            thread_list.append(t)
    
        thread_list[0].setDaemon(False)
    
        for t in thread_list:
            t.start()
    
        start_time = time.time()
    
        print('一共用时：', time.time() - start_time)
        print('主线程结束！', threading.current_thread().name)

5-11：每个子线程执行时间不一样，根据传参 cnt 定

第 16 行，增加了`cnt_list = [2, 4, 4, 4, 4]`，意图是让 thread\_list\[0\] 执行时间短一些，仅执行 while 循环 2 次，其他子线程执行 4 次

18-23：先把所有子线程设为守护线程，后面再把 thread\_list\[0\] 设为非守护线程（偷懒了）

输出结果：

这是主线程： MainThread
    一共用时： 0.0
    主线程结束！ MainThread
    当前线程的名字是： 当前线程的名字是： 当前线程的名字是：  Thread-5 当前线程的名字是：  Thread-2
    Thread-1 
    
    Thread-4
    当前线程的名字是：  Thread-3
    当前线程的名字是：  Thread-1当前线程的名字是：  当前线程的名字是： 当前线程的名字是：  Thread-3
    当前线程的名字是：  Thread-5
     Thread-4
    Thread-2
    
    Thread-1  退出

可以发现，父线程退出后，守护线程并没有退出，当非守护线程 Thread-1 退出后，其他守护线程强制退出。

由此可见，守护线程不仅仅守护父线程，也会守护其他非守护线程。

以上就是本文的全部内容。欢迎各位老师批评斧正。