Python线程优化求助：如何避免等待线程完成及解决脚本异常

嘿，我来帮你搞定这两个头疼的问题：线程结束后立即启动新任务，以及脚本无法正常退出的问题，这在处理大文件的多线程场景里太常见了！

为什么你的脚本越跑越慢？ #

你之前的写法应该是一次性创建了和任务数量一样多的线程吧？当线程数太多时，操作系统要频繁在这些线程之间切换上下文，CPU的大部分时间都花在切换上，真正处理任务的时间反而变少，自然越跑越慢。正确的思路是固定线程数量，让线程复用——一个线程完成任务后立刻去取下一个任务，不用重复创建销毁线程。

方案1：用线程池（最省心的方式） #

不管是Python2还是Python3，线程池都是最佳选择，它会帮你自动管理线程的复用和任务调度。

Python2 实现（适配你的代码环境） #

Python2可以用multiprocessing.dummy.Pool（注意这是线程池，不是进程池）：

import multiprocessing.dummy as mp
import time

def process_task(task_data):
    # 这里替换成你的实际任务处理逻辑
    time.sleep(1)  # 模拟任务耗时
    print(f"处理完成任务: {task_data}")

if __name__ == "__main__":
    # 优化：逐行读取大文件，避免一次性加载全量数据到内存
    tasks = []
    with open("你的大文件.txt", "r") as f:
        for line in f:
            line = line.strip()
            if line:
                tasks.append(line)
    
    # 设置线程池大小（IO密集型任务可以设为CPU核心数的2-4倍，比如10）
    pool_size = 10
    pool = mp.Pool(pool_size)
    
    # 提交所有任务，线程池会自动调度：一个线程完成就取新任务
    pool.map(process_task, tasks)
    
    # 关闭线程池，不再接受新任务
    pool.close()
    # 等待所有任务处理完成
    pool.join()
    
    print("所有任务处理完毕，脚本正常退出！")

Python3 实现（如果后续升级版本） #

Python3自带concurrent.futures.ThreadPoolExecutor，用法更直观：

from concurrent.futures import ThreadPoolExecutor
import time

def process_task(task_data):
    time.sleep(1)
    print(f"处理完成任务: {task_data}")

if __name__ == "__main__":
    tasks = []
    with open("你的大文件.txt", "r") as f:
        for line in f:
            line = line.strip()
            if line:
                tasks.append(line)
    
    with ThreadPoolExecutor(max_workers=10) as executor:
        executor.map(process_task, tasks)
    
    print("所有任务处理完毕，脚本正常退出！")

方案2：手动用Queue实现线程复用（适合自定义逻辑） #

如果你不想用线程池，也可以手动基于Queue实现固定线程的任务调度，同时解决退出问题：

import threading
import Queue
import time

class Work(threading.Thread):
    def __init__(self, job_queue):
        threading.Thread.__init__(self)
        self.job_queue = job_queue
        self.daemon = True  # 设置为守护线程：主线程退出时，子线程自动终止

    def run(self):
        while True:
            try:
                # 阻塞获取任务，超时1秒避免无限阻塞
                task_data = self.job_queue.get(timeout=1)
                # 替换成你的任务处理逻辑
                time.sleep(1)
                print(f"处理完成任务: {task_data}")
                # 标记任务已完成，让队列知道可以计数
                self.job_queue.task_done()
            except Queue.Empty:
                # 队列空了，线程自动退出
                break

def main():
    # 逐行读取大文件，减少内存占用
    job_queue = Queue.Queue()
    with open("你的大文件.txt", "r") as f:
        for line in f:
            line = line.strip()
            if line:
                job_queue.put(line)
    
    # 设置固定线程数
    thread_count = 10
    threads = []
    # 创建并启动线程
    for _ in range(thread_count):
        worker = Work(job_queue)
        worker.start()
        threads.append(worker)
    
    # 等待队列中所有任务都被处理完成
    job_queue.join()
    
    # 等待所有线程正常退出（因为设置了daemon，其实可以省略，但加上更稳妥）
    for t in threads:
        t.join()
    
    print("所有任务处理完毕，脚本正常退出！")

if __name__ == "__main__":
    main()

解决脚本无法正常退出的关键要点 #

你之前的脚本退不出，大概率是这几个原因：

1. 没有设置守护线程：主线程结束后，子线程还在后台运行，导致脚本挂着。上面的代码里都设置了daemon=True，确保主线程退出时子线程自动终止。
2. 没有等待任务全部完成：用Queue.join()或者线程池的join()方法，确保所有任务都处理完再退出。
3. 线程没有正确的退出逻辑：手动实现时，线程要在队列空的时候主动退出，避免无限循环。

额外优化建议 #

• 线程数不要贪多：IO密集型任务（比如文件读取、网络请求）可以设为CPU核心数的2-4倍；CPU密集型任务建议设为和CPU核心数一致，避免上下文切换开销。
• 逐行读取大文件：不要一次性把整个文件读到内存里，逐行读取并放入队列，减少内存压力，尤其是处理GB级别的大文件时。

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