Python多线程通过threading模块实现，适用于I/O密集型任务，因GIL限制无法在CPU密集型任务中并行执行；此时应使用多进程。
Python中实现多线程编程，主要依赖于其标准库中的
threading
模块。这个模块提供了一种高级、面向对象的API来创建和管理线程，让你可以将程序中的某些任务并发执行，尤其在处理I/O密集型操作时，能够显著提高程序的响应速度和效率。然而，对于CPU密集型任务，由于Python全局解释器锁（GIL）的存在，多线程并不能带来真正的并行计算优势，此时通常会考虑使用多进程。
解决方案
Python的
threading
模块是实现多线程的核心。最直接的方式是定义一个函数作为线程的执行体，然后创建
threading.Thread
对象，将这个函数作为
target
参数传入，最后调用
start()
方法启动线程。
一个基本的例子是这样的：
立即学习“Python免费学习笔记（深入）”；
import threadingimport timedef task(name, duration): """一个模拟耗时操作的函数""" print(f"线程 {name}: 正在启动...") time.sleep(duration) # 模拟I/O操作或计算 print(f"线程 {name}: 完成。")# 创建并启动线程thread1 = threading.Thread(target=task, args=("Worker 1", 3))thread2 = threading.Thread(target=task, args=("Worker 2", 2))thread1.start() # 启动线程1thread2.start() # 启动线程2# 等待所有线程完成thread1.join()thread2.join()print("所有线程都已执行完毕。")
在这个例子中，
task
函数是线程要执行的工作。我们创建了两个
Thread
实例，分别传入不同的参数。
start()
方法会启动线程，使其在后台运行。而
join()
方法则非常重要，它会阻塞主线程，直到对应的子线程执行完毕。如果没有
join()
，主线程可能在子线程完成前就退出了。
除了直接传入函数，更面向对象的方法是继承
threading.Thread
类，并重写其
run()
方法。这在需要线程维护自身状态或有更复杂生命周期管理时非常有用。
import threadingimport timeclass MyThread(threading.Thread): def __init__(self, name, duration): super().__init__() self.name = name self.duration = duration def run(self): print(f"线程 {self.name}: 正在启动...") time.sleep(self.duration) print(f"线程 {self.name}: 完成。")thread3 = MyThread("Custom Thread 1", 4)thread4 = MyThread("Custom Thread 2", 1)thread3.start()thread4.start()thread3.join()thread4.join()print("自定义线程也已执行完毕。")
这种方式提供了更好的封装性，让线程的逻辑和数据可以更紧密地结合在一起。
Python多线程真的能提高程序性能吗？它与多进程有何不同？
这是一个我经常被问到的问题，也是很多初学者容易混淆的地方。简而言之，Python多线程能否提高性能，取决于你的任务类型。
对于I/O密集型任务（比如网络请求、文件读写、数据库查询），Python多线程确实能有效提高程序的响应速度和效率。这是因为当一个线程在等待I/O操作完成时（比如等待网络响应），Python的全局解释器锁（GIL）会被释放，允许其他线程运行。这样，CPU就可以在等待I/O的同时，处理其他线程的任务，从而提高整体的并发性。你可以想象成：打电话时，你不需要一直拿着听筒等着对方说话，可以把电话放在一边，做点别的事情，听到响声再拿起。
然而，对于CPU密集型任务（比如大量的数值计算、图像处理），Python多线程在标准的CPython解释器下，并不能实现真正的并行计算，也因此无法提高性能。原因就是那个臭名昭著的全局解释器锁（GIL）。GIL确保了在任何给定时刻，只有一个线程能够执行Python字节码。这意味着即使你有多个线程，它们也只能轮流获得GIL并执行代码，无法同时利用多核CPU的优势。在这种情况下，多线程反而可能因为上下文切换的开销，导致性能略有下降。
与多进程（
multiprocessing
模块）的区别：
GIL的影响：多线程受GIL限制，无法在CPU密集型任务中实现并行。多进程则不受GIL限制，因为每个进程都有自己独立的Python解释器和GIL，它们可以在不同的CPU核心上真正并行运行。内存共享：线程在同一个进程中，共享相同的内存空间。这使得线程间数据共享变得容易，但也带来了数据竞争和同步的复杂性。进程之间则拥有独立的内存空间，数据共享需要通过特定的IPC（Inter-Process Communication）机制（如队列、管道、共享内存）来完成，这通常更复杂一些，但也更安全，因为避免了直接的内存冲突。创建开销：创建线程的开销通常比创建进程小。进程的创建需要复制父进程的内存空间（或使用写时复制技术），这会消耗更多资源和时间。适用场景：多线程适用于I/O密集型任务；多进程适用于CPU密集型任务。
所以，在选择多线程还是多进程时，首先要分析你的程序瓶颈在哪里。如果瓶颈在等待外部资源（网络、磁盘），那么
threading
很可能是个好选择；如果瓶颈在CPU计算，那么
multiprocessing
会是更合适的方案。
如何避免多线程中的数据竞争问题？锁（Lock）的实际应用
在多线程编程中，当多个线程尝试同时访问和修改同一个共享资源（比如一个全局变量、一个列表或一个文件）时，就可能发生数据竞争（Race Condition）。这会导致数据不一致、结果错误，甚至程序崩溃。这就像多个人同时往一个银行账户里存钱取钱，如果没有排队或协调，账目就容易乱掉。
为了解决这个问题，我们需要引入线程同步机制。Python的
threading
模块提供了多种同步原语，其中最基础和常用的是锁（Lock）。
Lock
对象就像一个门卫，它只有一个钥匙。当一个线程想要访问共享资源时，它必须先尝试“获取”这把钥匙（即调用
acquire()
方法）。如果钥匙已经被其他线程拿走了，当前线程就会被阻塞，直到钥匙被释放。当线程完成对共享资源的访问后，它必须“释放”这把钥匙（即调用
release()
方法），以便其他等待的线程可以获取它。
来看一个经典的例子：多个线程对同一个计数器进行递增操作。
import threadingimport timecounter = 0# 创建一个锁对象lock = threading.Lock()def increment_counter(): global counter for _ in range(100000): # 获取锁 lock.acquire() try: counter += 1 finally: # 确保锁被释放，即使发生异常 lock.release()threads = []for i in range(5): thread = threading.Thread(target=increment_counter) threads.append(thread) thread.start()for thread in threads: thread.join()print(f"最终计数器值: {counter}")# 理论上应该是 5 * 100000 = 500000
如果没有锁的保护，
counter
的最终值几乎不可能是500000。因为
counter += 1
这个操作实际上包含了读取、递增、写入三个步骤，在这些步骤之间，线程可能会被切换，导致数据丢失。
使用
lock.acquire()
和
lock.release()
是基础用法。更推荐的做法是使用
with
语句，因为它能确保锁在代码块执行完毕后（无论是否发生异常）自动释放，避免了忘记释放锁导致死锁的风险：
# ... (前面的导入和counter定义不变)def increment_counter_with_lock(): global counter for _ in range(100000): with lock: # 自动获取和释放锁 counter += 1# ... (创建和启动线程的代码不变)
这种
with lock:
的写法简洁又安全，是Python中处理锁的惯用模式。
除了
Lock
，
threading
模块还提供了其他更复杂的同步原语，比如：
RLock
(可重入锁)：同一个线程可以多次获取同一个
RLock
，但必须释放相同次数。适用于递归调用或同一个线程需要多次加锁的场景。
Semaphore
(信号量)：控制对共享资源的访问数量，而不是像
Lock
那样只允许一个。可以限制同时访问某个资源的线程数量。
Event
(事件)：用于线程间的通信，一个线程发送事件，其他线程等待事件发生。
Condition
(条件变量)：比
Event
更高级的通信机制，允许线程在特定条件满足时等待和被唤醒。
对于大多数数据竞争问题，
Lock
已经足够。选择合适的同步机制，是编写健壮多线程程序的关键。
守护线程（Daemon Thread）在Python多线程中扮演什么角色？
在Python的多线程世界里，线程可以分为两种：用户线程（或非守护线程）和守护线程（Daemon Thread）。它们的区别在于，当主程序退出时，它们是否会阻止程序终止。
用户线程：默认情况下，你创建的所有线程都是用户线程。这意味着，即使主线程执行完毕，只要有任何一个用户线程还在运行，Python解释器就不会退出，它会等待所有用户线程完成。守护线程：守护线程则不同。它是一种“后台”线程，当主线程退出时，无论守护线程是否完成，Python解释器都会强制终止整个程序，不会等待守护线程。你可以把守护线程想象成主程序的服务员，主程序一打烊，服务员就得立刻走人，不管手头的工作有没有做完。
如何设置守护线程？
在创建
Thread
对象之后，但在调用
start()
方法之前，将
daemon
属性设置为
True
即可：
import threadingimport timedef daemon_task(): print("守护线程: 正在启动，将运行5秒...") time.sleep(5) print("守护线程: 理论上会完成，但可能被提前终止。")def normal_task(): print("普通线程: 正在启动，将运行2秒...") time.sleep(2) print("普通线程: 完成。")daemon_t = threading.Thread(target=daemon_task)daemon_t.daemon = True # 设置为守护线程normal_t = threading.Thread(target=normal_task)daemon_t.start()normal_t.start()print("主线程: 启动了子线程，现在等待普通线程完成。")normal_t.join() # 主线程等待普通线程完成print("主线程: 普通线程已完成，现在主线程将退出。")# 此时，如果daemon_t还没完成，它会被强制终止。
运行这段代码，你会发现
daemon_task
中的“理论上会完成”那句话可能不会被打印出来，因为它在主线程退出时被“斩断”了。
守护线程的适用场景：
守护线程通常用于那些不需要程序等待其完成的任务，例如：
后台日志记录：持续将程序运行信息写入日志文件，即使主程序突然崩溃，也不影响主程序的退出。心跳包发送：定期向服务器发送心跳包以维持连接，主程序退出时，连接自然断开即可。缓存清理：定期清理过期缓存。资源监控：在后台监控系统资源使用情况。
使用守护线程的注意事项：
由于守护线程在主程序退出时会被突然终止，它们可能没有机会进行清理工作，比如关闭文件句柄、释放网络连接等。这可能导致资源泄露或数据损坏。因此，在使用守护线程时，要特别注意其任务的性质，确保即使被突然终止也不会造成严重后果。如果需要确保清理工作完成，那么它就不适合作为守护线程，或者需要额外的机制来优雅地关闭它。
以上就是python中如何实现多线程编程_Python threading模块多线程编程入门的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1372142.html
微信扫一扫 
支付宝扫一扫 
![Go语言接口与切片：如何识别和操作[]interface{}](https://cdn.chuangxiangniao.com/www/2025/12/176369856569294-1.jpg?imageMogr2/crop/480x300/gravity/center)
