Python线程与多线程完全总结（从入门到理解并发本质）

一篇把 Thread / Lock / Semaphore / Event / Queue / ThreadPoolExecutor 串成完整认知链的多线程学习总结

一、什么是线程？

线程（Thread）可以理解为：

text 复制代码

程序内部的执行单元（执行分身）

在操作系统层面：

text 复制代码

进程 = 工厂
线程 = 工人

一个进程可以包含多个线程，它们具有：

共享同一块内存
并发执行任务
由操作系统调度执行顺序

最基础线程示例

python 复制代码

import threading
import time

def task(name):
    print(name, "开始执行")
    time.sleep(2)
    print(name, "执行结束")

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

t1.start()
t2.start()

t1.join()
t2.join()

print("全部线程执行完毕")

二、为什么需要多线程？

单线程模型

text 复制代码

一个任务一个任务执行 → 效率低

多线程模型

text 复制代码

多个任务同时执行（并发）→ 提升效率

适用场景：

网络请求（爬虫）
IO密集型任务
文件读写
API调用
等待型操作

三、线程安全问题（核心问题）

示例：共享变量错误

python 复制代码

import threading

money = 100

def add():
    global money
    for _ in range(100000):
        money += 1

为什么会出错？

text 复制代码

money += 1 不是原子操作

它实际分三步：

text 复制代码

1. 读取 money
2. +1
3. 写回 money

多个线程交叉执行 → 线程会"抢写"，导致数据错乱

即使数学结果正确，也不代表数据安全

四、Lock（线程锁）

作用

text 复制代码

保证同一时刻只有一个线程执行代码

🧪 示例

python 复制代码

import threading

money = 100
lock = threading.Lock()

def add():
    global money
    for _ in range(100000):
        with lock:
            money += 1

理解

text 复制代码

Lock = 单人厕所
谁进去谁占用

五、Semaphore（信号量）

作用

text 复制代码

限制同时运行的线程数量

示例

python 复制代码

import threading
import time

sem = threading.Semaphore(3)

def task(i):
    with sem:
        print(i, "进入执行")
        time.sleep(2)
        print(i, "执行结束")

for i in range(10):
    threading.Thread(target=task, args=(i,)).start()

理解

text 复制代码

Semaphore(3) = 三个坑位的厕所
最多允许3个线程同时运行

六、Event（事件控制）

作用

text 复制代码

控制多个线程统一开始执行

示例

python 复制代码

import threading
import time

event = threading.Event()

def runner(name):
    print(name, "准备完成")
    event.wait()
    print(name, "开始执行")

threading.Thread(target=runner, args=("A",)).start()
threading.Thread(target=runner, args=("B",)).start()

time.sleep(2)

print("发令信号")
event.set()

理解

text 复制代码

Event = 发令枪 / 红绿灯

七、Queue（线程通信核心）

作用

text 复制代码

线程安全的数据传递通道

生产者消费者模型

python 复制代码

import threading
import queue

def producer(q):
    for i in range(5):
        q.put(i)
    q.put(None)

def consumer(q):
    while True:
        item = q.get()
        if item is None:
            break
        print("消费:", item)
        q.task_done()

q = queue.Queue()

t1 = threading.Thread(target=producer, args=(q,))
t2 = threading.Thread(target=consumer, args=(q,))

t1.start()
t2.start()

q.join()

t1.join()
t2.join()

Queue机制

text 复制代码

put()        → 任务 +1
get()        → 获取任务
task_done()  → 完成 -1
join()       → 等待所有任务完成

理解

text 复制代码

Queue = 传送带
线程 = 工人

八、线程池 ThreadPoolExecutor（核心）

作用

text 复制代码

自动管理线程的高级工具（推荐使用）

map模式

python 复制代码

from concurrent.futures import ThreadPoolExecutor

def task(x):
    return x * x

with ThreadPoolExecutor(max_workers=3) as pool:
    results = pool.map(task, [1, 2, 3, 4])

    for r in results:
        print(r)

map特点

text 复制代码

map = 按顺序返回结果

九、submit + Future + as_completed

示例

python 复制代码

from concurrent.futures import ThreadPoolExecutor, as_completed
import time

def task(x):
    time.sleep(x)
    return x

with ThreadPoolExecutor(max_workers=3) as pool:
    futures = [
        pool.submit(task, 3),
        pool.submit(task, 1),
        pool.submit(task, 2)
    ]

    for f in as_completed(futures):
        print(f.result())

as_completed

text 复制代码

谁先完成，谁先返回

三者对比

方法	特点
map	顺序输出
submit	返回Future对象
as_completed	完成顺序输出

十、线程池核心模型

text 复制代码

任务提交 → 线程池调度 → 并发执行 → 结果收集

三种模式本质

text 复制代码

map           → 自动提交 + 顺序收集
submit        → 手动提交 + Future控制
as_completed  → 完成事件驱动

十一、线程工具全景图

text 复制代码

Thread
 ├── Lock        → 防止冲突
 ├── Semaphore   → 控制并发数量
 ├── Event       → 控制执行时机
 ├── Queue       → 线程通信
 └── ThreadPool  → 自动线程管理

十二、核心总结

text 复制代码

线程 = 执行单元
锁 = 防冲突
信号量 = 并发控制
事件 = 执行时机控制
队列 = 数据传输
线程池 = 自动调度系统

复制代码