python进程间通信共享内存

Python中如何使用多进程？multiprocessing模块详解

在Python的世界里，想要实现多进程，multiprocessing模块的Process类可是咱们的得力助手。
它能够帮助我们创建独立的进程，每个进程都拥有自己的解释器和内存空间，这样就可以绕过GIL的限制，实现真正的并行计算啦。
接下来，我就来详细给你介绍一下如何用这个模块来创建进程、进行进程间通信，以及如何管理大量任务。

首先，咱们得学会怎么创建和启动基础进程。
这就像在厨房里准备食材，先得有原料对吧？所以，你首先需要定义一个目标函数，也就是进程要执行的具体任务。
然后，用Process类创建一个进程对象，给它指定一个目标函数和需要传递的参数。
启动进程就像按下煮饭的开关，调用start()方法，进程就开始运行了。
等任务完成，再用join()方法等待进程结束。
记得哦，Windows系统下要用if __name__ == '__main__'来避免无限递归的问题。

说到多进程，咱们得和它的小伙伴多线程比一比。
多线程呢，虽然能共享同一进程的内存空间，但主要适合处理I/O密集型任务，比如网络请求或者文件读写。
但是，由于GIL的存在，它无法真正并行执行CPU密集型任务。
相比之下，多进程每个进程都有独立的内存空间，适合处理CPU密集型任务，比如数学运算或者数据处理，而且不受GIL的限制，可以更好地利用多核CPU。

进程间通信，也就是IPC，因为进程间不共享内存，所以我们需要一些特殊的机制来实现通信。
比如，队列（Queue）就支持生产者-消费者模式，线程/进程安全；管道（Pipe）则更轻量级，但仅适用于两个进程间的通信；共享内存（SharedMemory）可以直接共享数值或数组，但需要手动同步。

当你需要管理大量任务时，进程池（Pool）就派上用场了。
它自动管理进程的生命周期，简化了任务分发和结果收集的工作。
你可以限制进程池的最大进程数，通过map或者apply_async方法分配任务，而且它会自动汇总结果，不需要你手动同步。

最后，根据不同的任务类型，选择合适的工具。
CPU密集型任务用多进程，I/O密集型任务用多线程。
关键模块有Process、Queue/Pipe/SharedMemory，还有Pool。
合理利用这些工具，可以大大提升Python程序的并行性能。

Python基础知识点：多进程的应用讲解

Python的multiprocessing模块确实是处理多进程任务的利器，它通过创建独立的进程来绕过GIL的限制，这样就能更好地利用多核CPU资源。
下面就来详细聊聊多进程的应用。

一、多进程的优缺点
优点
独立内存空间：每个进程都有自己的内存空间，这样就不会因为共享变量而出现竞争问题。

多核利用：可以直接使用多个CPU核心，特别适合处理CPU密集型任务，比如矩阵运算、加密等。

稳定性：子进程崩溃不会影响主进程，这点跟线程不同。

接口友好：跟threading.Thread的接口类似，学习起来比较容易。

缺点
通信复杂：进程之间的通信需要通过队列（Queue）、管道（Pipe）或共享内存（Value/Array）来实现，比线程之间的通信要复杂一些。

内存占用高：每个进程都需要独立分配内存，所以资源消耗比较大。

二、创建多进程
1 . 直接使用Process类 通过multiprocessing.Process创建进程，需要指定目标函数和参数。
比如：
python import multiprocessing import time
def worker(name): print(f"Start {name}") time.sleep(2 ) print(f"End {name}")
if __name__ == '__main__': processes = [] for i in range(3 ): p = multiprocessing.Process(target=worker, args=(f"Process-{i}",)) processes.append(p) p.start() for p in processes: p.join()
关键点：
if __name__ == '__main__':：这是为了避免在Windows或macOS下无限递归创建进程。

start()：启动进程。

join()：阻塞主进程直到子进程完成。

