Python threading模块：多线程编程的实战指南

站大爷IP
132 阅读9分钟

​

在Python编程中，多线程技术是提升程序效率的关键工具。当程序需要同时处理多个任务时，单线程的串行执行模式会成为性能瓶颈。例如，一个需要同时下载多个文件并实时显示进度的程序，若采用单线程设计，用户将不得不忍受漫长的等待时间。而Python的threading模块通过提供线程管理功能，让开发者能够轻松实现并发处理，显著提升程序响应速度。

免费python编程教程：pan.quark.cn/s/2c17aed36…

一、线程基础：理解最小执行单元

线程是操作系统调度的最小单位，它被封装在进程内部，共享进程的内存空间。以浏览器为例，每个标签页可能对应一个独立线程，这些线程可以同时加载页面、执行JavaScript脚本，而不会互相阻塞。Python的threading模块通过模拟这种机制，允许开发者在单个进程中创建多个线程，每个线程执行独立的任务。

1.1 线程的创建方式

Python提供了两种创建线程的方法：函数式和类式。

函数式创建：直接实例化Thread类，传入目标函数和参数。例如：

import threading

def print_number(num):
    print(f"线程执行: {num}")

thread = threading.Thread(target=print_number, args=(1,))
thread.start()
thread.join()  # 等待线程结束

转存失败，建议直接上传图片文件

这段代码创建了一个线程，执行print_number函数并传入参数1。start()方法启动线程，join()方法确保主线程等待子线程完成。

类式创建：通过继承Thread类并重写run()方法实现更复杂的逻辑。例如：

class MyThread(threading.Thread):
    def __init__(self, name):
        super().__init__(name=name)
    
    def run(self):
        print(f"{self.name} 开始执行")
        # 模拟耗时操作
        import time
        time.sleep(1)
        print(f"{self.name} 执行完成")

thread1 = MyThread("线程A")
thread2 = MyThread("线程B")
thread1.start()
thread2.start()
thread1.join()
thread2.join()

转存失败，建议直接上传图片文件

类式创建适合需要维护线程状态的场景，例如每个线程需要跟踪自己的进度或资源。

1.2 线程的生命周期

线程从创建到销毁经历五个阶段：

  1. 新建：实例化Thread对象，此时线程尚未启动。
  2. 就绪：调用start()方法后，线程进入就绪队列，等待CPU调度。
  3. 运行：线程获得CPU时间片，执行run()方法中的代码。
  4. 阻塞：线程因等待资源（如I/O操作）或主动调用sleep()而暂停执行。
  5. 死亡：run()方法执行完毕或抛出未捕获异常，线程终止。

通过is_alive()方法可以检查线程是否处于活动状态。例如：

thread = threading.Thread(target=lambda: print("执行中"))
thread.start()
print(thread.is_alive())  # 输出True
thread.join()
print(thread.is_alive())  # 输出False

转存失败，建议直接上传图片文件

二、线程同步：避免数据混乱的钥匙

多线程编程中，共享资源的访问需要同步控制，否则会导致数据不一致。例如，两个线程同时修改全局变量counter，可能因执行顺序不确定而得到错误结果。

2.1 互斥锁（Lock）

互斥锁是最基本的同步机制，确保同一时间只有一个线程能访问共享资源。例如：

counter = 0
lock = threading.Lock()

def increment():
    global counter
    for _ in range(100000):
        with lock:  # 自动获取和释放锁
            counter += 1

thread1 = threading.Thread(target=increment)
thread2 = threading.Thread(target=increment)
thread1.start()
thread2.start()
thread1.join()
thread2.join()
print(counter)  # 输出200000

转存失败，建议直接上传图片文件

with lock语句简化了锁的获取和释放操作，避免因忘记释放锁而导致的死锁。

2.2 递归锁（RLock）

递归锁允许同一线程多次获取锁，适用于嵌套锁定的场景。例如：

rlock = threading.RLock()

def recursive_func(n):
    with rlock:
        print(f"深度: {n}")
        if n > 0:
            recursive_func(n - 1)

thread = threading.Thread(target=recursive_func, args=(2,))
thread.start()
thread.join()

转存失败，建议直接上传图片文件

若使用普通锁，递归调用会导致线程阻塞。

2.3 条件变量（Condition）

条件变量用于线程间的条件等待和通知，常用于生产者-消费者模型。例如：

import threading
import time

class Queue:
    def __init__(self):
        self.items = []
        self.lock = threading.Lock()
        self.cond = threading.Condition(self.lock)
    
    def put(self, item):
        with self.cond:
            self.items.append(item)
            self.cond.notify()  # 通知消费者
    
    def get(self):
        with self.cond:
            while not self.items:
                self.cond.wait()  # 等待条件满足
            return self.items.pop(0)

def producer(q):
    for i in range(5):
        q.put(i)
        print(f"生产: {i}")
        time.sleep(0.5)

def consumer(q):
    for _ in range(5):
        item = q.get()
        print(f"消费: {item}")
        time.sleep(1)

q = Queue()
producer_thread = threading.Thread(target=producer, args=(q,))
consumer_thread = threading.Thread(target=consumer, args=(q,))
producer_thread.start()
consumer_thread.start()
producer_thread.join()
consumer_thread.join()

转存失败，建议直接上传图片文件

此例中，生产者线程在队列为空时通知消费者，消费者线程在队列为空时等待，实现高效的协作。

2.4 信号量（Semaphore）

信号量限制同时访问共享资源的线程数量。例如，控制最多3个线程同时访问数据库：

sem = threading.Semaphore(3)

