Python多线程入门：threading模块全解析

学习文章要努力，但是不要急！今天的这篇文章《Python多线程编程入门：threading模块详解》将会介绍到等等知识点，如果你想深入学习文章，可以关注我！我会持续更新相关文章的，希望对大家都能有所帮助！

Python多线程通过threading模块实现，适用于I/O密集型任务，因GIL限制无法在CPU密集型任务中并行执行；此时应使用多进程。

Python中实现多线程编程，主要依赖于其标准库中的threading模块。这个模块提供了一种高级、面向对象的API来创建和管理线程，让你可以将程序中的某些任务并发执行，尤其在处理I/O密集型操作时，能够显著提高程序的响应速度和效率。然而，对于CPU密集型任务，由于Python全局解释器锁（GIL）的存在，多线程并不能带来真正的并行计算优势，此时通常会考虑使用多进程。

解决方案

Python的threading模块是实现多线程的核心。最直接的方式是定义一个函数作为线程的执行体，然后创建threading.Thread对象，将这个函数作为target参数传入，最后调用start()方法启动线程。

一个基本的例子是这样的：

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）。

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中的“理论上会完成”那句话可能不会被打印出来，因为它在主线程退出时被“斩断”了。

守护线程的适用场景：

守护线程通常用于那些不需要程序等待其完成的任务，例如：

• 后台日志记录：持续将程序运行信息写入日志文件，即使主程序突然崩溃，也不影响主程序的退出。
• 心跳包发送：定期向服务器发送心跳包以维持连接，主程序退出时，连接自然断开即可。
• 缓存清理：定期清理过期缓存。
• 资源监控：在后台监控系统资源使用情况。

使用守护线程的注意事项：

由于守护线程在主程序退出时会被突然终止，它们可能没有机会进行清理工作，比如关闭文件句柄、释放网络连接等。这可能导致资源泄露或数据损坏。因此，在使用守护线程时，要特别注意其任务的性质，确保即使被突然终止也不会造成严重后果。如果需要确保清理工作完成，那么它就不适合作为守护线程，或者需要额外的机制来优雅地关闭它。

理论要掌握，实操不能落！以上关于《Python多线程入门：threading模块全解析》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！