Python多线程通过threading模块实现，适用于I/O密集型任务。尽管GIL限制了CPU密集型任务的并行执行，但在I/O操作时会释放GIL，允许多线程并发提升性能。使用Lock可避免共享数据的竞态条件，确保操作原子性；而queue.Queue提供线程安全的数据交换机制，适用于生产者-消费者模型等场景，降低线程耦合，提升程序健壮性。
Python实现多线程主要通过内置的
threading
模块。它允许程序在同一时间执行多个任务，从而提升应用程序的响应速度和处理效率，尤其是在处理I/O密集型操作时表现出色。尽管CPython解释器存在全局解释器锁（GIL），限制了多线程在CPU密集型任务上的并行能力，但对于那些需要等待外部资源（如网络请求、文件读写）的任务，多线程依然是优化性能的有效手段。
解决方案
在Python中实现多线程，最直接的方式是使用
threading
模块。我们可以定义一个函数作为线程要执行的任务，然后创建
threading.Thread
实例，将函数作为目标（target）传递进去，最后启动线程。
import threading import time def task_function(name, delay): """一个简单的线程任务函数""" print(f"线程 {name}: 启动...") time.sleep(delay) print(f"线程 {name}: 完成任务。") # 创建并启动线程 thread1 = threading.Thread(target=task_function, args=("Worker 1", 2)) thread2 = threading.Thread(target=task_function, args=("Worker 2", 3)) thread1.start() # 启动线程1 thread2.start() # 启动线程2 # 等待所有线程完成 thread1.join() thread2.join() print("所有线程已完成。主程序退出。")
这段代码展示了如何创建两个独立的线程，它们各自执行
task_function
。
start()
方法启动线程，而
join()
方法则让主线程等待子线程执行完毕后再继续执行，这在很多场景下是确保程序正确性的关键。
Python多线程真的能“并行”执行吗？深入理解GIL（全局解释器锁）
很多人一提到Python多线程，就会立刻想到GIL（Global Interpreter Lock），并且认为它让Python的多线程“形同虚设”，无法实现真正的并行。这其实是一种误解，或者说，是不够全面的理解。
立即学习“Python免费学习笔记（深入）”；
GIL确实是CPython（最常用的Python解释器）的一个特性，它确保在任何时候，只有一个线程能够执行Python字节码。这意味着，即使你的机器有多个CPU核心，CPython的多线程在执行CPU密集型任务时，也无法真正地并行利用这些核心。它更像是“并发”而非“并行”——线程们轮流获得GIL，快速切换执行，给人一种同时进行的错觉。
那么，GIL的存在是完全的弊端吗？并非如此。GIL的设计初衷是为了简化CPython的内存管理，避免复杂的锁机制，从而让解释器本身更易于开发和维护。没有GIL，Python对象的引用计数将变得非常复杂，每次操作都需要加锁，反而可能导致性能下降。
关键在于，GIL在I/O操作（如文件读写、网络请求）时是会被释放的。当一个线程需要等待外部资源时，它会主动释放GIL，让其他线程有机会获得GIL并执行。这就是为什么Python多线程在处理I/O密集型任务时依然能发挥巨大作用，显著提升程序的响应速度和吞吐量。它不是让你的CPU跑满所有核心，而是让你的程序在等待外部资源时不至于“卡死”，能够同时处理其他任务。所以，对于网络爬虫、Web服务等场景，多线程依然是Python的利器。
如何在Python多线程中安全地共享数据？锁（Lock）与同步机制
在多线程环境中，多个线程可能会同时访问和修改同一份数据。如果不对这些操作进行适当的控制，就可能出现所谓的“竞态条件”（Race Condition），导致数据不一致或程序崩溃。这就像多个人同时去抢一个座位，如果没有规则，结果会一团糟。
为了解决这个问题，我们需要引入同步机制，其中最常用、最基础的就是锁（
threading.Lock
）。锁就像一个门卫，一次只允许一个线程进入临界区（即访问共享数据的代码段）。
来看一个经典的例子：多个线程对一个共享计数器进行加一操作。
import threading import time shared_counter = 0 # 创建一个锁 lock = threading.Lock() def increment_counter(): global shared_counter for _ in range(100000): # 获取锁 lock.acquire() try: shared_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"最终计数器值（使用锁）：{shared_counter}") # 假设没有锁，会发生什么？ # shared_counter_no_lock = 0 # def increment_counter_no_lock(): # global shared_counter_no_lock # for _ in range(100000): # shared_counter_no_lock += 1 # # threads_no_lock = [] # for i in range(5): # thread = threading.Thread(target=increment_counter_no_lock) # threads_no_lock.append(thread) # thread.start() # # for thread in threads_no_lock: # thread.join() # # print(f"最终计数器值（无锁）：{shared_counter_no_lock}") # 这个值几乎每次运行都会小于500000
在上面的例子中，如果没有
lock.acquire()
和
lock.release()
，
shared_counter
的最终值几乎肯定会小于预期的500000。这是因为多个线程可能同时读取旧值，然后各自加一，再写回，导致部分增量丢失。使用锁后，每次只有一个线程能进入
shared_counter += 1
这行代码，确保了操作的原子性。
为了代码更简洁和安全，Python推荐使用
with
语句来管理锁：
def increment_counter_with_with(): global shared_counter for _ in range(100000): with lock: # 自动获取锁并在代码块结束时释放 shared_counter += 1
除了
Lock
，
threading
模块还提供了其他更复杂的同步原语，如
RLock
（可重入锁）、
Semaphore
（信号量）、
Condition
（条件变量）和
Event
（事件），它们能应对更复杂的同步需求，但在入门阶段，理解并掌握
Lock
的使用至关重要。
线程间通信：队列（Queue）在多线程编程中的妙用
仅仅通过共享变量和锁来同步数据，对于复杂的数据交换场景，可能会变得非常笨重和容易出错。当一个线程需要将处理结果传递给另一个线程，或者多个线程需要协作完成一个任务时，线程安全的队列（
queue.Queue
）就显得尤为重要。它提供了一种优雅、高效且线程安全的数据交换机制。
queue.Queue
模块提供了几种队列实现：
-
queue.Queue
：先进先出（FIFO）队列。
-
queue.LifoQueue
：后进先出（LIFO）队列。
-
queue.PriorityQueue
：优先级队列。
它们都是线程安全的，这意味着你可以在多个线程中安全地调用它们的
put()
（放入数据）和
get()
（取出数据）方法，而无需自己手动加锁。
一个典型的应用场景是“生产者-消费者”模型。一个或多个生产者线程负责生成任务或数据，并将其放入队列；一个或多个消费者线程则从队列中取出数据进行处理。
import threading import queue import time # 创建一个线程安全的队列 task_queue = queue.Queue() def producer(name, num_tasks): """生产者线程：生成任务并放入队列""" print(f"生产者 {name}: 启动...") for i in range(num_tasks): task = f"任务-{name}-{i+1}" task_queue.put(task) # 放入队列 print(f"生产者 {name}: 放入 {task}") time.sleep(0.1) # 模拟生产耗时 print(f"生产者 {name}: 完成所有任务生产。") task_queue.put(None) # 发送结束信号 def consumer(name): """消费者线程：从队列取出任务并处理""" print(f"消费者 {name}: 启动...") while True: task = task_queue.get() # 从队列取出任务 if task is None: # 收到结束信号 task_queue.put(None) # 将结束信号再放回队列，通知其他消费者 break print(f"消费者 {name}: 处理 {task}") time.sleep(0.5) # 模拟处理耗时 task_queue.task_done() # 标记任务完成 print(f"消费者 {name}: 完成所有任务处理。") # 启动生产者和消费者 producer_thread = threading.Thread(target=producer, args=("P1", 5)) consumer_thread1 = threading.Thread(target=consumer, args=("C1",)) consumer_thread2 = threading.Thread(target=consumer, args=("C2",)) producer_thread.start() consumer_thread1.start() consumer_thread2.start() # 等待生产者完成 producer_thread.join() # 等待所有任务被处理完毕 task_queue.join() # 阻塞直到队列中的所有任务都被get()并且task_done() # 等待消费者接收到结束信号并退出 consumer_thread1.join() consumer_thread2.join() print("所有生产者和消费者已完成。主程序退出。")
在这个例子中，生产者线程将任务放入
task_queue
，消费者线程则从队列中取出任务。
task_queue.put(None)
是一个简单的结束信号机制，确保所有消费者都能优雅地退出。
task_queue.join()
和
task_queue.task_done()
的配合使用，则可以方便地等待所有队列中的任务都被处理完毕，这在实际项目中非常有用。通过队列，线程间的耦合度降低，代码结构也更加清晰和健壮。
python 网络爬虫 app 爬虫 无锁 同步机制 为什么 red 有锁 Python Event 线程 多线程 主线程 Thread 并发 对象 事件