如何在收到退出命令时终止多个Python线程？

首先，你当前的实现有个关键问题：当你在CLI中输入q后，只会向队列中放入一个("QUIT",)命令，这意味着只有一个线程能拿到这个命令并退出，其他线程会继续运行，因为它们再也拿不到退出信号了。

下面提供两种优雅的解决方案，让所有线程能同时响应退出命令：

方法一：使用threading.Event（推荐） #

threading.Event是线程安全的信号量，能同时通知所有线程退出，比队列传递单条退出命令更可靠高效。

改造步骤： #

1. 创建全局的退出事件，所有线程共享这个事件
2. 修改CLI线程，输入q时设置退出事件
3. 改造每个工作线程，监听退出事件，同时处理命令队列

完整代码示例：

import threading
import queue
import time

def do_stuff():
    print("Thread 1 doing work")

def do_other_stuff():
    print("Thread 2 doing work")

def cli(exit_event, cmd_queue):
    while True:
        user_input = input()
        if user_input == "q":
            # 设置退出事件，通知所有线程
            exit_event.set()
            print("Exit signal sent to all threads")
            return

def some_thread_1(exit_event, cmd_queue):
    while not exit_event.is_set():
        # 处理队列中的所有待执行命令
        while not cmd_queue.empty():
            cmd = cmd_queue.get()
            # 这里可以添加其他命令的处理逻辑
            # 比如 if cmd == ("SOME_CMD",): do_something()
            cmd_queue.task_done()
        
        # 执行线程自身的业务逻辑
        do_stuff()
        # 用event.wait代替sleep，能在退出信号到来时立刻唤醒线程
        exit_event.wait(0.001)
    print("Thread 1 exited gracefully")

def some_other_thread_2(exit_event, cmd_queue):
    while not exit_event.is_set():
        while not cmd_queue.empty():
            cmd = cmd_queue.get()
            cmd_queue.task_done()
        
        do_other_stuff()
        exit_event.wait(0.001)
    print("Thread 2 exited gracefully")

if __name__ == "__main__":
    exit_event = threading.Event()
    cmd_queue = queue.Queue()

    # 启动CLI线程
    cli_thread = threading.Thread(target=cli, args=(exit_event, cmd_queue), daemon=True)
    cli_thread.start()

    # 启动工作线程
    thread1 = threading.Thread(target=some_thread_1, args=(exit_event, cmd_queue))
    thread2 = threading.Thread(target=some_other_thread_2, args=(exit_event, cmd_queue))
    
    thread1.start()
    thread2.start()

    # 等待工作线程退出
    thread1.join()
    thread2.join()
    print("All threads exited")

优势： #

• 线程响应退出信号更及时：用exit_event.wait(0.001)代替time.sleep(0.001)，一旦退出事件被设置，线程会立刻唤醒并退出
• 无需维护退出命令的数量：不管有多少线程，一个事件就能通知所有线程
• 代码更简洁：避免了每个线程重复判断("QUIT",)的冗余逻辑

方法二：向队列发送多份退出命令 #

如果你坚持要用队列传递退出信号，可以根据线程数量，向队列中放入对应数量的("QUIT",)命令，确保每个线程都能拿到一份。

改造示例： #

import threading
import queue
import time

def do_stuff():
    print("Thread 1 doing work")

def do_other_stuff():
    print("Thread 2 doing work")

def cli(cmd_queue, thread_count):
    while True:
        user_input = input()
        if user_input == "q":
            # 给每个线程发送一份退出命令
            for _ in range(thread_count):
                cmd_queue.put(("QUIT",))
            print("Exit commands sent to all threads")
            return

def some_thread_1(cmd_queue):
    while True:
        cmd = cmd_queue.get()
        if cmd == ("QUIT",):
            print("Thread 1 exited gracefully")
            return
        # 处理其他命令...
        do_stuff()
        time.sleep(0.001)

def some_other_thread_2(cmd_queue):
    while True:
        cmd = cmd_queue.get()
        if cmd == ("QUIT",):
            print("Thread 2 exited gracefully")
            return
        # 处理其他命令...
        do_other_stuff()
        time.sleep(0.001)

if __name__ == "__main__":
    cmd_queue = queue.Queue()
    thread_count = 2

    cli_thread = threading.Thread(target=cli, args=(cmd_queue, thread_count), daemon=True)
    cli_thread.start()

    thread1 = threading.Thread(target=some_thread_1, args=(cmd_queue,))
    thread2 = threading.Thread(target=some_other_thread_2, args=(cmd_queue,))
    
    thread1.start()
    thread2.start()

    thread1.join()
    thread2.join()
    print("All threads exited")

注意事项： #

• 必须提前知道线程数量，如果线程是动态创建的，这种方法很难维护
• 线程会阻塞在cmd_queue.get()，如果没有退出命令会一直等待，所以需要确保所有退出命令都被放入队列

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