首页
/ 正文

Python3 多线程（千字长文）

更新时间: 2025-03-23 16:15:28

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

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

新项目:《从零手撸：仿小红书（微服务架构）》 正在持续爆肝中，基于 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+ 小伙伴加入学习，欢迎点击围观

前言

在编程世界中，Python3 多线程如同为程序安装了多个“引擎”，让代码能够在同一时间执行多个任务。无论是处理网络请求、文件下载，还是实时数据分析，多线程技术都能显著提升程序的执行效率。然而，对于许多开发者而言，多线程的概念既熟悉又陌生——熟悉是因为它常被提及，陌生则源于其复杂性。本文将通过通俗的比喻、清晰的代码示例和分步讲解，帮助初学者和中级开发者逐步掌握 Python3 多线程的核心原理与实践技巧。

一、多线程基础：为什么需要并行？

1.1 线程 vs 进程：一个简单的比喻

可以将线程理解为“程序中的小工人”，而进程则是“整个工厂”。一个进程可以包含多个线程，就像一个工厂里有多个工人协作完成任务。线程的优势在于：

轻量级：线程切换开销小，适合快速切换任务；
资源共享：同一进程内的线程共享内存空间，数据传递更高效。

1.2 多线程的核心作用

在 Python 中，多线程主要用于 I/O 密集型任务（如网络请求、文件读写），而非 CPU 密集型任务（如复杂计算）。这是因为 Python 的 全局解释器锁（GIL） 会限制多线程在 CPU 密集场景下的性能（后文详细解释）。

二、如何创建和管理线程？

2.1 核心模块：`threading`

Python 的 threading 模块提供了丰富的线程管理功能。以下是创建线程的简单步骤：

示例 1：基本线程创建

import threading  
import time  

def print_numbers():  
    for i in range(5):  
        print(f"Number: {i}")  
        time.sleep(1)  

def print_letters():  
    for c in ['A', 'B', 'C']:  
        print(f"Letter: {c}")  
        time.sleep(1)  

thread1 = threading.Thread(target=print_numbers)  
thread2 = threading.Thread(target=print_letters)  

thread1.start()  
thread2.start()  

thread1.join()  
thread2.join()

运行结果：

Number: 0  
Letter: A  
Number: 1  
Letter: B  
...（输出顺序可能交错）

关键点解析：

Thread(target=...)：指定线程执行的目标函数；
.start()：真正启动线程；
.join()：等待线程执行完毕后再继续主线程。

2.2 线程的生命周期

线程从创建到结束会经历以下阶段：
| 阶段 | 描述 |
|---------------|----------------------------------------|
| 就绪 | 线程已创建但尚未启动 |
| 运行 | 线程被 CPU 调度执行 |
| 阻塞 | 因 I/O 操作或等待其他线程而暂停 |
| 终止 | 线程任务完成或被强制终止 |

三、线程同步：避免“数据混乱”的关键

3.1 问题场景：竞态条件（Race Condition）

假设多个线程同时修改一个共享变量，可能导致结果不可预测。例如：

balance = 0  

def withdraw(amount):  
    global balance  
    balance -= amount  

def deposit(amount):  
    global balance  
    balance += amount

此时，balance 的值可能因线程交替执行而出现错误。

3.2 解决方案：锁（Lock）

通过 threading.Lock() 可以实现对共享资源的互斥访问：

import threading  

balance = 0  
lock = threading.Lock()  

def withdraw(amount):  
    global balance  
    with lock:  # 仅允许一个线程进入此代码块  
        balance -= amount  

def deposit(amount):  
    global balance  
    with lock:  
        balance += amount

比喻解释：

锁的作用如同“交通灯”，确保同一时间只有一个线程能操作共享资源，避免“撞车”。

3.3 其他同步工具：信号量（Semaphore）

信号量用于控制同时访问资源的线程数量。例如，限制最多 3 个线程访问数据库：

semaphore = threading.Semaphore(3)  

def access_database():  
    with semaphore:  
        # 数据库操作代码  
        pass

四、实际案例：多线程在 Web 爬虫中的应用

4.1 场景需求

假设需要同时下载多个网页内容，传统单线程方式耗时过长。通过多线程可显著提速。

示例 2：并行下载网页

import threading  
import requests  

urls = [  
    "https://example.com/page1",  
    "https://example.com/page2",  
    "https://example.com/page3"  
]  

def download(url):  
    response = requests.get(url)  
    print(f"Downloaded {url} with {len(response.text)} bytes")  

threads = []  
for url in urls:  
    thread = threading.Thread(target=download, args=(url,))  
    thread.start()  
    threads.append(thread)  

for thread in threads:  
    thread.join()

输出效果：

Downloaded https://example.com/page2 with 1500 bytes  
Downloaded https://example.com/page1 with 1200 bytes  
Downloaded https://example.com/page3 with 1800 bytes

关键点：

线程池（ThreadPoolExecutor）可进一步优化资源管理，但需注意线程数量与硬件的匹配。

五、GIL 的限制与替代方案

5.1 全局解释器锁（GIL）

Python 的 GIL 是一个关键特性，它确保同一时间只有一个线程执行 Python 字节码。这意味着：

CPU 密集型任务（如科学计算）无法通过多线程提速；
I/O 密集型任务（如网络请求）因线程等待 I/O 的时间较长，仍能显著提升效率。

5.2 替代方案

对于 CPU 密集型任务，可考虑以下方案：

多进程（multiprocessing）：通过进程隔离避免 GIL 限制；
异步编程（asyncio）：利用事件循环实现非阻塞 I/O。

示例 3：多进程计算

from multiprocessing import Process  
import time  

def calculate(n):  
    sum = 0  
    for i in range(n):  
        sum += i  
    print(f"Sum of {n} numbers: {sum}")  

if __name__ == "__main__":  
    p1 = Process(target=calculate, args=(10**8,))  
    p2 = Process(target=calculate, args=(10**8,))  
    p1.start()  
    p2.start()  
    p1.join()  
    p2.join()

六、总结与最佳实践

6.1 多线程的核心价值

提升 I/O 密集型任务的效率；
简化异步操作的逻辑（如并发下载、实时监控）。

6.2 开发注意事项

避免过度使用线程：过多线程可能因切换开销降低性能；
谨慎处理共享资源：通过锁或信号量确保数据一致性；
测试与监控：使用日志或性能分析工具排查线程死锁或资源竞争问题。

6.3 进阶方向

学习 concurrent.futures 模块，简化线程/进程池的使用；
探索 asyncio 的协程模型，实现更高效的异步编程。

结论

Python3 多线程是提升程序性能的重要工具，但需结合场景合理选择。通过本文的讲解，读者应能掌握线程的基础操作、同步机制及实际应用案例。未来，随着 Python 生态的演进，多线程与异步编程的结合将为开发者提供更多优化空间。希望本文能成为您深入探索并发编程的起点！