好的，咱们一步步来解决这个问题——既要优雅响应Ctrl-C触发的KeyboardInterrupt，又要妥善终止线程和子进程，还要完成收尾工作，比如关闭打开的文件。

其实子进程的跟踪思路和你处理线程的方式类似：维护一个全局或类级别的列表，记录所有启动的子进程实例，在退出时遍历这个列表逐一处理。

1. 跟踪子进程 #

在启动子进程时，把subprocess.Popen对象（或你用的其他进程类实例）加入跟踪列表：

# 可以是全局变量，也可以封装在管理类里
active_processes = []

# 启动子进程的示例
def start_worker_process():
    proc = subprocess.Popen(
        ["your_command_here"],
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE
    )
    active_processes.append(proc)
    return proc

2. 优雅终止子进程 #

在KeyboardInterrupt的异常块里，遍历列表终止进程：

except KeyboardInterrupt:
    print("\n收到终止信号，开始清理子进程...")
    for proc in active_processes:
        if proc.poll() is None:  # 检查进程是否还在运行
            proc.terminate()  # 先尝试优雅终止（发送SIGTERM）
            try:
                proc.wait(timeout=5)  # 等待进程正常退出
            except subprocess.TimeoutExpired:
                proc.kill()  # 超时后强制杀死（发送SIGKILL）
                print(f"子进程 {proc.pid} 超时未退出，已强制终止")

Python没有安全的强制终止线程的方法（强制终止可能导致资源泄漏、数据损坏），所以最好的方案是给线程设置停止标志，让线程主动检测并退出。

示例线程类 #

import threading
import time

class WorkerThread(threading.Thread):
    def __init__(self):
        super().__init__()
        self.running = True  # 停止标志
        self.log_file = open("thread_work.log", "a")  # 示例打开的文件

    def run(self):
        while self.running:
            # 线程的核心工作逻辑
            self.log_file.write(f"线程 {self.name} 运行中...\n")
            self.log_file.flush()
            time.sleep(1)
        # 收尾工作：关闭文件、释放资源
        self.log_file.close()
        print(f"线程 {self.name} 已优雅退出")

在异常块中终止线程 #

# 假设你已经用active_threads列表跟踪线程
except KeyboardInterrupt:
    # 先通知所有线程停止
    for thread in active_threads:
        thread.running = False
    # 等待线程退出
    for thread in active_threads:
        thread.join(timeout=10)
        if thread.is_alive():
            print(f"线程 {thread.name} 未能及时退出，可能存在阻塞")

很遗憾，Python没有内置的“一键终止所有进程和线程”的全局方法——因为强制终止线程风险极高，官方不推荐这种暴力操作。但有两个可选的补充方案：

1. 用psutil批量终止子进程（第三方库） #

如果你需要清理所有子进程（包括没显式跟踪的），可以用psutil库，它能方便地遍历当前进程的所有子进程：

import psutil

parent_proc = psutil.Process()
# 递归获取所有子进程
for child in parent_proc.children(recursive=True):
    child.terminate()
# 等待进程退出，超时则强制杀死
gone, still_alive = psutil.wait_procs(child, timeout=5)
for proc in still_alive:
    proc.kill()

注意：需要先安装psutil：pip install psutil，这种方式会终止所有子进程，要谨慎使用。

2. 线程的极端处理（不推荐） #

如果线程死活不响应停止标志，没有安全的强制终止方式，只能从设计层面优化——比如把线程的阻塞操作改成可中断的（比如用threading.Event代替time.sleep），让线程能及时检测到停止信号。

把上面的逻辑整合起来，大概的主程序结构是：

import threading
import subprocess
import time

active_threads = []
active_processes = []

class WorkerThread(threading.Thread):
    def __init__(self):
        super().__init__()
        self.running = True
        self.log_file = open("thread_log.txt", "a")

    def run(self):
        while self.running:
            self.log_file.write(f"{time.strftime('%Y-%m-%d %H:%M:%S')} 线程运行中\n")
            self.log_file.flush()
            time.sleep(1)
        self.log_file.close()
        print(f"线程 {self.name} 退出")

def start_subprocess():
    proc = subprocess.Popen(["ping", "-t", "localhost"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    active_processes.append(proc)
    return proc

if __name__ == "__main__":
    # 启动线程和子进程
    thread1 = WorkerThread()
    thread1.start()
    active_threads.append(thread1)

    proc1 = start_subprocess()

    try:
        while True:
            print("主程序运行中，按Ctrl-C终止")
            time.sleep(2)
    except KeyboardInterrupt:
        print("\n开始优雅退出...")

        # 终止线程
        for thread in active_threads:
            thread.running = False
        for thread in active_threads:
            thread.join(timeout=5)

        # 终止子进程
        for proc in active_processes:
            if proc.poll() is None:
                proc.terminate()
                try:
                    proc.wait(timeout=3)
                except subprocess.TimeoutExpired:
                    proc.kill()
                    print(f"强制终止子进程 {proc.pid}")

        print("优雅退出完成")

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