以下是我对Python多进程并发编程的理解，内容涵vb.net教程C#教程python教程SQL教程access 2010教程盖核心概念、使用场景、实现方式及代码示例：

一、多进程 vs 多线程

1. 核心区别：

   • 进程拥有独立内存空间，线程共享同一进程内存
   • Python的GIL（全局解释器锁）限制多线程的CPU密集型并行
   • 多进程适合CPU密集型任务，多线程适合I/O密集型任务

2. 选择策略：

   • CPU密集型：多进程（如数值计算、图像处理）
   • I/O密集型：多线程/协程（如网络请求、文件读写）

二、multiprocessing 核心组件

1. Process 类

from multiprocessing import Process
import os

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

if __name__ == '__main__':
    p = Process(target=worker, args=('process1',))
    p.start()
    p.join()
    print("主进程结束")

2. 进程池 Pool

from multiprocessing import Pool

def square(x):
    return x * x

if __name__ == '__main__':
    with Pool(4) as pool:  # 创建4个进程的池
        # map方法
        results = pool.map(square, range(10))
        
        # apply_async异步方法
        async_result = pool.apply_async(square, (5,))
        print(async_result.get())  # 获取结果

三、进程间通信（IPC）

1. Queue 队列

from multiprocessing import Process, Queue

def producer(q):
    q.put('Hello from child')

def consumer(q):
    print('Received:', q.get())

if __name__ == '__main__':
    q = Queue()
    p1 = Process(target=producer, args=(q,))
    p2 = Process(target=consumer, args=(q,))
    p1.start()
    p2.start()
    p1.join()
    p2.join()

2. Pipe 管道

from multiprocessing import Process, Pipe

def child(conn):
    conn.send('Message from child')
    conn.close()

if __name__ == '__main__':
    parent_conn, child_conn = Pipe()
    p = Process(target=child, args=(child_conn,))
    p.start()
    print(parent_conn.recv())  # 输出接收的消息
    p.join()

3. 共享内存

from multiprocessing import Process, Value, Array

def modify(n, arr):
    n.value = 3.1415927
    for i in range(len(arr)):
        arr[i] = -arr[i]

if __name__ == '__main__':
    num = Value('d', 0.0)        # 双精度浮点数
    arr = Array('i', range(10))  # 整数数组
    
    p = Process(target=modify, args=(num, arr))
    p.start()
    p.join()
    
    print(num.value)  # 3.1415927
    print(arr[:])     # [0, -1, -2,...-9]

四、进程同步

1. Lock 锁

from multiprocessing import Process, Lock

def printer(lock, item):
    with lock:
        print(f'Process {item} acquired lock')

if __name__ == '__main__':
    lock = Lock()
    items = ['A', 'B', 'C']
    processes = []
    
    for item in items:
        p = Process(target=printer, args=(lock, item))
        processes.append(p)
        p.start()
    
    for p in processes:
        p.join()

2. Event 事件

from multiprocessing import Process, Event
import time

def waiter(event):
    print("等待事件触发...")
    event.wait()
    print("事件已触发!")

if __name__ == '__main__':
    event = Event()
    p = Process(target=waiter, args=(event,))
    p.start()
    
    time.sleep(2)
    event.set()  # 触发事件
    p.join()

五、高级特性

1. Manager 管理器

from multiprocessing import Process, Manager

def worker(d, l):
    d[os.getpid()] = os.getpid()
    l.append(os.getpid())

if __name__ == '__main__':
    with Manager() as manager:
        d = manager.dict()
        l = manager.list()
        
        processes = []
        for _ in range(4):
            p = Process(target=worker, args=(d, l))
            processes.append(p)
            p.start()
        
        for p in processes:
            p.join()
        
        print("Dict:", d)
        print("List:", l)

2. 跨平台启动方式

# Windows必须使用以下保护代码
if __name__ == '__main__':
    # 主进程代码

六、性能优化建议

1. 控制进程数量（通常等于CPU核心数）
2. 避免频繁创建/销毁进程（使用进程池）
3. 减少进程间通信次数和数据量
4. 使用fork（Linux）或spawn（Windows）启动方法

   from multiprocessing import set_start_method
   set_start_method('spawn')  # 在程序开始处设置
   

七、典型应用场景

1. 大规模数据并行处理
2. CPU密集型科学计算
3. 分布式任务处理
4. 并行图像/视频处理
5. 多任务隔离执行（每个进程独立运行）

通过合理使用多进程，可以显著提升Python程序的执行效率，特别是在多核CPU环境下。注意平衡任务分配和通信开销，才能达到最佳性能。

原创文章，转载请注明出处：https://www.xin3721.com/