异常教程

Python 多线程（长文讲解）

更新时间:

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战(已更新的所有项目都能学习) / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

  • 新开坑项目:《Spring AI 项目实战》 正在持续爆肝中，基于 Spring AI + Spring Boot 3.x + JDK 21...， 点击查看 ;
  • 《从零手撸：仿小红书（微服务架构）》 已完结，基于 Spring Cloud Alibaba + Spring Boot 3.x + JDK 17...，点击查看项目介绍 ;演示链接： http://116.62.199.48:7070 ;
  • 《从零手撸：前后端分离博客项目（全栈开发）》 2 期已完结，演示链接： http://116.62.199.48/ ;

截止目前， 星球 内专栏累计输出 90w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 3100+ 小伙伴加入学习 ，欢迎点击围观

在编程的世界中，效率是开发者永恒的追求。无论是处理海量数据、优化网络请求，还是提升应用程序的响应速度，Python 多线程技术都扮演着关键角色。对于编程初学者和中级开发者而言，理解多线程的原理与实践，不仅能解决实际开发中的性能瓶颈问题，更能帮助开发者构建出更加健壮和灵活的系统。本文将以通俗易懂的语言，结合实际案例，深入解析 Python 多线程的核心概念、实现方法及常见问题，帮助读者从零开始掌握这一技术。

一、多线程：什么是线程？为什么需要它？

1.1 线程与进程：生活中的类比

想象一个工厂的生产线：

  • 进程如同整个工厂，拥有独立的资源（如原材料、机器），负责完成一项完整的工作（如生产汽车）。
  • 线程则是工厂中的工人，共享工厂的资源（如车间和设备），并协同完成不同的任务（如焊接、喷漆）。

在编程中，进程是操作系统分配资源的基本单位，而线程是进程内的执行单元。线程可以共享进程的内存空间和资源，因此切换线程的开销比切换进程更小，适合需要并行执行的任务。

1.2 多线程的优势与适用场景

多线程技术的核心优势在于并发执行，可以显著提升程序的效率。例如：

  • IO密集型任务（如文件读写、网络请求），线程在等待IO响应时，可以切换执行其他任务。
  • 用户界面程序（如游戏、GUI应用），多线程可以避免界面卡顿，同时处理后台计算。

但需注意：Python 的多线程并非真正的“并行”，这与全局解释器锁（GIL）有关，后文将详细解释。

二、Python 多线程的核心实现：threading 模块

2.1 基础概念与代码示例

Python 的 threading 模块提供了丰富的线程管理功能。以下是创建和启动线程的典型步骤：

步骤 1：导入模块并定义线程函数

import threading  

def worker(number):  
    """线程执行的任务函数"""  
    print(f"线程 {number} 正在执行...")  
    # 模拟耗时操作  
    import time  
    time.sleep(1)

步骤 2：创建并启动线程

threads = []  
for i in range(5):  
    t = threading.Thread(target=worker, args=(i,))  # 创建线程对象  
    threads.append(t)  
    t.start()  # 启动线程  

for t in threads:  
    t.join()  
print("所有线程已执行完毕！")

输出示例：

线程 0 正在执行...  
线程 1 正在执行...  
...  
所有线程已执行完毕！

2.2 线程的状态与生命周期

线程的生命周期包括以下阶段：

  1. 新建（New）：通过 Thread 对象创建后，但尚未启动。
  2. 就绪（Runnable）：调用 start() 方法后，进入就绪队列等待执行。
  3. 运行（Running）：获得 CPU 时间片并执行代码。
  4. 阻塞（Blocked）：因等待 IO 或锁而暂停。
  5. 死亡（Dead）：任务执行完毕或被强制终止。

三、多线程的挑战：GIL 与线程安全

3.1 全局解释器锁（GIL）：双刃剑

Python 的 Global Interpreter Lock（GIL） 是一个关键概念，它确保同一时刻只有一个线程执行 Python 字节码。这意味着：

  • IO密集型任务：多线程能显著提升效率，因线程在等待 IO 时会释放 GIL。
  • CPU密集型任务（如计算密集型代码）：多线程可能无法提升速度，甚至因 GIL 的频繁切换而降低性能。

