Python多线程适用于I/O密集型任务，因GIL在I/O等待时释放，允许其他线程运行，从而提升并发效率；但CPU密集型任务应使用multiprocessing模块实现真正并行。
Python中实现多线程，主要依赖内置的
threading
模块。它的核心思想是让程序在同一进程内并发执行多个任务，尤其适合处理那些需要等待外部资源响应（比如网络请求、文件读写）的I/O密集型操作。不过，Python的全局解释器锁（GIL）是个绕不开的话题，它意味着在任何时刻，只有一个线程能真正执行Python字节码，这使得多线程在CPU密集型任务上并不能实现真正的并行计算。
解决方案
在Python里，多线程编程主要围绕
threading
模块展开。最直接的方式就是创建
threading.Thread
的实例。你可以给它传入一个可调用对象（比如函数）作为目标任务，然后调用
start()
方法启动线程，最后用
join()
等待线程完成。
import threadingimport timedef task(name): print(f"线程 {name}: 启动") time.sleep(2) # 模拟I/O操作，比如网络请求或文件读写 print(f"线程 {name}: 结束")# 创建线程thread1 = threading.Thread(target=task, args=("一号",))thread2 = threading.Thread(target=task, args=("二号",))# 启动线程thread1.start()thread2.start()# 等待所有线程完成thread1.join()thread2.join()print("所有线程都已完成。")
当然，更高级一点，我们还会用到
concurrent.futures
模块中的
ThreadPoolExecutor
，它提供了一个更简洁、更方便的线程池管理方式，省去了手动创建和管理线程的麻烦。我个人觉得，对于大多数并发任务，尤其是那些I/O密集型的，
ThreadPoolExecutor
是个非常好的起点，它让代码看起来更整洁，也更容易管理。
from concurrent.futures import ThreadPoolExecutorimport timedef intensive_io_task(url): print(f"开始下载 {url}...") time.sleep(1 + hash(url) % 3) # 模拟网络延迟 print(f"完成下载 {url}") return f"内容来自 {url}"urls = [ "http://example.com/page1", "http://example.com/page2", "http://example.com/page3", "http://example.com/page4"]# 使用ThreadPoolExecutor创建线程池，max_workers指定最大线程数with ThreadPoolExecutor(max_workers=3) as executor: # 提交任务并获取Future对象 futures = [executor.submit(intensive_io_task, url) for url in urls] for future in futures: # future.result()会阻塞直到任务完成并返回结果 print(f"结果: {future.result()}")print("所有网络请求已处理完毕。")
多线程的核心挑战之一是共享数据的同步。Python提供了多种同步原语来避免竞态条件（race condition），比如
Lock
、
RLock
、
Semaphore
、
Event
和
Condition
。
Lock
是最基础的，它确保同一时间只有一个线程能访问被保护的代码块或数据。
立即学习“Python免费学习笔记（深入）”；
import threadingbalance = 0lock = threading.Lock() # 创建一个锁def deposit(amount): global balance for _ in range(100000): lock.acquire() # 获取锁 try: balance += amount finally: lock.release() # 释放锁，确保即使出错也能释放def withdraw(amount): global balance for _ in range(100000): lock.acquire() try: balance -= amount finally: lock.release()thread_deposit = threading.Thread(target=deposit, args=(1,))thread_withdraw = threading.Thread(target=withdraw, args=(1,))thread_deposit.start()thread_withdraw.start()thread_deposit.join()thread_withdraw.join()print(f"最终余额: {balance}") # 理论上应该是0，如果不用锁，结果会不确定
这里我们用
Lock
保护了
balance
变量，确保了并发操作的原子性，避免了因多线程同时修改导致的数据错误。
Python多线程在I/O密集型任务中为何表现出色？（及其背后的GIL考量）
说实话，很多人一提到Python多线程，第一个想到的就是全局解释器锁（GIL），然后就觉得“Python多线程没用”或者“它根本不能并行”。但这种观点有点儿片面。我个人觉得，理解GIL的关键在于它只允许一个线程在任何给定时间执行Python字节码，但这并不意味着当一个线程在等待外部I/O操作（比如从网络读取数据、写入文件、数据库查询）时，其他线程就不能运行了。恰恰相反，当一个Python线程执行I/O操作时，它会主动释放GIL，这样其他等待中的Python线程就有机会获取GIL并执行它们的Python代码。
这就是为什么Python多线程在处理I/O密集型任务时非常有效。想象一下，你的程序需要同时下载多个文件，或者向多个API发送请求。如果用单线程，你必须等待一个下载完成后才能开始下一个，效率极低。而多线程则可以同时发起这些请求，当一个线程在等待网络响应时，另一个线程可以继续处理它的网络请求。这样一来，虽然你的CPU并没有并行地执行Python代码，但你的程序却在“等待”的时间上实现了并发，大大提升了整体吞吐量。
在我看来，这种“并发而非并行”的特性，让Python多线程在Web服务器、爬虫、数据采集、GUI应用（保持UI响应）等场景下大放异彩。它能有效利用等待时间，让程序看起来更快、响应更及时。所以，别被GIL吓倒，关键是看你的任务类型。
如何在Python多线程应用中安全地共享数据并避免竞态条件？
多线程编程最让人头疼的问题之一就是数据同步和竞态条件。多个线程同时访问和修改同一个共享资源，如果没有适当的保护，结果往往是不可预测的，甚至会引发难以调试的bug。这就像多个人同时往一个存钱罐里扔钱或取钱，如果没有规矩，账目肯定乱套。
Python的
threading
模块提供了一系列同步原语来解决这个问题。最常用也最基础的是
threading.Lock
。它是一个互斥锁，任何时候只有一个线程能持有这个锁。当一个线程
acquire()
（获取）了锁，其他试图获取同一把锁的线程就会被阻塞，直到持有锁的线程
release()
（释放）它。这确保了被锁保护的代码块（我们称之为“临界区”）在任何时候都只被一个线程执行。
import threadingshared_data = []data_lock = threading.Lock() # 创建一个锁实例def add_data(item): # 使用with语句管理锁，更安全、更简洁，避免忘记释放 with data_lock: shared_data.append(item) print(f"线程 {threading.current_thread().name} 添加了: {item}, 当前数据: {shared_data}")threads = [threading.Thread(target=add_data, args=(i,), name=f"Worker-{i}") for i in range(5)]for t in threads: t.start()for t in threads: t.join()print(f"最终共享数据: {shared_data}")
除了
Lock
，还有
RLock
（可重入锁，同一个线程可以多次获取而不会死锁）、
Semaphore
（信号量，控制同时访问资源的线程数量）、
Event
（事件，用于线程间的简单通信）和
Condition
（条件变量，更复杂的线程间通信）。
不过，我个人觉得，如果共享的数据结构比较复杂，或者线程间的通信需求很高，直接操作锁会变得非常繁琐且容易出错。这时候，
queue
模块就显得尤为重要了。
queue.Queue
（以及
LifoQueue
和
PriorityQueue
）是线程安全的队列，它内部已经处理好了锁机制，你只需要简单地
put()
和
get()
数据，就能安全地在线程间传递信息，大大降低了出错的概率。这是我处理线程间数据交换时最喜欢用的工具，它把复杂的同步细节都封装起来了。
Python多线程的适用边界：何时应避免使用，以及更优的替代方案
虽然Python多线程在I/O密集型任务中表现不俗，但它并非万金油。我有时会遇到一些开发者，无论什么任务都想用多线程来“加速”，结果发现性能不升反降，甚至程序变得更慢了。这通常是因为他们没有充分理解多线程的适用边界。
最核心的一点，就是前面提到的GIL。如果你的任务是CPU密集型的，比如大量的数学计算、图像处理、数据分析（不涉及I/O等待），那么Python的多线程并不能带来真正的并行计算。因为GIL的存在，同一时刻只有一个线程在执行Python字节码，其他线程都在等待GIL的释放。这种情况下，创建多个线程反而会增加额外的开销，比如线程创建、销毁、上下文切换的成本，这反而会让程序的总执行时间变长。
那么，当遇到CPU密集型任务时，我们应该怎么做呢？
multiprocessing
模块： 这是Python官方推荐的解决方案，用于实现真正的并行计算。
multiprocessing
模块通过创建独立的进程来规避GIL的限制，每个进程都有自己的Python解释器和内存空间。这意味着它们可以同时在多核CPU上运行，实现真正的并行。虽然进程间的通信比线程间复杂一些（需要序列化数据），但对于CPU密集型任务，它的性能提升是显而易见的。我个人觉得，如果你真的需要压榨多核CPU的性能，
multiprocessing
是你的首选。
import multiprocessingimport timedef cpu_bound_task(n): process_name = multiprocessing.current_process().name print(f"进程 {process_name}: 开始计算 {n}...") result = sum(i*i for i in range(n)) print(f"进程 {process_name
以上就是Python中多线程怎么实现 Python中多线程编程指南的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1368951.html
微信扫一扫 
支付宝扫一扫 
