一、为什么需要多进程？

当你的Python程序遇到性能瓶颈时，经常会听到这样的建议："用多进程替代多线程"。这背后的根本原因在于Python的GIL（全局解释器锁）机制——它使得多线程无法真正实现并行计算。而多进程则通过创建独立的内存空间，每个进程拥有自己的Python解释器，完美规避了GIL的限制。

笔者在数据分析项目中首次体验多进程的威力：一个原本需要4小时运行的pandas处理任务，通过8进程并行处理后，耗时直接降至35分钟！

二、multiprocessing核心用法

1. 基础进程创建

python
from multiprocessing import Process
import os

def task(name):
print(f"子进程 {name} (PID: {os.getpid()}) 执行中")

if name == 'main':
processes = []
for i in range(3):
p = Process(target=task, args=(f'worker-{i}',))
processes.append(p)
p.start()

for p in processes:
    p.join()

关键点：
- 必须使用 if __name__ == '__main__': 保护主模块
- start() 启动进程，join() 等待完成
- 每个进程有独立的PID和内存空间

2. 进程池优化（Pool）

当需要处理大量任务时，直接创建数百个进程会导致系统崩溃。这时应该使用进程池：

python
from multiprocessing import Pool

def process_data(chunk):
# 模拟数据处理
return sum(x*x for x in chunk)

if name == 'main':
data = [range(i1000, (i+1)1000) for i in range(10)]

with Pool(processes=4) as pool:  # 推荐使用上下文管理器
    results = pool.map(process_data, data)

print(f"处理结果: {results}")

最佳实践：
- 池大小建议设为CPU核心数的1-2倍
- map方法保持输入顺序，imap适合流式处理
- 使用with语句确保资源正确释放

三、高级优化技巧

1. 共享内存通信

进程间通信是性能关键点，通过共享内存可以避免序列化开销：

python
from multiprocessing import Value, Array

def worker(n, arr):
n.value += 1
arr[0] += 10

if name == 'main':
num = Value('i', 0) # 'i'表示整型
arr = Array('d', [0.0, 1.0, 2.0]) # 'd'表示双精度浮点

processes = [Process(target=worker, args=(num, arr)) for _ in range(3)]

for p in processes:
    p.start()
for p in processes:
    p.join()

print(f"最终值: {num.value}, 数组: {arr[:]}")

2. 进程安全的队列

python
from multiprocessing import Queue

def producer(q):
for i in range(5):
q.put(f"消息-{i}")

def consumer(q):
while True:
item = q.get()
if item is None: # 终止信号
break
print(f"消费: {item}")

if name == 'main':
q = Queue()
procs = [
Process(target=producer, args=(q,)),
Process(target=consumer, args=(q,))
]

for p in procs:
    p.start()

q.put(None)  # 发送结束信号
for p in procs:
    p.join()

四、实战性能对比

我们通过图像处理任务对比不同方法的效率（测试环境：8核CPU）：

| 方法 | 耗时(s) | CPU利用率 |
|---------------|--------|----------|
| 单进程 | 48.2 | 12% |
| 多线程(8线程) | 46.5 | 30% |
| 多进程(8进程) | 8.7 | 98% |

典型应用场景推荐：
- CPU密集型：科学计算、图像处理 → 多进程
- IO密集型：网络请求、文件操作 → 多线程/异步
- 混合型：先多进程分解任务，再线程处理IO

五、避坑指南

1. 僵尸进程预防：确保所有子进程都被join()或terminate()
2. 内存爆炸：大数据传输考虑使用共享内存或数据库
3. 日志混乱：使用logging模块的QueueHandler实现多进程日志
4. Windows特殊处理：避免使用fork()启动方式

python

多进程日志示例

import logging
from multiprocessing import Queue, Process
from logging.handlers import QueueHandler, QueueListener

def setup_logger(q):
handler = QueueHandler(q)
logger = logging.getLogger()
logger.addHandler(handler)
logger.setLevel(logging.INFO)

def worker():
logging.info("子进程日志消息")

if name == 'main':
logqueue = Queue() handler = logging.StreamHandler() listener = QueueListener(logqueue, handler)
listener.start()

setup_logger(log_queue)
p = Process(target=worker)
p.start()
p.join()

listener.stop()