2 . 子类化Process 通过继承Process并重写run()方法，可以实现更灵活的控制：
python class WorkerProcess(multiprocessing.Process): def __init__(self, name): super().__init__() self.name = name
def run(self): print(f"Start {self.name}") time.sleep(2 ) print(f"End {self.name}")
if __name__ == '__main__': processes = [WorkerProcess(f"SubProcess-{i}") for i in range(3 )] for p in processes: p.start() for p in processes: p.join()
三、进程池（Pool）
进程池适用于需要限制并发进程数的场景，比如避免系统资源耗尽。
使用方式如下：
python from multiprocessing import Pool
def worker(name): print(f"Start {name}") time.sleep(2 ) print(f"End {name}")
if __name__ == '__main__': with Pool(processes=2 ) as pool: 最大2 个并发进程 names = [f"PoolProcess-{i}" for i in range(5 )] pool.map(worker, names) 自动分配任务
关键点：
Pool(processes=N)：指定最大并发数。

map()：将任务分发给进程池，自动管理进程生命周期。

使用with语句或手动调用pool.close()和pool.join()确保资源释放。

四、进程间通信
1 . 队列（Queue） python from multiprocessing import Queue
def producer(q): q.put("Data from producer")
def consumer(q): print(q.get()) 输出: "Data from producer"
if __name__ == '__main__': q = Queue() p1 = multiprocessing.Process(target=producer, args=(q,)) p2 = multiprocessing.Process(target=consumer, args=(q,)) p1 .start() p2 .start() p1 .join() p2 .join()
2 . 管道（Pipe） python from multiprocessing import Pipe
def child(conn): conn.send("Hello from child") conn.close()
if __name__ == '__main__': parent_conn, child_conn = Pipe() p = multiprocessing.Process(target=child, args=(child_conn,)) p.start() print(parent_conn.recv()) 输出: "Hello from child" p.join()
3 . 共享内存（Value/Array） python from multiprocessing import Value, Array
def modify_data(num, arr): num.value += 1 for i in range(len(arr)): arr[i] = 2
if __name__ == '__main__': num = Value('i', 1 0) 'i'表示整数类型 arr = Array('d', [1 .0, 2 .0, 3 .0]) 'd'表示双精度浮点 p = multiprocessing.Process(target=modify_data, args=(num, arr)) p.start() p.join() print(num.value, list(arr)) 输出: 1 1 [2 .0, 4 .0, 6 .0]
五、注意事项

跨平台兼容性：在Windows或macOS上，需要将进程代码放在if __name__ == '__main__':中，以避免重复导入。

资源释放：使用进程池后，务必调用terminate()或close()+join()来释放资源。

调试困难：多进程中的错误不会直接抛出到主进程，建议通过日志记录异常。

六、总结

适用场景：CPU密集型任务、需要隔离内存的操作。

避免场景：I/O密集型任务（线程或异步更高效）、频繁进程间通信。

扩展学习：可以参考官方文档了解Manager、Lock等高级功能。

通过合理使用多进程，可以显著提升Python程序的并行计算能力，尤其是在多核环境下效果更明显。

Python中如何使用多进程？multiprocessing优化技巧

在Python里搞多进程并行处理啊，用multiprocessing模块就挺方便的，特别是那种计算量大的活儿。
下面我就给你唠唠具体怎么用，还有一些建议：
1 . 基本用法：Process和Pool

Process：适合跑那些不搭界、独立干活的进程。
比如： python from multiprocessing import Process, os
def worker(): print(f"当前进程ID:{os.getpid()}")
p = Process(target=worker) p.start() 开启进程 p.join() 等它跑完

Pool：适合批量处理任务，它会自动分派工作给进程（默认按CPU核心数来）。
举个栗子： python from multiprocessing import Pool
def square(x): return x x
with Pool(4 ) as pool: 手动指定4 个进程 result = pool.map(square, [1 , 2 , 3 , 4 ]) print(result) 输出: [1 , 4 , 9 , 1 6 ] 小提示：Pool默认会根据cpu_count()来分配进程数，你也可以手动指定。

2 . 数据共享与通信
多进程默认是不共享内存的，要想互通消息，得用以下几种方法：

Queue：就是个跨进程的队列，先进先出。
比如： python from multiprocessing import Process, Queue
def worker(q): q.put("来自子进程的消息")
q = Queue() p = Process(target=worker, args=(q,)) p.start() print(q.get()) 输出: 来自子进程的消息 p.join()

Pipe：适合两个进程之间的双向通信。
比如： python from multiprocessing import Process, Pipe
def worker(conn): conn.send("消息") conn.close()
parent_conn, child_conn = Pipe() p = Process(target=worker, args=(child_conn,)) p.start() print(parent_conn.recv()) 输出: 消息 p.join()

