【一】主线程死亡，子线程未死亡

• 主线程结束运行后不会马上结束，而是等待其他非守护子线程结束之后才会结束
• 如果主线程死亡就代表者主进程也死亡，随之而来的是所有子线程的死亡

from threading import Thread
import time


def work(name):
    print(f'{name} is starting')
    time.sleep(2)
    print(f'{name} is ending')


def main():
    print('主进程开始了！')
    task = Thread(target=work, args=('ligo',))
    task.start()
    print('主进程结束了！')


if __name__ == '__main__':
    main()

    # 主进程开始了！
    # ligo is starting
    # 主进程结束了！
    # ligo is ending

【二】主进程死亡，子进程必死亡

from threading import Thread
import time


def work(name):
    print(f'{name} is starting')
    time.sleep(2)
    print(f'{name} is ending')


def main():
    print('主进程开始了！')
    task = Thread(target=work, args=('ligo',))
    # 开启守护线程 , 主线程结束，子线程随之结束
    task.daemon = True
    task.start()
    print('主进程结束了！')


if __name__ == '__main__':
    main()

    # 主进程开始了！
    # ligo is starting
    # 主进程结束了！ 

【三】迷惑例子

# 导入所需模块
from threading import Thread
import time


# 定义函数foo，模拟一个耗时操作
def foo():
    # 打印开始信息
    print(f' this is foo begin')
    # 模拟耗时操作，暂停3秒
    time.sleep(3)
    # 打印结束信息
    print(f' this is foo end')


# 定义另一个函数func，同样模拟耗时操作
def func():
    # 打印开始信息
    print(f' this is func begin')
    # 模拟耗时操作，暂停1秒
    time.sleep(1)
    # 打印结束信息
    print(f' this is func end')


# 主函数
def main():
    # 创建线程 task_foo ，目标函数为foo
    task_foo = Thread(target=foo)
    # 设置 task_foo 为守护线程
    # 意味着当主线程结束时，不论 task_foo 是否执行完毕都会被强制终止
    task_foo.daemon = True
    # 创建线程 task_func ，目标函数为func
    task_func = Thread(target=func)

    # 启动线程 task_foo
    task_foo.start()
    # 启动线程 task_func
    task_func.start()

    # 主线程继续执行，打印以下信息
    print(f' this is main')


# 程序入口
if __name__ == '__main__':
    main()
    #  this is main begin 
    #  this is foo begin
    #  this is func begin
    #  this is main end
    #  this is func end