Python多线程并发编程简单示例:threading与concurrent.futures用法

阿麦
阿麦
发布时间:2026-11-21 | 2人浏览过
原创

本文详细介绍Python多线程并发编程的核心概念与基础用法,通过清晰的代码示例分别演示threading模块与concurrent.futures线程池的实现方式,并提供两者的对比与选型建议。

在编写 Python 程序时,如果遇到大量网络请求、文件读写或接口轮询等耗时操作,单线程顺序执行会导致程序长时间处于等待状态。使用多线程并发可以在一个线程等待 I/O 响应时,切换执行其他线程的任务,从而显著缩短整体运行时间。在 Python 标准库中,实现多线程主要有两种方式:一是底层的 threading 模块,适合对单个线程进行精细控制;二是现代高阶的 concurrent.futures 模块(通过 ThreadPoolExecutor),更适合管理批量任务并发与结果收集。本文通过具体且可直接运行的示例,带你掌握这两种方式的用法与适用场景。

一、Python多线程工作原理与适用场景

在开始写代码前,需要明确 Python 多线程的适用边界。受限于标准 CPython 解释器的全局解释器锁(Global Interpreter Lock,简称 GIL),同一时刻只有一个线程能够在 CPU 核心上执行 Python 字节码。因此,多线程并不能让纯计算密集的任务(如大型矩阵运算、复杂加密解密)利用多核并行提速。

但在 I/O 密集型任务中,当某个线程发起网络请求或磁盘读写时,会进入等待状态并主动释放 GIL。此时其他就绪状态的线程就可以获取 GIL 继续执行。这样各任务的“网络等待时间”重叠在了一起,整体执行效率就会得到大幅提升。

Python多线程并发编程简单示例:threading与concurrent.futures用法
图 1:Python 多线程在 CPU 密集与 I/O 密集任务中的行为机制对比

二、使用 threading 模块编写多线程程序

threading 是 Python 提供的基础线程模块。它的基本操作方式非常直观:定义一个工作函数,把该函数传递给 threading.Thread 构造器,然后调用 start() 启动线程,最后在主线程中调用 join() 等待子线程执行完毕。

1. 基本步骤与代码示例

以下示例模拟同时下载 3 个文件的场景,使用 time.sleep() 模拟网络传输的延迟:

import threading
import time

def download_file(filename, duration):
    print(f"[{time.strftime('%H:%M:%S')}] 开始下载: {filename}")
    time.sleep(duration)  # 模拟网络耗时
    print(f"[{time.strftime('%H:%M:%S')}] 完成下载: {filename} (耗时 {duration}s)")

def main():
    start_time = time.time()
    tasks = [("file1.zip", 2), ("file2.zip", 3), ("file3.zip", 1)]
    threads = []

    # 1. 创建并启动线程
    for name, dur in tasks:
        t = threading.Thread(target=download_file, args=(name, dur))
        threads.append(t)
        t.start()

    # 2. 等待所有线程执行结束
    for t in threads:
        t.join()

    total_time = time.time() - start_time
    print(f"所有任务完成,总耗时: {total_time:.2f} 秒")

if __name__ == "__main__":
    main()

运行上述代码后,终端的示例输出如下:

[10:00:00] 开始下载: file1.zip
[10:00:00] 开始下载: file2.zip
[10:00:00] 开始下载: file3.zip
[10:00:01] 完成下载: file3.zip (耗时 1s)
[10:00:02] 完成下载: file1.zip (耗时 2s)
[10:00:03] 完成下载: file2.zip (耗时 3s)
所有任务完成,总耗时: 3.01 秒

如果使用单线程顺序执行,这三个任务的总耗时为 2 + 3 + 1 = 6 秒;而在多线程并发下,三个任务同时开始等待网络,总耗时仅取决于耗时最长的任务(约 3 秒)。

Python多线程并发编程简单示例:threading与concurrent.futures用法
图 2:使用 threading.Thread 创建与管理单个线程的典型执行流程
注意事项:
  • args 必须是元组。如果只有一个参数,写成 args=("item1",),切勿漏掉末尾逗号。
  • 启动线程必须调用 t.start()。如果误写成 t.run(),只会在当前主线程中同步执行函数,失去并发效果。
  • threading.Thread 无法直接拿到函数返回值。如果需要获取子线程产生的数据,需要借助 queue.Queue 或列表等外部容器。

三、使用 concurrent.futures 模块高效管理线程池

在实际工程场景中,直接使用 threading.Thread 往往存在一些局限:如果需要并发处理 500 个文件,一次性创建 500 个线程会造成巨大的内存开销和操作系统调度负担;此外,获取返回值和捕获异常都很繁琐。

Python 3.2 引入的 concurrent.futures.ThreadPoolExecutor 完美解决了这些痛点。它维护了一个可控容量的线程池(Worker Pool),复用固定数量的线程去消化任务队列,并通过 Future 对象优雅地返回执行结果和异常。

Python多线程并发编程简单示例:threading与concurrent.futures用法
图 3:ThreadPoolExecutor 线程池工作流与任务派发模型

1. 方式一:使用 map() 批量执行并按序获取结果

如果你有一批参数相同的任务列表,并且希望按照输入顺序依次获取计算结果,executor.map() 是最简洁的方法:

import time
from concurrent.futures import ThreadPoolExecutor

def fetch_data(item_id):
    time.sleep(1)  # 模拟网络耗时
    return f"数据项 #{item_id} 内容"