Value/Array：可以共享内存变量，但得配个锁（Lock）防竞争。
比如： python from multiprocessing import Process, Value
def worker(n): n.value += 1
num = Value('i', 0) 'i'表示整数类型 p = Process(target=worker, args=(num,)) p.start() p.join() print(num.value) 输出: 1 小贴士：别整太复杂的共享状态，保持进程独立性，这样调试起来简单多了。

3 . 控制并发数量

CPU密集型任务：进程数就设成CPU核心数，别搞太多，不然上下文切换太耗性能。
比如： python from multiprocessing import cpu_count, Pool
with Pool(cpu_count()) as p: p.map(task, data_list)

I/O密集型任务：可以适当多开点进程（比如CPU核心数的2 倍），因为进程等I/O的时候CPU是闲着的。
比如： python with Pool(cpu_count() 2 ) as p: p.map_async(io_task, data_list) 异步提交任务

异步调用：用apply_async或map_async控制任务提交的节奏，防止主进程被阻塞。
比如： python results = [p.apply_async(task, (arg,)) for arg in data_list] output = [res.get() for res in results] 获取结果
4 . 异常处理与守护进程

子进程异常捕获：在子进程函数里加try-except，返回错误信息。
比如： python def safe_worker(x): try: return x / 0 except Exception as e: return f"出错了：{e}"
with Pool(2 ) as pool: res = pool.map(safe_worker, [1 , 2 ]) print(res) 输出: ['出错了：divisionbyzero', '出错了：divisionbyzero']

守护进程：设置daemon=True，子进程就跟着主进程退出了。
比如： python p = Process(target=worker, daemon=True) p.start() 主进程结束时，子进程自动退出
总结

选工具：独立任务用Process，批量任务用Pool。

通信方式：多进程用Queue，双进程用Pipe，简单数据用共享变量。

并发控制：CPU密集型按核心数分配，I/O密集型可以适当加量。

健壮性：子进程里捕获异常，必要时设为守护进程，退出逻辑简单点。

总之啊，合理用这些技巧，能大大提升Python多进程程序的性能和稳定性。

【Python 并发编程系列】第1篇：什么是并发编程？Python 到底能不能多线程跑任务？

嘿，各位编程爱好者们！今天咱们来聊聊并发编程这个小巧思。
想象一下，你的电脑就像一个超级服务员，一边服务着顾客A，一边又得赶去招呼顾客B，这样是不是效率蹭蹭往上涨？这就是并发编程的精髓——让程序在同一时间内处理多个任务，快如闪电！
Python虽然支持多线程，但是啊，它有个叫GIL的全局解释器锁，就像个交通警察，不让多个线程同时执行Python字节码。
所以，在处理CPU密集型任务时，多线程的效果并不理想，倒是在处理I/O密集型任务时，多线程就能大显身手了。

那么，什么是并发，什么是并行呢？简单来说，并发就是看似同时进行，实际上是在轮流进行；而并行则是真的同时在多个核心上执行。
进程和线程的区别也很有趣，进程就像是独立的公司，有自己的资源；而线程就像是公司里的员工，共享公司的资源，但得协调好，别发生冲突。

说到Python，GIL限制了多线程在CPU密集型任务上的表现，但在I/O密集型任务上，比如爬虫，多线程就能释放GIL，让其他线程执行，提高效率。

对于I/O密集型任务，比如网络请求和数据库查询，多线程是个不错的选择；而CPU密集型任务，比如复杂的数学运算和图像处理，就得考虑使用多进程或者C扩展来绕过GIL的限制。

在选择线程和进程时，得根据任务的类型和资源需求来定。
I/O密集型任务用线程，CPU密集型任务用进程，内存占用方面，线程共享内存，多进程独立内存。
启动成本也要考虑，线程启动快，适合小任务，进程启动慢，适合大任务。

最后，通过一些简单的代码测试，我们发现I/O密集型任务线程池和进程池的耗时差不多，CPU密集型任务的话，进程池就展现了它的优势，充分利用了多核CPU。

总之，并发编程能让我们程序跑得更快，Python的多线程适合I/O密集型任务，多进程适合CPU密集型任务。
虽然GIL是个小限制，但我们可以用多进程或异步编程来克服它。
记得根据任务需求来选择合适的并发策略哦！