Python多线程怎么用？并发编程详解

一分耕耘，一分收获！既然都打开这篇《Python多线程怎么用？并发编程入门教程》，就坚持看下去，学下去吧！本文主要会给大家讲到等等知识点，如果大家对本文有好的建议或者看到有不足之处，非常欢迎大家积极提出！在后续文章我会继续更新文章相关的内容，希望对大家都有所帮助！

Python多线程并不能真正实现并行计算，尤其在CPU密集型任务中，由于全局解释器锁（GIL）的存在，多线程无法同时利用多个CPU核心，因此大多数情况下不能提高程序运行速度；但在I/O密集型任务中，如网络请求、文件读写等，线程在等待I/O时会释放GIL，从而实现“并发”提升效率；1. 多线程适用于I/O密集型任务，2. 多线程受GIL限制不适用于CPU密集型任务，3. 多线程存在数据竞争问题需使用锁、信号量、条件变量等同步机制解决，4. 多线程与多进程的选择取决于任务类型，多进程适用于CPU密集型任务，多线程适用于I/O密集型任务。

Python多线程的实现主要依赖于其内置的threading模块。它允许程序创建并管理多个执行流，在特定场景下，比如等待网络响应或文件读写时，能够有效提升程序的并发能力和响应速度。但需要明确的是，由于全局解释器锁（GIL）的存在，Python的多线程并不能真正实现并行计算，尤其是在CPU密集型任务上。

解决方案

要实现Python多线程，基本步骤是定义一个函数作为线程的执行体，然后创建threading.Thread实例，并调用其start()方法来启动线程。如果需要等待线程执行完毕，可以使用join()方法。

下面是一个简单的例子，模拟两个线程同时进行一些操作：

import threading
import time
import random

# 线程要执行的任务
def worker_task(name, duration):
    print(f"线程 {name}: 开始执行，预计耗时 {duration:.2f} 秒...")
    # 模拟一些工作，比如网络请求或文件处理
    time.sleep(duration)
    print(f"线程 {name}: 执行完毕。")

# 创建并启动线程
if __name__ == "__main__":
    print("主线程: 准备启动子线程...")

    # 创建两个线程
    thread1 = threading.Thread(target=worker_task, args=("下载器", random.uniform(1, 3)))
    thread2 = threading.Thread(target=worker_task, args=("日志记录器", random.uniform(0.5, 2)))

    # 启动线程
    thread1.start()
    thread2.start()

    # 等待所有子线程完成
    # 这里会阻塞主线程，直到thread1和thread2都执行完毕
    thread1.join()
    thread2.join()

    print("主线程: 所有子线程已完成，程序退出。")

这段代码展示了如何创建并运行两个独立的线程。每个线程都在执行worker_task函数，模拟不同的耗时操作。通过start()启动它们，然后用join()等待它们各自完成。这是最基础的多线程用法，简单直接。

Python多线程真的能提高程序运行速度吗？

这是一个老生常谈的问题，也是很多人对Python多线程最大的误解来源。答案是：看情况，大部分时候不能，但某些特定场景下能。

核心原因在于Python的全局解释器锁（Global Interpreter Lock，GIL）。简单来说，GIL是一个互斥锁，它确保在任何给定时刻，只有一个线程在执行Python字节码。这意味着，即使你的机器有多个CPU核心，Python的多线程也无法同时利用这些核心来并行执行CPU密集型任务。当你启动多个线程进行大量计算时，它们实际上是在轮流获取GIL，然后执行一小段代码，再释放GIL让给其他线程。这种频繁的上下文切换反而可能带来额外的开销，导致多线程版本的程序比单线程版本更慢。

我记得第一次接触到GIL时，感觉它简直是多线程的“杀手”，完全颠覆了我对并发编程的认知。但深入了解后会发现，GIL的存在是为了简化CPython的内存管理，避免复杂的锁机制，让Python的C扩展更容易开发。

所以，什么时候多线程有用呢？当你的任务是I/O密集型时，比如网络请求、文件读写、数据库操作等。在这些场景下，线程大部分时间都在等待外部资源（网络数据、磁盘IO）的响应，而不是执行CPU指令。当一个线程在等待I/O时，它会主动释放GIL，让其他线程有机会运行。这样，多个I/O操作就可以在等待中“并发”进行，从而显著提高程序的整体效率。例如，爬虫程序、Web服务器、或者一些需要同时处理多个网络连接的工具，多线程就能发挥作用。

掌握线程同步机制：如何避免数据竞争与死锁？

既然多个线程可能同时访问和修改共享数据，那么问题就来了：数据可能会乱掉。这就是所谓的数据竞争（Race Condition）。比如，两个线程同时尝试给一个计数器加1，最终结果可能不是你预期的2，因为它们可能同时读取了旧值，然后都基于旧值进行更新。为了避免这种混乱，我们需要线程同步机制。

