深入解析 Python 并发编程：Asyncio 与 Threading 的实战对比与选择指南

2026-02-13 21:39:33 0条评论 2次阅读 0人点赞

在 Python 开发之旅中，我们经常面临需要同时处理多项任务的挑战。无论是从多个 API 获取数据，还是同时处理数千个网络连接，并发编程都是必不可少的工具。然而，Python 为我们提供了两条截然不同的路径：Asyncio（异步编程） 和 Threading（多线程）。对于许多开发者来说，选择哪一个往往令人困惑。

在这篇文章中，我们将深入探讨这两者的核心机制、本质区别以及最佳实践。我们会通过实际代码示例，直观地看到它们在处理不同任务时的表现，并帮助你掌握在什么情况下该选择哪一种技术。让我们开始这段探索并发世界的旅程吧。

Asyncio 与 Threading：核心差异一览

虽然两者都可以实现“并发”，但它们的工作原理截然不同。我们可以通过以下几个维度来快速了解它们的区别。

1. 并发模型：单线程协作 vs 多线程并行

  • Asyncio：Asyncio 采用单线程事件循环模型。它就像一个精明的餐厅经理，虽然只有一个服务员（单线程），但他知道在厨师做菜的时候去服务另一桌客人。它通过 await 语法，在遇到 I/O 等待时让出控制权，转而执行其他任务。这使得它可以在一个线程中高效地处理成百上千个并发操作，且没有多线程上下文切换的开销。
  • Threading：Threading 则是多线程模型，它雇佣了多个服务员（线程）。表面上看起来大家在同时工作，但在 Python 中，由于 全局解释器锁（GIL） 的存在，同一时刻实际上只有一个服务员在工作（只能有一个线程执行 Python 字节码）。这使得 Python 的多线程更像是一种“并发”而非真正的“并行”，尽管如此，它在处理阻塞型任务时依然非常有用。

2. 适用场景：I/O 密集型 vs 混合型

  • Asyncio：它是 I/O 密集型任务 的王者。如果你的程序大部分时间都在等待网络响应、数据库查询或文件读写，Asyncio 可以在等待期间去处理其他逻辑，从而最大化 CPU 利用率。它是现代高性能 Web 框架（如 FastAPI）的基石。
  • Threading：Threading 适合那些既有 I/O 操作，又涉及少量 CPU 计算的场景，或者你需要调用不支持异步的第三方阻塞库时。对于 CPU 密集型任务（如图像处理、大量计算），由于 GIL 的存在，多线程不仅无法加速，反而可能因为上下文切换导致性能下降，这种情况通常建议使用 multiprocessing。

3. 资源消耗与复杂性

  • Asyncio：由于没有线程创建和销毁的开销，Asyncio 的内存占用极低。然而，异步编程要求我们改变思维模式，所有的 I/O 操作都必须是“非阻塞”的，这意味着你必须使用专门的异步库（如 INLINECODE8be528ce 而非 INLINECODEf9716cc1），且需要小心处理事件循环的管理。
  • Threading：线程的创建和上下文切换需要消耗一定的系统资源。更重要的是，多线程编程带来了共享资源访问的风险。你需要时刻警惕竞态条件和死锁问题，这意味着你需要熟练掌握锁（Lock）、信号量等同步原语，这无疑增加了代码的调试难度。

深入理解 Python Asyncio

Asyncio 是 Python 3.4 引入的一个庞大库，用于编写单线程的并发代码。它依赖于“协程”的概念。协程本质上是一种可以暂停和恢复的函数。

Asyncio 实战示例

让我们通过一个简单的例子来看看 Asyncio 是如何工作的。假设我们需要模拟两个任务，每个任务都要等待 1 秒。

import asyncio
import time

# 定义一个异步函数（协程）
async def say_hello(task_id):
    print(f"[任务 {task_id}] 开始执行，打印 Hello")
    # await 关键字会暂停当前协程，让出控制权给事件循环
    # asyncio.sleep 模拟 I/O 阻塞操作，不会阻塞整个线程
    await asyncio.sleep(1)  
    print(f"[任务 {task_id}] 1秒后恢复，打印 World")

async def main():
    # 创建两个任务，并让它们并发运行
    # asyncio.gather 会同时调度这两个协程
    print("--- Asyncio 并发测试开始 ---")
    start_time = time.time()
    
    # 这里的 await 意味着 main 函数会等待这两个子任务全部完成才继续
    await asyncio.gather(say_hello(1), say_hello(2))
    
    end_time = time.time()
    print(f"--- 执行结束，总耗时: {end_time - start_time:.2f} 秒 ---")

