免费python编程教程：https://pan.quark.cn/s/2c17aed36b72
在Python编程中，多线程技术是提升程序效率的关键工具。当程序需要同时处理多个任务时，单线程的串行执行模式会成为性能瓶颈。例如，一个需要同时下载多个文件并实时显示进度的程序，若采用单线程设计，用户将不得不忍受漫长的等待时间。而Python的threading模块通过提供线程管理功能，让开发者能够轻松实现并发处理，显著提升程序响应速度。
一、线程基础：理解最小执行单元
线程是操作系统调度的最小单位，它被封装在进程内部，共享进程的内存空间。以浏览器为例，每个标签页可能对应一个独立线程，这些线程可以同时加载页面、执行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 线程的生命周期
线程从创建到销毁经历五个阶段：
新建：实例化Thread对象，此时线程尚未启动。
就绪：调用start()方法后，线程进入就绪队列，等待CPU调度。
运行：线程获得CPU时间片，执行run()方法中的代码。
阻塞：线程因等待资源（如I/O操作）或主动调用sleep()而暂停执行。
死亡：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 性能优化建议
减少锁竞争：尽量缩小临界区范围，避免长时间持有锁。
使用局部变量：减少全局变量的访问，降低同步开销。
合理设置线程数：根据任务类型和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()
此例中，每个下载任务在一个独立线程中执行，主线程等待所有下载完成。
八、总结：多线程编程的核心要点
线程创建：通过Thread类或继承实现，灵活选择函数式或类式。
同步控制：使用锁、条件变量、信号量确保数据安全。
通信机制：共享内存或队列实现线程间数据传递。
守护线程：简化后台任务管理。
线程池：高效管理频繁创建的线程。
适用场景：优先用于I/O密集型任务，CPU密集型任务考虑多进程。
掌握threading模块后，可以轻松实现并发下载、实时数据处理、异步任务调度等高级功能。但需注意，多线程编程需谨慎处理同步问题，避免死锁和数据竞争。通过合理设计，多线程能显著提升程序性能和用户体验。
