并发编程 #
一、多线程 #
python
import threading
def task(name):
print(f"任务 {name} 开始")
# 执行任务
print(f"任务 {name} 结束")
# 创建线程
t1 = threading.Thread(target=task, args=("A",))
t2 = threading.Thread(target=task, args=("B",))
# 启动线程
t1.start()
t2.start()
# 等待线程完成
t1.join()
t2.join()
二、线程锁 #
python
import threading
counter = 0
lock = threading.Lock()
def increment():
global counter
for _ in range(100000):
with lock: # 加锁
counter += 1
threads = [threading.Thread(target=increment) for _ in range(10)]
for t in threads:
t.start()
for t in threads:
t.join()
print(counter) # 1000000
三、线程池 #
python
from concurrent.futures import ThreadPoolExecutor
def task(n):
return n ** 2
with ThreadPoolExecutor(max_workers=5) as executor:
# 提交任务
futures = [executor.submit(task, i) for i in range(10)]
# 获取结果
for future in futures:
print(future.result())
# 或使用map
results = list(executor.map(task, range(10)))
四、多进程 #
python
import multiprocessing
def task(name):
print(f"进程 {name}")
if __name__ == '__main__':
processes = [
multiprocessing.Process(target=task, args=(i,))
for i in range(4)
]
for p in processes:
p.start()
for p in processes:
p.join()
五、进程池 #
python
from concurrent.futures import ProcessPoolExecutor
def task(n):
return n ** 2
if __name__ == '__main__':
with ProcessPoolExecutor(max_workers=4) as executor:
results = list(executor.map(task, range(10)))
print(results)
六、进程间通信 #
python
import multiprocessing
def worker(queue):
queue.put("来自子进程的消息")
if __name__ == '__main__':
queue = multiprocessing.Queue()
p = multiprocessing.Process(target=worker, args=(queue,))
p.start()
print(queue.get()) # "来自子进程的消息"
p.join()
七、共享内存 #
python
import multiprocessing
def worker(counter):
with counter.get_lock():
counter.value += 1
if __name__ == '__main__':
counter = multiprocessing.Value('i', 0)
processes = [
multiprocessing.Process(target=worker, args=(counter,))
for _ in range(10)
]
for p in processes:
p.start()
for p in processes:
p.join()
print(counter.value) # 10
八、总结 #
| 方式 | 适用场景 | 特点 |
|---|---|---|
| 多线程 | IO密集型 | 共享内存,受GIL限制 |
| 多进程 | CPU密集型 | 独立内存,无GIL限制 |
| 协程 | IO密集型 | 轻量级,高并发 |
GIL(全局解释器锁):
- 同一时刻只有一个线程执行Python字节码
- 多线程不适合CPU密集型任务
- 多进程可以绑过GIL限制
最后更新:2026-03-16