点击头像，进入个人中心，查看文章合集，还有更多Python相关的精彩教程等着你！

7.1 引言

在现代编程中，并发 (Concurrency) 和 并行 (Parallelism) 是提升性能的重大手段。

• 并发：同时处理多个任务（不必定同时执行，可以交替进行）。

• 并行：真正意义上的同时执行（依赖多核 CPU）。

Python 提供了多种并发工具：

• threading —— 多线程编程

• multiprocessing —— 多进程编程

• concurrent.futures —— 高层接口，简化并发任务提交

本章主要介绍 多线程，下一章将学习 异步编程 (asyncio)。

7.2 线程基础

7.2.1 创建线程

使用 threading.Thread 创建线程。

示例：

import threadingimport timedef worker(name):
    print(f"线程 {name} 开始")
    time.sleep(2)
    print(f"线程 {name} 结束")

t1 = threading.Thread(target=worker, args=("A",))
t2 = threading.Thread(target=worker, args=("B",))

t1.start()
t2.start()

t1.join()
t2.join()
print("主线程结束")

✅ 输出结果（线程交替执行）：

线程 A 开始
线程 B 开始
线程 A 结束
线程 B 结束
主线程结束

7.3 守护线程 (Daemon Thread)

• 普通线程：必须运行结束，主程序才会退出

• 守护线程：随着主线程退出而强制结束

示例：

def background_task():    while True:
        print("后台运行中...")
        time.sleep(1)

t = threading.Thread(target=background_task, daemon=True)
t.start()

time.sleep(3)
print("主线程结束，守护线程会被杀死")

✅ 输出结果（只运行几次后台任务后退出）：

后台运行中...
后台运行中...
后台运行中...
主线程结束，守护线程会被杀死

7.4 线程同步

7.4.1 问题：竞态条件 (Race Condition)

多个线程同时修改同一变量，可能导致结果错误。

示例（错误情况）：

balance = 0def deposit():    global balance    for _ in range(100000):        balance += 1t1 = threading.Thread(target=deposit)t2 = threading.Thread(target=deposit)t1.start(); t2.start()t1.join(); t2.join()print("最终余额:", balance)

✅ 结果可能小于 200000，由于多个线程同时写入，数据丢失。

7.4.2 使用 Lock 解决竞态问题

threading.Lock 可以确保同一时间只有一个线程修改共享资源。

示例：

balance = 0lock = threading.Lock()def deposit():    global balance    for _ in range(100000):        with lock:            balance += 1t1 = threading.Thread(target=deposit)t2 = threading.Thread(target=deposit)t1.start(); t2.start()t1.join(); t2.join()print("最终余额:", balance)

✅ 输出结果：

最终余额: 200000

7.5 线程池

使用
concurrent.futures.ThreadPoolExecutor 可以更方便地管理线程。

示例：

from concurrent.futures import ThreadPoolExecutorimport timedef task(n):
    time.sleep(1)    return n * nwith ThreadPoolExecutor(max_workers=3) as executor:
    results = list(executor.map(task, [1, 2, 3, 4, 5]))

print("结果:", results)

✅ 输出结果（3 个线程并发执行，整体运行更快）：

结果: [1, 4, 9, 16, 25]

7.6 全局解释器锁 (GIL)

• Python 的 GIL（Global Interpreter Lock，全局解释器锁） 限制了多线程不能真正并行执行 Python 字节码。

• 适合 I/O 密集型任务（网络请求、文件读写）。

• 对于 CPU 密集型任务，推荐使用 多进程 (multiprocessing)。

7.7 小结

• threading.Thread 创建线程

• 守护线程 → 主线程结束时自动退出

• 锁 (Lock) → 避免竞态条件

• 线程池 → 使用 ThreadPoolExecutor 简化管理

• GIL 限制 → 多线程适合 I/O 密集型任务，不适合 CPU 密集型

下一章我们将学习 异步编程 (asyncio)，它是 Python 提供的另一种高效并发模型，特别适合网络编程。