最常用的同步原语是锁（Lock）。threading.Lock提供了一个简单的机制：一个线程在访问共享资源前先acquire()锁，访问完后release()锁。如果锁已经被其他线程持有，尝试获取锁的线程就会被阻塞，直到锁被释放。

import threading
import time

# 共享资源
counter = 0
# 创建一个锁
lock = threading.Lock()

def increment_counter():
    global counter
    for _ in range(100000):
        # 获取锁
        lock.acquire()
        try:
            counter += 1
        finally:
            # 确保锁被释放，即使发生异常
            lock.release()

if __name__ == "__main__":
    threads = []
    for _ in range(5):
        thread = threading.Thread(target=increment_counter)
        threads.append(thread)
        thread.start()

    for thread in threads:
        thread.join()

    print(f"最终计数: {counter}") # 应该总是 500000

没有锁的话，counter的值几乎不可能是500000。但有了lock，每次只有一个线程能修改counter，确保了数据的一致性。

除了Lock，还有：

• RLock (可重入锁)：同一个线程可以多次获取同一个锁，适用于递归函数或多层调用中需要多次加锁的场景。
• Semaphore (信号量)：控制同时访问某个资源的线程数量上限，而不是完全互斥。
• Condition (条件变量)：更复杂的线程间通信机制，允许线程等待某个条件为真，或通知其他线程某个条件已满足。
• queue模块：这是我个人最推荐的线程间数据传递方式。queue.Queue（以及LifoQueue和PriorityQueue）是线程安全的队列，它内部已经处理了所有的锁和同步机制。线程A把数据put进队列，线程B从队列get数据，这种生产者-消费者模式可以大大简化多线程编程的复杂度，几乎完全避免了手动管理锁的麻烦。

说到死锁，它通常发生在多个线程互相等待对方释放资源时。例如，线程A持有资源X并等待资源Y，而线程B持有资源Y并等待资源X。解决死锁的关键在于破坏死锁的四个必要条件之一，最常见的方法是统一资源获取顺序，或者使用超时机制。调试多线程中的数据竞争和死锁问题，那真的是一场噩梦，所以尽可能使用像queue这样高级的、自带同步机制的数据结构，能省下很多头发。

多线程与多进程：我该如何选择？

聊完了线程，自然会想到它的“兄弟”——进程。在Python中，除了threading模块，还有一个multiprocessing模块，它允许你创建真正的操作系统进程。那么，什么时候用多线程，什么时候用多进程呢？

我个人在做技术选型时，通常会这样考虑：

多线程（threading模块）

• 优点：
  • 轻量级：线程的创建和销毁开销比进程小很多。
  • 内存共享方便：所有线程运行在同一个进程的内存空间里，共享数据非常方便（但也更容易出现数据竞争问题，需要同步）。
  • 切换开销小：线程上下文切换比进程快。
• 缺点：
  • 受GIL限制：无法利用多核CPU进行并行计算（CPU密集型任务）。
  • 数据同步复杂：共享数据需要手动加锁，容易出现死锁和数据不一致。
• 适用场景：
  • I/O密集型任务：如网络爬虫、Web服务器、GUI应用（等待用户输入）。
  • 需要频繁共享大量数据的场景。

多进程（multiprocessing模块）

• 优点：
  • 真正并行：每个进程都有独立的Python解释器和内存空间，不受GIL限制，可以充分利用多核CPU。
  • 稳定性高：一个进程崩溃不会影响其他进程。
  • 数据隔离：进程间默认不共享内存，避免了线程中的数据竞争问题（但也意味着进程间通信需要额外机制）。
• 缺点：
  • 开销大：进程的创建和销毁开销大，内存占用也更高。
  • 进程间通信（IPC）复杂：需要使用队列、管道、共享内存等机制来传递数据。
• 适用场景：
  • CPU密集型任务：如科学计算、图像处理、大数据分析、机器学习模型训练。
  • 需要充分利用多核处理器性能的场景。

所以，如果你的程序需要进行大量的计算，比如处理大型数据集、进行复杂的数学运算，那么毫无疑问，选择multiprocessing模块是更明智的。它能真正让你的程序跑在多个CPU核心上。但如果你的程序大部分时间都在等待外部响应，比如从网络下载文件、等待数据库查询结果，那么threading模块或者更现代的asyncio（异步IO）可能会是更好的选择，它们能让你在等待的同时做其他事情，提高程序的响应性。

最终，选择哪种并发模型，很大程度上取决于你程序的具体需求和瓶颈所在。没有银弹，只有最适合的工具。

今天关于《Python多线程怎么用？并发编程详解》的内容介绍就到此结束，如果有什么疑问或者建议，可以在golang学习网公众号下多多回复交流；文中若有不正之处，也希望回复留言以告知！