如何在Python程序退出前等待所有守护线程完成？

这个场景我太熟悉了——外部库深层逻辑封装得死死的，自己改不了，还得盯着不让程序提前退出把回调给吞了。给你几个可行的方案，按稳妥程度排序：

方案1：用事件对象让主线程等待回调触发 #

这是最推荐的办法，不需要碰外部库的线程逻辑，只需要包装一下你的回调函数，让主线程“等一等”操作完成：

import threading

# 初始化一个事件，用来标记长时间操作是否完成
operation_finished = threading.Event()

def wrapped_callback(result):
    # 先执行你原来的回调逻辑
    print("开始处理操作结果：", result)
    # ... 你的其他回调代码 ...
    
    # 操作完成后触发事件，告诉主线程可以退出了
    operation_finished.set()

# 调用外部库的方法，传入包装后的回调
external_library_long_running_task(callback=wrapped_callback)

# 主线程在这里阻塞，直到事件被触发——这样就不会提前退出
operation_finished.wait()

原理很简单：主线程只要在wait()这里等着，就不会因为只剩守护线程而退出，直到回调执行完并触发事件。完全不需要修改外部库的任何代码，兼容性拉满。

方案2：修改外部库守护线程的属性 #

如果你能找到外部库创建的那个监控线程，可以把它的daemon属性改成False，这样程序就不会因为只剩它而退出。不过这个方法需要你能准确识别目标线程，有一定风险：

# 先启动外部库的长时间操作
external_library_long_running_task()

# 遍历所有活跃线程，找到监控线程（根据名字或其他特征识别）
for thread in threading.enumerate():
    # 这里要根据实际情况调整判断条件，比如线程名包含"monitor"或"google"
    if "google_monitor" in thread.name.lower():
        # 把守护线程改成非守护
        thread.daemon = False
        # 让主线程等待这个线程完成，确保回调执行
        thread.join()

注意：Python允许在线程启动后修改daemon属性，但如果线程已经在运行，你得确保这个修改不会影响外部库的逻辑。如果识别错了线程，可能会导致其他问题，所以这个方案是备选。

方案3：用子进程隔离执行逻辑 #

如果上面两个方案都不行，可以把长时间操作放到子进程里执行。子进程的生命周期独立于主线程的守护线程，主进程可以等待子进程完成后再处理结果：

from multiprocessing import Process, Queue

def run_external_task(queue):
    # 如果外部库有同步版本的接口，直接调用并把结果放进队列
    result = external_library_long_running_task_sync()
    queue.put(result)

def handle_result(result):
    # 你的回调逻辑
    print("处理结果：", result)

if __name__ == "__main__":
    result_queue = Queue()
    # 创建子进程执行外部任务
    task_process = Process(target=run_external_task, args=(result_queue,))
    task_process.start()
    
    # 主进程等待子进程完成并获取结果
    final_result = result_queue.get()
    task_process.join()
    
    # 执行原来的回调逻辑
    handle_result(final_result)

这个方案适合外部库的线程逻辑完全黑盒的情况，但需要外部库支持在子进程中运行（有些库可能有进程间通信的问题）。

内容的提问来源于stack exchange，提问作者gmolau