Python多线程怎么用？入门教程详解

有志者，事竟成！如果你在学习文章，那么本文《Python多线程怎么实现？入门指南》，就很适合你！文章讲解的知识点主要包括，若是你对本文感兴趣，或者是想搞懂其中某个知识点，就请你继续往下看吧~

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的多线程“形同虚设”，无法实现真正的并行。这其实是一种误解，或者说，是不够全面的理解。

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多线程怎么用？入门教程详解》的内容了。个人认为，基础知识的学习和巩固，是为了更好的将其运用到项目中，欢迎关注golang学习网公众号，带你了解更多关于锁,队列,Python多线程,gil,threading模块的知识点！