在CPU密集型任务中，Python的GIL（全局解释器锁）常常成为性能瓶颈。当我第一次遇到需要处理大规模数据运算的项目时，单进程运行需要近8小时。通过multiprocessing模块改造后，同样的任务在4核机器上仅用2小时就完成——这正是多进程的魅力所在。

一、多进程基础原理

与多线程不同，多进程会创建真正的系统级进程，每个进程都有独立的内存空间。这意味着：

1. 彻底避开GIL限制
2. 充分利用多核CPU
3. 进程崩溃不会影响主程序
4. 内存消耗相对较大

python
import multiprocessing
import os

def worker():
print(f'子进程ID: {os.getpid()}')

if name == 'main':
print(f'主进程ID: {os.getpid()}')
p = multiprocessing.Process(target=worker)
p.start()
p.join()

二、5种核心使用方法

1. Process类基础用法

python
def calculate_square(nums):
for n in nums:
print(f'{n}的平方是{n**2}')

if name == 'main':
numbers = [1, 2, 3, 4]
p = multiprocessing.Process(
target=calculate_square,
args=(numbers,)
)
p.start()
p.join()

2. 进程池（Pool）高效管理

python
def process_data(data):
return data * 2

if name == 'main':
with multiprocessing.Pool(processes=4) as pool:
results = pool.map(process_data, range(10))
print(results) # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

3. 进程间通信方案

python

使用Queue

def producer(q):
q.put('重要数据')

def consumer(q):
print(f'收到: {q.get()}')

if name == 'main':
queue = multiprocessing.Queue()
p1 = multiprocessing.Process(target=producer, args=(queue,))
p2 = multiprocessing.Process(target=consumer, args=(queue,))
p1.start()
p2.start()

4. 共享内存（Value/Array）

python
def modify_shared(n, arr):
n.value = 3.1415926
for i in range(len(arr)):
arr[i] *= 2

if name == 'main':
num = multiprocessing.Value('d', 0.0)
arr = multiprocessing.Array('i', range(5))

p = multiprocessing.Process(target=modify_shared, args=(num, arr))
p.start()
p.join()

print(num.value)  # 3.1415926
print(arr[:])     # [0, 2, 4, 6, 8]

5. 进程锁（Lock）同步控制

python
def withdraw(balance, lock):
with lock:
balance.value -= 1

if name == 'main':
balance = multiprocessing.Value('i', 100)
lock = multiprocessing.Lock()

processes = []
for _ in range(10):
    p = multiprocessing.Process(target=withdraw, 
                              args=(balance, lock))
    processes.append(p)
    p.start()

for p in processes:
    p.join()

print(f'最终余额: {balance.value}')  # 90

三、性能优化实战建议

1. 进程数量黄金法则：建议设置为CPU核心数+1
python optimal_processes = multiprocessing.cpu_count() + 1

2. 避免大数据传递：使用Manager代理共享数据
   python manager = multiprocessing.Manager() shared_list = manager.list()

3. 异常处理机制：
   python def safe_worker(): try: # 业务代码 except Exception as e: print(f'进程异常: {e}')

4. 内存监控技巧：
   python import psutil def memory_usage(): return psutil.Process().memory_info().rss / 1024 / 1024

四、常见问题解决方案

问题1：子进程不输出打印内容？
- 解决方案：使用sys.stdout.flush()或配置logging模块

问题2：Windows平台报错？
- 必须将代码放在if __name__ == '__main__':中

问题3：僵尸进程堆积？
- 使用daemon属性或实现信号处理

python p = multiprocessing.Process(daemon=True)

五、真实项目案例

某电商平台的用户行为分析系统改造前：
- 单进程处理1000万条日志需要45分钟
- 内存占用峰值8GB

使用多进程优化后：python
def process_chunk(chunk):
# 分析逻辑
return results

if name == 'main':
chunks = splitdata('userlogs.csv', 8)
with multiprocessing.Pool() as pool:
allresults = pool.map(processchunk, chunks)
- 处理时间降至12分钟
- 内存占用稳定在3GB以内

多进程编程就像组建施工队——与其让单个工人（线程）疲于奔命，不如组建专业团队（进程）协同作业。掌握multiprocessing模块后，你会惊讶地发现：原来Python也能如此高效地榨干CPU性能！