def main():
    items = [101, 102, 103, 104, 105]
    start = time.time()

    # 创建容量为 3 的线程池
    with ThreadPoolExecutor(max_workers=3) as executor:
        # map 会将 items 中的每个元素分别传给 fetch_data 并并发执行
        results = executor.map(fetch_data, items)

        for res in results:
            print(f"[{time.strftime('%H:%M:%S')}] 获得结果: {res}")

    print(f"全部读取完成,总耗时: {time.time() - start:.2f} 秒")

if __name__ == "__main__":
    main()

通过上下文管理器 with ThreadPoolExecutor(),当代码块执行退出时,会自动调用 shutdown(wait=True),确保所有在执行中的线程安全退出。

2. 方式二:使用 submit() 与 as_completed() 实现“先完成先处理”

在更多实际应用中,任务的耗时可能长短不一。如果希望哪个任务先下载完就立即处理哪个,可以使用 executor.submit() 单独提交任务,并配合 as_completed() 进行迭代:

import time
from concurrent.futures import ThreadPoolExecutor, as_completed

def request_api(url, delay):
    time.sleep(delay)
    if "bad" in url:
        raise ValueError(f"请求失败: {url}")
    return f"响应数据来自 {url}"

def main():
    tasks = {
        "https://api.example.com/fast": 1,
        "https://api.example.com/slow": 3,
        "https://api.example.com/medium": 2,
    }

    with ThreadPoolExecutor(max_workers=3) as executor:
        # 将 Future 对象与对应的 url 做字典映射,便于后续识别
        future_to_url = {
            executor.submit(request_api, url, delay): url
            for url, delay in tasks.items()
        }

        # as_completed 谁先完成就先产出谁的 Future 对象
        for future in as_completed(future_to_url):
            url = future_to_url[future]
            try:
                data = future.result()
                print(f"[{time.strftime('%H:%M:%S')}] 成功: {data}")
            except Exception as exc:
                print(f"[{time.strftime('%H:%M:%S')}] 异常: {url} 生成了错误: {exc}")

if __name__ == "__main__":
    main()

示例输出清晰展示了“先完成先响应”的机制:

[10:00:01] 成功: 响应数据来自 https://api.example.com/fast
[10:00:02] 成功: 响应数据来自 https://api.example.com/medium
[10:00:03] 成功: 响应数据来自 https://api.example.com/slow

四、threading 与 concurrent.futures 对比与选型

两者在 Python 标准库中各司其职,在不同场景下各有优劣。以下是两者核心维度的对比矩阵:

对比维度 threading 模块 concurrent.futures 线程池
抽象级别 较低层级,细粒度管理单个线程 较高层级,统一调度与生命周期托管
并发量控制 需要手动维护线程列表或结合信号量 (Semaphore) 直接设定 max_workers,超出任务自动排队
返回值与异常 无法直接通过函数返回,需借助队列 (Queue) 传递 通过 future.result() 直接取回结果,异常会自动在主线程抛出
资源开销 频繁创建与销毁线程会带来额外系统开销 线程常驻并循环复用,节约系统分配与销毁开销
典型适用场景 常驻后台监控线程、自定义 Socket 监听、特殊守护任务 批量网络爬虫、文件并发下载、并行 API 调用、批处理 I/O
Python多线程并发编程简单示例:threading与concurrent.futures用法
图 4:Python 多线程并发技术选型与决策路径

五、常见问题与实用排查建议

1. 为什么增加了多线程,速度反而变慢了?

遇到这种情况,首先排查任务是否属于计算密集型。如果是纯 CPU 计算(如数值计算、正则表达式大量匹配、图片处理),由于 GIL 锁的存在,多个线程会在单核上反复竞争锁和切换上下文,这不仅不能提升速度,反而会因额外的调度开销导致整体变慢。对于 CPU 密集型任务,应使用 multiprocessing.Pool 或 ProcessPoolExecutor。

2. 线程池的 max_workers 设置为多少合适?

线程数并非越多越好。过多的线程会消耗大量内存堆栈(每个线程默认占用数兆字节),并增加操作系统上下文切换的负担。通常的建议是:

  • 对于绝大多数 I/O 密集型任务,max_workers 建议设置在 min(32, (os.cpu_count() or 1) + 4) 之间(Python 3.8+ 默认采用此策略)。
  • 如果是高延迟的外部接口调用(如单个接口耗时数十秒),可以适当提高至 50 到 100,但需注意目标服务器的速率限制(Rate Limit)与本地操作系统的最大文件描述符限制。

3. 线程安全问题与共享数据

多个线程如果同时修改同一个非线程安全的全局变量(如对全局计数器执行 counter += 1),由于该操作在字节码层面并非原子操作,会导致数据不一致。此时必须使用 threading.Lock 进行加锁保护,或者优先采用“数据不共享、只通过返回值交付”的函数式设计风格,这也是优先推荐 ThreadPoolExecutor 的重要原因之一。

六、总结

掌握 Python 多线程编程的关键在于认清并发场景与选对工具:

  • 适用前提:多线程专注解决 I/O 密集型等待问题,无法规避 CPU 密集型场景下的 GIL 限制。
  • 轻量单一任务:使用 threading.Thread 明确掌控单个线程的生命周期,配合 start() 与 join() 执行。
  • 批量并发处理:优先使用 concurrent.futures.ThreadPoolExecutor,通过上下文管理器自动回收资源,利用 map() 进行有序处理,或借助 submit() 与 as_completed() 实现高效的先到先得调度。
相关专题:

本站声明

本文内容仅供参考,不代表本站观点。转载或引用请注明出处。如发现内容问题,请通过联系我们页面反馈。

Python 相关产品和应用

全部下载

专题列表