# asyncio.run() 负责创建事件循环并运行 main 协程
if __name__ == "__main__":
    asyncio.run(main())

#### 代码解析

  • async def：声明这是一个协程函数，调用它不会立即执行代码，而是返回一个协程对象。
  • INLINECODE0a1a30a1：这是 Asyncio 的魔法所在。当执行到 INLINECODE677ccd2a 时，当前协程会暂停，将控制权交还给事件循环。此时，事件循环会去运行其他排队的任务（比如 say_hello(2)）。
  • 并发效果：由于在等待的 1 秒钟内，CPU 没有闲着，而是在两个任务间切换，因此两个任务总共只花费了约 1 秒（而不是 2 秒）。

深入理解 Python Threading

Python 的 threading 模块是对底层原生线程的封装。它允许你在同一个进程中并行运行多个函数。虽然 GIL 限制了 CPU 的并行计算能力，但对于网络请求这类涉及大量等待的任务，多线程可以让 CPU 在等待时切换线程去处理其他连接。

Threading 实战示例

为了对比，我们用 Threading 实现同样的逻辑。

import threading
import time

def say_hello_thread(task_id):
    print(f"[线程 {task_id}] 开始执行，打印 Hello")
    # time.sleep 是阻塞式的，它会占用当前线程，但不会阻塞其他线程
    time.sleep(1)  
    print(f"[线程 {task_id}] 1秒后恢复，打印 World")

def main_threads():
    print("--- Threading 并发测试开始 ---")
    start_time = time.time()
    
    # 创建两个线程对象，target 指定要执行的函数
    t1 = threading.Thread(target=say_hello_thread, args=(1,))
    t2 = threading.Thread(target=say_hello_thread, args=(2,))
    
    # 启动线程
    t1.start()
    t2.start()
    
    # join() 方法会让主线程等待这两个线程执行完毕
    t1.join()
    t2.join()
    
    end_time = time.time()
    print(f"--- 执行结束，总耗时: {end_time - start_time:.2f} 秒 ---")

if __name__ == "__main__":
    main_threads()

#### 代码解析

  • INLINECODE13a5a6f2：我们实例化了两个线程对象，分别指向 INLINECODEc1301b23 函数。
  • start()：启动线程。此时，Python 解释器会切换到新线程执行目标函数，而主线程（Main）继续往下运行。
  • INLINECODEa22bb14c：这是一个同步操作。主线程必须等待 t1 和 t2 完成任务后才能结束程序。如果不使用 INLINECODE85f4a752，主线程可能会先于子线程结束，导致程序异常退出。
  • 并发效果：由于 time.sleep(1) 会释放 GIL，两个线程可以交替运行。总耗时同样约为 1 秒。

深度对比：高并发下的表现与陷阱

为了让你更深刻地理解两者的差异，让我们扩展一下场景。假设我们要模拟 10 个并发下载任务，看看两种方式的处理方式有何不同。

Asyncio 的高效扩展

Asyncio 处理 10 个任务和处理 2 个任务在资源消耗上几乎没有区别。事件循环只是在一个线程里快速地协调各个协程。

import asyncio

async def download_file(file_id):
    print(f"开始下载文件 {file_id}...")
    await asyncio.sleep(1) # 模拟下载耗时
    print(f"文件 {file_id} 下载完成。")
    return f"文件{file_id}的数据"

