python中实现多进程通信的核心是multiprocessing模块提供的机制，1. queue适用于多生产者-多消费者场景，支持进程安全的fifo数据交换，自动处理序列化和同步；2. pipe提供轻量级的点对点双向通信，适合两个进程间的高效数据传输；3. manager支持共享复杂对象如列表和字典，通过代理实现跨进程访问；4. 共享内存（value/array）提供高性能的数据共享，适用于简单类型但需手动加锁；5. 同步原语（lock、semaphore、event、condition）用于协调进程执行，避免竞态条件，最终选择应根据通信模式、数据类型和性能需求综合决定。
Python中实现多进程通信，核心在于
multiprocessing
在Python的多进程编程里，进程因为拥有独立的内存空间，所以不像线程那样可以直接访问共享数据。这就意味着，如果你想让两个进程协同工作，比如一个进程负责生产数据，另一个进程负责消费数据，或者它们需要共享某些状态信息，那么就必须显式地进行通信。
解决方案
立即学习“Python免费学习笔记（深入）”；
实现多进程通信，我通常会从两个最常用、也最直观的工具入手：
multiprocessing.Queue
multiprocessing.Pipe
Queue
比如，一个进程负责从文件读取大量数据并处理，另一个进程则负责将处理后的数据写入数据库。
import multiprocessing
import time
import os
def producer(q, data_count):
"""生产者：生成数据并放入队列"""
print(f"[{os.getpid()}] 生产者启动...")
for i in range(data_count):
item = f"数据块-{i}"
q.put(item)
print(f"[{os.getpid()}] 放入: {item}")
time.sleep(0.1) # 模拟数据生成耗时
q.put(None) # 发送结束信号
print(f"[{os.getpid()}] 生产者完成。")
def consumer(q):
"""消费者：从队列中取出数据并处理"""
print(f"[{os.getpid()}] 消费者启动...")
while True:
item = q.get()
if item is None: # 收到结束信号
break
print(f"[{os.getpid()}] 取出: {item}, 正在处理...")
time.sleep(0.2) # 模拟数据处理耗时
print(f"[{os.getpid()}] 消费者完成。")
if __name__ == "__main__":
q = multiprocessing.Queue()
data_to_produce = 10
p_process = multiprocessing.Process(target=producer, args=(q, data_to_produce))
c_process = multiprocessing.Process(target=consumer, args=(q,))
p_process.start()
c_process.start()
p_process.join()
c_process.join()
print("所有进程已完成通信示例。")而
Pipe
send()
recv()
import multiprocessing
import time
import os
def sender_process(conn):
"""发送方：通过管道发送数据"""
print(f"[{os.getpid()}] 发送方启动...")
for i in range(5):
msg = f"你好，这是消息 {i}"
conn.send(msg)
print(f"[{os.getpid()}] 发送: {msg}")
time.sleep(0.5)
conn.send("结束") # 发送结束信号
conn.close() # 关闭连接
print(f"[{os.getpid()}] 发送方完成。")
def receiver_process(conn):
"""接收方：通过管道接收数据"""
print(f"[{os.getpid()}] 接收方启动...")
while True:
try:
msg = conn.recv()
if msg == "结束":
break
print(f"[{os.getpid()}] 接收到: {msg}")
except EOFError: # 当管道另一端关闭时会抛出
break
conn.close()
print(f"[{os.getpid()}] 接收方完成。")
if __name__ == "__main__":
parent_conn, child_conn = multiprocessing.Pipe() # 创建管道
sender = multiprocessing.Process(target=sender_process, args=(parent_conn,))
receiver = multiprocessing.Process(target=receiver_process, args=(child_conn,))
sender.start()
receiver.start()
sender.join()
receiver.join()
print("管道通信示例完成。")为什么需要多进程通信？单进程或多线程不够吗？
这是一个很棒的问题，它直指我们选择多进程的根本原因。说实话，很多时候，单进程确实能搞定大部分事情，尤其是在IO密集型任务上，异步编程或者多线程就能发挥得很好。但当遇到CPU密集型任务时，Python的全局解释器锁（GIL）就成了多线程的“紧箍咒”。
GIL的存在意味着，在任何给定时刻，只有一个线程能够执行Python字节码。这导致即使你创建了多个线程，它们也无法真正并行地利用多核CPU的计算能力。它们只是在CPU时间片上快速切换，看起来像并行，实则还是串行执行。
而进程则不同，每个进程都有自己独立的GIL，它们是操作系统层面的独立执行单元。这意味着，当你启动多个进程时，它们是真正并行地在不同CPU核心上运行的，完全绕开了GIL的限制。所以，对于那些需要大量计算、数据处理、科学计算等CPU密集型任务，多进程才是发挥多核优势的关键。
既然进程之间是独立的，拥有各自的内存空间，那么它们之间的数据交换和协作就成了新的问题。它们不会像线程那样天然共享内存。这就是为什么我们需要
multiprocessing
multiprocessing.Queue与multiprocessing.Pipe如何选择？
在
multiprocessing
Queue
Pipe
总结一下我的经验：
Queue
Pipe
除了Queue和Pipe，还有哪些高级通信或同步机制？
multiprocessing
首先，不得不提的是
Manager
Manager
# Manager 示例
import multiprocessing
import time
def worker_with_manager(shared_list, shared_dict, process_id):
print(f"[{process_id}] 启动...")
shared_list.append(f"来自进程{process_id}的数据")
shared_dict[f'key_{process_id}'] = f'value_{process_id}'
print(f"[{process_id}] 修改了共享数据。")
time.sleep(0.5)
if __name__ == "__main__":
with multiprocessing.Manager() as manager:
shared_list = manager.list() # 创建一个可在进程间共享的列表
shared_dict = manager.dict() # 创建一个可在进程间共享的字典
processes = []
for i in range(3):
p = multiprocessing.Process(target=worker_with_manager, args=(shared_list, shared_dict, i))
processes.append(p)
p.start()
for p in processes:
p.join()
print("\n所有进程完成。")
print("最终共享列表:", shared_list)
print("最终共享字典:", shared_dict)Manager
其次，是共享内存（Shared Memory）。
multiprocessing
Value
Array
# 共享内存示例 (Value 和 Array)
import multiprocessing
import time
def increment_value(shared_val, process_id):
print(f"[{process_id}] 启动...")
for _ in range(5):
with shared_val.get_lock(): # 使用锁来保护共享值
shared_val.value += 1
print(f"[{process_id}] 值增加到: {shared_val.value}")
time.sleep(0.1)
def modify_array(shared_arr, process_id):
print(f"[{process_id}] 启动修改数组...")
for i in range(len(shared_arr)):
with shared_arr.get_lock():
shared_arr[i] += process_id
print(f"[{process_id}] 修改数组[{i}]到: {shared_arr[i]}")
time.sleep(0.05)
if __name__ == "__main__":
# 共享整数值
shared_int = multiprocessing.Value('i', 0) # 'i' 表示有符号整数
# 共享整数数组
shared_array = multiprocessing.Array('i', [0, 0, 0]) # 'i' 表示有符号整数，长度为3
processes = []
# 针对共享值
for i in range(2):
p = multiprocessing.Process(target=increment_value, args=(shared_int, i))
processes.append(p)
p.start()
# 针对共享数组
for i in range(2):
p = multiprocessing.Process(target=modify_array, args=(shared_array, i))
processes.append(p)
p.start()
for p in processes:
p.join()
print("\n所有进程完成。")
print("最终共享整数值:", shared_int.value)
print("最终共享数组:", list(shared_array))使用共享内存时，你必须自己处理同步问题，比如使用
Lock
最后，是同步原语（Synchronization Primitives）。虽然它们不直接用于数据传输，但对于协调进程的执行流程至关重要。这包括：
这些同步原语在多进程编程中扮演着“交通警察”的角色，确保进程间的协作有序进行，避免混乱和数据损坏。
选择哪种通信或同步机制，很大程度上取决于你具体的应用场景：数据量大小、数据类型、通信模式（一对一、一对多、多对多）、以及对性能的要求。有时候，甚至需要将多种机制结合起来使用，才能构建出既高效又健壮的多进程应用。
以上就是Python如何实现多进程通信？multiprocessing模块详解的详细内容，更多请关注php中文网其它相关文章！
每个人都需要一台速度更快、更稳定的 PC。随着时间的推移，垃圾文件、旧注册表数据和不必要的后台进程会占用资源并降低性能。幸运的是，许多工具可以让 Windows 保持平稳运行。
Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号
163
收藏
