进程是操作系统进行资源分配和调度的基本单位每个进程都有独立的内存空间、文件描述符和执行状态。Python 通过multiprocessing模块支持多进程编程用于充分利用多核 CPU。一、进程 vs 线程特性进程线程内存空间独立互不干扰共享进程的内存数据隔离天然隔离需要 IPC共享数据需要加锁创建开销大复制内存小切换开销大切换页表小GIL 影响无影响真正并行受 GIL 限制适用场景CPU 密集型I/O 密集型# 进程的独立内存空间 from multiprocessing import Process data [] # 全局列表 def worker(): data.append(1) # 每个进程有自己的 copy print(f进程 {id(data)}: {data}) p1 Process(targetworker) p2 Process(targetworker) p1.start() p2.start() p1.join() p2.join() # 输出不同进程的 data 互不影响二、创建进程1. 使用Process类from multiprocessing import Process import os def worker(name, num): print(f进程 {name}: PID{os.getpid()}, 父进程{os.getppid()}) return num * 2 # 方式1直接传入函数 p Process(targetworker, args(worker1, 100)) p.start() # 启动进程 p.join() # 等待进程结束 # 方式2自定义进程类 class MyProcess(Process): def __init__(self, name): super().__init__() self.name name def run(self): print(f运行进程: {self.name}) p MyProcess(my_worker) p.start() p.join()2. 进程启动方式import multiprocessing as mp # 设置启动方式必须在 if __name__ __main__ 内 if __name__ __main__: mp.set_start_method(spawn) # Windows 默认 # mp.set_start_method(fork) # Linux/macOS 默认 # 三种方式对比 # | spawn | 全新启动不继承父进程资源 | Windows、macOS | # | fork | 复制父进程不安全 | Linux | # | forkserver | 通过服务进程 fork安全 | Unix-like |三、进程池Poolfrom multiprocessing import Pool import time def cpu_intensive(n): CPU 密集型任务 return sum(i * i for i in range(n)) if __name__ __main__: with Pool(processes4) as pool: # map阻塞保持顺序 results pool.map(cpu_intensive, [10**7] * 4) print(results) # map_async异步非阻塞 result pool.map_async(cpu_intensive, [10**7] * 4) print(异步提交完成) results result.get() # 等待结果 # apply_async单任务异步 async_result pool.apply_async(cpu_intensive, (10**7,)) result async_result.get(timeout30)四、进程间通信IPC1. Queue队列from multiprocessing import Process, Queue def producer(q): for i in range(5): q.put(f消息{i}) print(f生产: {i}) q.put(None) # 结束标志 def consumer(q): while True: msg q.get() if msg is None: break print(f消费: {msg}) if __name__ __main__: q Queue() p1 Process(targetproducer, args(q,)) p2 Process(targetconsumer, args(q,)) p1.start() p2.start() p1.join() p2.join()2. Pipe管道from multiprocessing import Process, Pipe def worker(conn): conn.send([1, 2, 3]) print(f收到父进程消息: {conn.recv()}) conn.close() if __name__ __main__: parent_conn, child_conn Pipe() p Process(targetworker, args(child_conn,)) p.start() print(f收到子进程数据: {parent_conn.recv()}) parent_conn.send(来自父进程) p.join()3. Shared Memory共享内存from multiprocessing import Process, Value, Array def worker(val, arr): val.value 1 for i in range(len(arr)): arr[i] i if __name__ __main__: num Value(i, 0) # i 表示有符号整数 arr Array(d, [0.0, 1.0, 2.0]) # d 表示 double processes [Process(targetworker, args(num, arr)) for _ in range(4)] for p in processes: p.start() for p in processes: p.join() print(fnum: {num.value}) print(farr: {arr[:]})4. Manager管理器from multiprocessing import Process, Manager def worker(d, l, key, value): d[key] value l.append(value) if __name__ __main__: with Manager() as manager: d manager.dict() l manager.list() processes [Process(targetworker, args(d, l, fkey{i}, i)) for i in range(5)] for p in processes: p.start() for p in processes: p.join() print(fdict: {d}) print(flist: {l})五、进程同步锁from multiprocessing import Process, Lock, Value def worker(lock, counter): for _ in range(1000): with lock: counter.value 1 if __name__ __main__: counter Value(i, 0) lock Lock() processes [Process(targetworker, args(lock, counter)) for _ in range(10)] for p in processes: p.start() for p in processes: p.join() print(f最终值: {counter.value}) # 应该是 10000六、进程 vs 线程 性能对比from multiprocessing import Process from threading import Thread import time def cpu_task(): for i in range(10**7): pass def io_task(): time.sleep(0.1) if __name__ __main__: import time # CPU 密集型多进程更快利用多核 start time.time() processes [Process(targetcpu_task) for _ in range(4)] for p in processes: p.start() for p in processes: p.join() print(f多进程CPU任务: {time.time() - start:.2f}s) # I/O 密集型多线程更快切换开销小 start time.time() threads [Thread(targetio_task) for _ in range(40)] for t in threads: t.start() for t in threads: t.join() print(f多线程I/O任务: {time.time() - start:.2f}s)结果4核CPU多进程CPU任务: 1.8s # 并行利用多核 多线程CPU任务: 6.5s # 受 GIL 限制 多进程I/O任务: 0.45s # 进程开销大 多线程I/O任务: 0.12s # 线程开销小