Python多线程通过threading模块实现，适用于I/O密集型任务，因GIL限制无法在CPU密集型任务中并行执行；此时应使用多进程。
Python中实现多线程编程，主要依赖于其标准库中的
threading模块。这个模块提供了一种高级、面向对象的API来创建和管理线程，让你可以将程序中的某些任务并发执行，尤其在处理I/O密集型操作时，能够显著提高程序的响应速度和效率。然而，对于CPU密集型任务，由于Python全局解释器锁（GIL）的存在，多线程并不能带来真正的并行计算优势，此时通常会考虑使用多进程。
解决方案
Python的
threading模块是实现多线程的核心。最直接的方式是定义一个函数作为线程的执行体，然后创建
threading.Thread对象，将这个函数作为
target参数传入，最后调用
start()方法启动线程。
一个基本的例子是这样的：
立即学习“Python免费学习笔记（深入）”；
import threading
import time
def 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() # 启动线程1
thread2.start() # 启动线程2
# 等待所有线程完成
thread1.join()
thread2.join()
print("所有线程都已执行完毕。")在这个例子中，
task函数是线程要执行的工作。我们创建了两个
Thread实例，分别传入不同的参数。
start()方法会启动线程，使其在后台运行。而
join()方法则非常重要，它会阻塞主线程，直到对应的子线程执行完毕。如果没有
join()，主线程可能在子线程完成前就退出了。
除了直接传入函数，更面向对象的方法是继承
threading.Thread类，并重写其
run()方法。这在需要线程维护自身状态或有更复杂生命周期管理时非常有用。
import threading
import time
class 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）。
这本书给出了一份关于python这门优美语言的精要的参考。作者通过一个完整而清晰的入门指引将你带入python的乐园，随后在语法、类型和对象、运算符与表达式、控制流函数与函数编程、类及面向对象编程、模块和包、输入输出、执行环境等多方面给出了详尽的讲解。如果你想加入 python的世界，David M beazley的这本书可不要错过哦。 (封面是最新英文版的,中文版貌似只译到第二版)
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()
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 threading
import time
def 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中的“理论上会完成”那句话可能不会被打印出来，因为它在主线程退出时被“斩断”了。
守护线程的适用场景：
守护线程通常用于那些不需要程序等待其完成的任务，例如：
- 后台日志记录：持续将程序运行信息写入日志文件，即使主程序突然崩溃，也不影响主程序的退出。
- 心跳包发送：定期向服务器发送心跳包以维持连接，主程序退出时，连接自然断开即可。
- 缓存清理：定期清理过期缓存。
- 资源监控：在后台监控系统资源使用情况。
使用守护线程的注意事项：
由于守护线程在主程序退出时会被突然终止，它们可能没有机会进行清理工作，比如关闭文件句柄、释放网络连接等。这可能导致资源泄露或数据损坏。因此，在使用守护线程时，要特别注意其任务的性质，确保即使被突然终止也不会造成严重后果。如果需要确保清理工作完成，那么它就不适合作为守护线程，或者需要额外的机制来优雅地关闭它。