def access_db(name):
    with sem:
        print(f"{name} 正在访问数据库")
        time.sleep(1)

threads = [threading.Thread(target=access_db, args=(f"线程{i}",)) for i in range(5)]
for t in threads:
    t.start()
for t in threads:
    t.join()

转存失败，建议直接上传图片文件

输出显示同时只有3个线程在访问数据库。

三、线程通信：共享内存与队列

多线程间需要通过共享内存或队列传递数据。共享内存适用于简单场景，而队列（queue.Queue）更安全且易于管理。

3.1 共享内存

通过全局变量或类属性实现线程间通信。例如：

shared_data = []

def writer():
    for i in range(3):
        shared_data.append(i)
        print(f"写入: {i}")

def reader():
    while len(shared_data) < 3:
        time.sleep(0.1)
    print(f"读取: {shared_data}")

writer_thread = threading.Thread(target=writer)
reader_thread = threading.Thread(target=reader)
writer_thread.start()
reader_thread.start()
writer_thread.join()
reader_thread.join()

转存失败，建议直接上传图片文件

此例中，writer线程写入数据，reader线程等待数据就绪后读取。

3.2 队列（Queue）

queue.Queue是线程安全的FIFO队列，适用于生产者-消费者模型。例如：

import queue

q = queue.Queue()

def producer(q):
    for i in range(3):
        q.put(i)
        print(f"生产: {i}")

def consumer(q):
    for _ in range(3):
        item = q.get()
        print(f"消费: {item}")

producer_thread = threading.Thread(target=producer, args=(q,))
consumer_thread = threading.Thread(target=consumer, args=(q,))
producer_thread.start()
consumer_thread.start()
producer_thread.join()
consumer_thread.join()

转存失败，建议直接上传图片文件

队列自动处理同步，避免手动加锁的复杂性。

四、守护线程：后台运行的隐形助手

守护线程在主线程退出时自动终止，适用于后台任务。例如，日志记录线程：

def log_messages():
    while True:
        print("记录日志...")
        time.sleep(1)

daemon_thread = threading.Thread(target=log_messages, daemon=True)
daemon_thread.start()

print("主线程执行其他任务...")
time.sleep(3)
print("主线程退出")

转存失败，建议直接上传图片文件

输出显示，主线程退出后，守护线程也随之终止。

五、线程池：高效管理线程资源

对于频繁创建和销毁线程的场景，线程池能显著提升性能。Python标准库未直接提供线程池，但可通过concurrent.futures.ThreadPoolExecutor实现。例如：

from concurrent.futures import ThreadPoolExecutor

def task(name):
    print(f"任务 {name} 执行中")
    time.sleep(1)
    return f"任务 {name} 完成"

with ThreadPoolExecutor(max_workers=3) as executor:
    futures = [executor.submit(task, i) for i in range(5)]
    for future in futures:
        print(future.result())

转存失败，建议直接上传图片文件

此例中，线程池最多同时运行3个线程，按顺序提交5个任务。

六、多线程的适用场景与限制

多线程适合I/O密集型任务（如网络请求、文件读写），因线程在等待I/O时能释放GIL（全局解释器锁），让其他线程执行。但对于CPU密集型任务（如复杂计算），多线程因GIL的存在可能无法提升性能，此时应考虑多进程（multiprocessing模块）。

6.1 性能优化建议

  1. 减少锁竞争：尽量缩小临界区范围，避免长时间持有锁。
  2. 使用局部变量：减少全局变量的访问，降低同步开销。
  3. 合理设置线程数：根据任务类型和CPU核心数调整线程数量。

七、实战案例：多线程下载器

以下是一个多线程下载器的实现，同时下载多个文件并显示进度：

import threading
import requests
import os

class Downloader:
    def __init__(self, urls, output_dir="downloads"):
        self.urls = urls
        self.output_dir = output_dir
        os.makedirs(output_dir, exist_ok=True)
    
    def download_file(self, url, index):
        try:
            response = requests.get(url, stream=True)
            filename = os.path.join(self.output_dir, f"file_{index}.bin")
            with open(filename, "wb") as f:
                for chunk in response.iter_content(1024):
                    f.write(chunk)
            print(f"下载完成: {url} -> {filename}")
        except Exception as e:
            print(f"下载失败: {url}, 错误: {e}")
    
    def run(self):
        threads = []
        for i, url in enumerate(self.urls):
            thread = threading.Thread(target=self.download_file, args=(url, i))
            threads.append(thread)
            thread.start()
        
        for thread in threads:
            thread.join()

if __name__ == "__main__":
    urls = [
        "https://example.com/file1.bin",
        "https://example.com/file2.bin",
        "https://example.com/file3.bin"
    ]
    downloader = Downloader(urls)
    downloader.run()

转存失败，建议直接上传图片文件

此例中，每个下载任务在一个独立线程中执行，主线程等待所有下载完成。

八、总结：多线程编程的核心要点

  1. 线程创建：通过Thread类或继承实现，灵活选择函数式或类式。
  2. 同步控制：使用锁、条件变量、信号量确保数据安全。
  3. 通信机制：共享内存或队列实现线程间数据传递。
  4. 守护线程：简化后台任务管理。
  5. 线程池：高效管理频繁创建的线程。
  6. 适用场景：优先用于I/O密集型任务，CPU密集型任务考虑多进程。

掌握threading模块后，可以轻松实现并发下载、实时数据处理、异步任务调度等高级功能。但需注意，多线程编程需谨慎处理同步问题，避免死锁和数据竞争。通过合理设计，多线程能显著提升程序性能和用户体验。

​

avatar
文章
阅读
粉丝