async def main_batch():
    # 创建 10 个任务列表
    tasks = [download_file(i) for i in range(1, 11)]
    
    # 使用 asyncio.wait 可以同时等待所有任务完成
    # 这会触发 10 个并发的“下载”操作，在同一个线程里完成
    done, pending = await asyncio.wait(tasks)
    
    print("
所有下载任务已完成！")

if __name__ == "__main__":
    asyncio.run(main_batch())

Threading 的资源代价

当我们创建 10 个线程时，操作系统需要分配 10 个栈空间（通常每个线程约 8MB），这会消耗大量内存。而且，线程越多，CPU 调度线程的开销就越大。

import threading
import time

def download_file_thread(file_id):
    print(f"[线程 {threading.current_thread().name}] 开始下载文件 {file_id}...")
    time.sleep(1)
    print(f"[线程 {threading.current_thread().name}] 文件 {file_id} 下载完成。")

def main_batch_thread():
    threads = []
    print("启动 10 个线程进行下载...
")
    
    for i in range(1, 11):
        t = threading.Thread(target=download_file_thread, args=(i,))
        threads.append(t)
        t.start()

    for t in threads:
        t.join()

    print("
所有下载任务已完成！")

关键差异：竞态条件

这是 Threading 最让人头疼的地方。由于多个线程共享进程的内存空间，如果多个线程同时修改同一个变量，就会产生数据不一致。Asyncio 由于是单线程的，协程之间的切换是受控的（通常只在 await 处），所以在处理共享数据时，相对不容易出现不可预测的竞态条件（当然，如果使用了多线程 Asyncio 也会面临同样问题）。

让我们看一个多线程不安全的例子：

import threading

# 共享资源：一个简单的计数器
counter = 0

def increment():
    global counter
    # 这里的 += 操作实际上分三步：读取、加法、写回
    # 线程可能会在任意步骤被切换，导致数据丢失
    _ = counter
    counter = _ + 1

def unsafe_counter_demo():
    global counter
    counter = 0
    threads = []
    
    # 启动 1000 个线程，每个线程加 1
    for _ in range(1000):
        t = threading.Thread(target=increment)
        threads.append(t)
        t.start()

    for t in threads:
        t.join()

    # 理想结果应该是 1000，但实际运行结果往往小于 1000
    print(f"最终计数值（期望 1000）：{counter}") 

if __name__ == "__main__":
    unsafe_counter_demo()

如果你运行这段代码多次，你会发现结果通常不是 1000，而是 998 或 997 等随机数。解决方法是使用 threading.Lock，但这会进一步降低性能并增加代码复杂度。而在 Asyncio 中，由于没有这种抢占式的切换，处理这类逻辑要简单得多。

实用指南：你该如何选择？

在实际的开发工作中，我们该如何在 Asyncio 和 Threading 之间做出选择呢？这里有一份实用的决策指南。

1. 优先选择 Asyncio 的场景

  • 构建高并发的网络服务：例如 Web 服务器、聊天室服务器。你希望用有限的内存处理成千上万个连接。
  • 微服务架构：你需要频繁调用外部 API 或数据库（如 PostgreSQL, Redis 等，它们都支持异步驱动）。
  • 代码的可维护性：虽然异步代码写起来稍有门槛，但它的执行流通常是线性的，一旦理解了 async/await，逻辑会非常清晰，且避免了锁带来的困扰。

2. 优先选择 Threading 的场景

  • 使用不支持异步的第三方库：你有一个非常强大但只支持同步调用的 SDK（例如某些机器学习推理库），且该库调用非常耗时。此时，使用 Asyncio 会阻塞整个事件循环，而使用 Threading 可以在后台线程中运行它，保持主流程流畅。
  • Windows 下的 GUI 应用程序：在开发 Tkinter 或 PyQt 应用时，如果有一个耗时操作，必须放在单独的线程中，否则会导致界面卡死（无响应）。
  • 代码库已有大量同步逻辑：如果你的老项目全部是同步代码，将其全部重写为 Asyncio 成本过高，那么在需要并发的地方使用 ThreadPoolExecutor（线程池）通常是最快、最安全的过渡方案。

3. 性能优化小贴士

  • Asyncio 的陷阱：永远不要在协程中使用阻塞的同步代码（如 INLINECODEac52732a 或 INLINECODE04189e81）。这会阻塞整个事件循环，导致所有并发任务瞬间变成串行执行。如果你必须这样做，请使用 asyncio.to_thread 将其放入线程池运行。
  • Threading 的上限：不要创建几千个线程。线程是很重的资源。通常建议使用 concurrent.futures.ThreadPoolExecutor 来管理一个固定数量的线程池，避免系统资源耗尽。
  • 混合模式：Asyncio 和 Threading 可以共存。你可以使用 loop.run_in_executor 将 CPU 密集型或阻塞型任务放到线程池中运行，并通过 Future 对象在 Asyncio 中等待结果。

结语

Python 的并发世界丰富而强大。Asyncio 为我们提供了高效处理 I/O 密集型任务的能力，它以极低的资源消耗换取了惊人的并发性能；而 Threading 则是处理阻塞操作和集成遗留代码的可靠伙伴。

理解它们的底层机制——单线程事件循环与多线程抢占调度——是写出高性能 Python 代码的关键。下一次当你需要优化代码性能时，不妨先审视一下你的任务类型：是等待更多（I/O）还是计算更多（CPU）？根据答案，选择合适的工具，你的程序将如虎添翼。

声明：本站所有文章，如无特殊说明或标注，均为本站原创发布。任何个人或组织，在未征得本站同意时，禁止复制、盗用、采集、发布本站内容到任何网站、书籍等各类媒体平台。如若本站内容侵犯了原著者的合法权益，可联系我们进行处理。如需转载，请注明文章出处豆丁博客和来源网址。https://shluqu.cn/46315.html
点赞
0.00 平均评分 (0% 分数) - 0 票

相关文章美国1G带宽/1T流量高速vps $17.99/年