解决方案：

  • 对于 CPU 密集型任务，可考虑使用 multiprocessing 模块（多进程）。
  • 使用 C 扩展库（如 NumPy）绕过 GIL。

3.2 线程安全与竞态条件

当多个线程共享资源（如全局变量）时，可能出现竞态条件（Race Condition）。例如：

count = 0  

def increment():  
    global count  
    for _ in range(100000):  
        count += 1  

t1 = threading.Thread(target=increment)  
t2 = threading.Thread(target=increment)  
t1.start()  
t2.start()  
t1.join()  
t2.join()  
print(count)  # 可能输出小于 200000 的结果！

问题原因：count += 1 并非原子操作，多个线程可能同时读取、修改同一值。

解决方案：使用锁（Lock）

import threading  

lock = threading.Lock()  

def increment():  
    global count  
    for _ in range(100000):  
        lock.acquire()  
        count += 1  
        lock.release()  

def increment_with_context():  
    global count  
    for _ in range(100000):  
        with lock:  
            count += 1

四、实战案例：多线程下载文件与数据处理

4.1 案例目标

同时下载多个文件并计算斐波那契数列，对比单线程与多线程的效率差异。

4.2 代码实现

import threading  
import requests  
import time  

def download_file(url, filename):  
    response = requests.get(url)  
    with open(filename, 'wb') as f:  
        f.write(response.content)  
    print(f"{filename} 下载完成！")  

def fibonacci(n):  
    a, b = 0, 1  
    for _ in range(n):  
        a, b = b, a + b  
    print(f"斐波那契数列第{n}项：{a}")  

start_time = time.time()  

urls = [  
    "https://example.com/file1.jpg",  
    "https://example.com/file2.jpg",  
]  

threads = []  
for url in urls:  
    filename = url.split("/")[-1]  
    t = threading.Thread(target=download_file, args=(url, filename))  
    threads.append(t)  
    t.start()  

calc_thread = threading.Thread(target=fibonacci, args=(30,))  
calc_thread.start()  

for t in threads:  
    t.join()  
calc_thread.join()  

print(f"总耗时：{time.time() - start_time:.2f} 秒")

输出分析：
由于下载文件属于 IO 密集型任务，多线程能显著减少总耗时（相比串行执行）。

五、常见问题与最佳实践

5.1 如何避免死锁？

死锁是多个线程互相等待对方释放资源时的僵局。例如：

lock1 = threading.Lock()  
lock2 = threading.Lock()  

def thread1():  
    with lock1:  
        time.sleep(1)  
        with lock2:  
            print("Thread 1 完成！")  

def thread2():  
    with lock2:  
        time.sleep(1)  
        with lock1:  
            print("Thread 2 完成！")

解决方案：

  • 遵循“按顺序获取锁”的原则，或使用 try ... except 释放已获取的锁。
  • 使用 threading.Condition 或 threading.Semaphore 等高级同步工具。

5.2 多线程与多进程的区别

特征多线程多进程
资源消耗较低（共享内存）较高（独立内存空间）
并行性受 GIL 限制真正并行（无 GIL）
适用场景IO 密集型任务CPU 密集型任务

六、结论

Python 多线程技术通过并发执行任务，为开发者提供了优化程序性能的强大工具。从基础概念到实际案例，本文展示了如何通过 threading 模块创建和管理线程，并探讨了 GIL、线程安全等关键问题。尽管多线程并非万能，但它在 IO 密集型场景中的表现尤为突出。

对于开发者而言，掌握多线程的核心思想和实践技巧，不仅能解决实际问题，更能为后续学习多进程、异步编程等高级技术打下坚实基础。在实际开发中，建议根据任务类型（IO/CPU 密集型）选择合适的技术方案，并始终关注线程同步与资源竞争问题，以构建高效、稳定的系统。

希望这篇文章能帮助你揭开 Python 多线程的神秘面纱，并在实际项目中灵活运用这一技术！

最新发布

查看更多文章