Python中如何用Threading实现并发执行100个耗时几分钟的Class/函数？

import threading
import time
from queue import Queue

class TaskProcessor:
    def __init__(self, task_id):
        self.task_id = task_id
        
    def process(self):
        """模拟耗时几分钟的任务"""
        print(f"任务 {self.task_id} 开始执行")
        time.sleep(180)  # 模拟3分钟的任务，实际使用时替换为真实逻辑
        print(f"任务 {self.task_id} 执行完成")
        return f"任务 {self.task_id} 结果"

def worker(task_queue, results):
    """工作线程函数"""
    while not task_queue.empty():
        try:
            task = task_queue.get_nowait()
            result = task.process()
            results.append(result)
        except Queue.Empty:
            break
        finally:
            task_queue.task_done()

def main():
    # 1. 创建100个任务实例
    tasks = [TaskProcessor(i) for i in range(100)]
    
    # 2. 创建任务队列
    task_queue = Queue()
    for task in tasks:
        task_queue.put(task)
    
    # 3. 创建线程池（建议根据CPU核心数调整）
    max_workers = 10  # 控制并发数，避免资源耗尽
    threads = []
    results = []
    
    # 4. 启动工作线程
    for _ in range(max_workers):
        thread = threading.Thread(target=worker, args=(task_queue, results))
        thread.start()
        threads.append(thread)
    
    # 5. 等待所有任务完成
    task_queue.join()
    
    # 6. 等待所有线程结束
    for thread in threads:
        thread.join()
    
    print(f"所有任务完成，共处理 {len(results)} 个任务")

if __name__ == "__main__":
    main()

关键点说明：

1. 任务封装：用TaskProcessor类封装每个耗时任务，process()方法包含具体业务逻辑
2. 线程安全队列：使用Queue管理任务分发，避免线程竞争
3. 工作线程模式：每个线程从队列获取任务执行，队列空时自动退出
4. 并发控制：通过max_workers限制同时运行的线程数（建议设为CPU核心数的2-4倍）
5. 结果收集：通过共享的results列表收集任务结果（注意：如果涉及复杂数据结构，可能需要加锁）

替代方案：

# 使用concurrent.futures（Python 3.2+）
from concurrent.futures import ThreadPoolExecutor

def run_tasks():
    with ThreadPoolExecutor(max_workers=10) as executor:
        tasks = [TaskProcessor(i) for i in range(100)]
        results = list(executor.map(lambda t: t.process(), tasks))
    return results

用线程池更简洁，自动管理线程生命周期。

一句话总结：用线程池+队列控制并发，避免直接创建100个线程。