python使用multiprocessing多进程通讯

2024-08-31 07:20

本文主要是介绍python使用multiprocessing多进程通讯,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

python使用multiprocessing,多进程通讯

    • 1 使用管道(Pipe)和使用队列(Queue)
    • 2 进行父进程和子进程间的简单通信
      • 1. 使用管道(Pipe)
        • 示例代码
      • 2. 使用队列(Queue)
        • 示例代码
      • 总结
    • 3 进行多个进程间的简单通信
      • 示例 1: 使用管道(Pipe)进行多个进程间的简单通信
        • 示例代码
      • 示例 2: 使用队列(Queue)进行多个进程间的简单通信
        • 示例代码
      • 解释
        • 示例 1: 使用管道(Pipe)进行多个进程间的简单通信
        • 示例 2: 使用队列(Queue)进行多个进程间的简单通信
      • 总结
    • 4 进程池中的简单通信
      • 示例 1: 使用管道(Pipe)进行进程池中的简单通信
        • 示例代码
      • 示例 2: 使用队列(Queue)进行进程池中的简单通信
        • 示例代码
      • 解释
        • 示例 1: 使用管道(Pipe)进行进程池中的简单通信
        • 示例 2: 使用队列(Queue)进行进程池中的简单通信
      • 总结

1 使用管道(Pipe)和使用队列(Queue)

在Python中,multiprocessing模块提供了一种简单的方式来利用多核处理器进行并行处理。对于进程间的通信,multiprocessing模块提供了几种机制,其中最常用的是管道(Pipe)和队列(Queue)。下面我将详细介绍这两种方法,并给出相应的示例代码。

2 进行父进程和子进程间的简单通信

1. 使用管道(Pipe)

管道是进程间通信的一种非常直接的方式。它可以实现两个进程之间的双向通信。multiprocessing.Pipe() 函数创建一对连接两端的管道对象。

示例代码

这里有一个使用管道进行进程间通信的例子:

import multiprocessingdef worker(conn):# 从管道接收消息msg = conn.recv()print(f"Received: {msg}")# 向管道发送消息conn.send("Reply from the worker")# 关闭管道conn.close()if __name__ == '__main__':# 创建管道parent_conn, child_conn = multiprocessing.Pipe()# 创建子进程p = multiprocessing.Process(target=worker, args=(child_conn,))# 启动子进程p.start()# 向管道发送消息parent_conn.send("Hello from the main process!")# 从管道接收回复reply = parent_conn.recv()print(f"Received Reply: {reply}")# 等待子进程结束p.join()

在这个例子中:

  • 我们首先导入了 multiprocessing 模块。
  • 使用 multiprocessing.Pipe() 创建了一个管道,返回两个连接对象 parent_connchild_conn
  • 创建了一个子进程 p,它调用 worker 函数,并传入 child_conn 作为参数。
  • 主进程中,我们向管道发送了一条消息 "Hello from the main process!"
  • 子进程中,我们从管道接收了这条消息,并打印出来,然后向管道发送回复。
  • 主进程中,我们再次从管道接收回复,并打印出来。
  • 最后,我们等待子进程结束。

2. 使用队列(Queue)

队列是一种更安全的进程间通信方式,因为它内置了线程安全的锁机制,可以避免竞态条件。multiprocessing.Queue() 可以创建一个进程安全的队列对象。

示例代码

这里是一个使用队列进行进程间通信的例子:

import multiprocessingdef worker(queue):# 从队列接收消息msg = queue.get()print(f"Received: {msg}")# 向队列发送消息queue.put("Reply from the worker")if __name__ == '__main__':# 创建队列queue = multiprocessing.Queue()# 创建子进程p = multiprocessing.Process(target=worker, args=(queue,))# 启动子进程p.start()# 向队列发送消息queue.put("Hello from the main process!")# 从队列接收回复reply = queue.get()print(f"Received Reply: {reply}")# 等待子进程结束p.join()

在这个例子中:

  • 我们同样首先导入了 multiprocessing 模块。
  • 使用 multiprocessing.Queue() 创建了一个队列对象。
  • 创建了一个子进程 p,它调用 worker 函数,并传入 queue 作为参数。
  • 主进程中,我们向队列发送了一条消息 "Hello from the main process!"
  • 子进程中,我们从队列接收了这条消息,并打印出来,然后向队列发送回复。
  • 主进程中,我们再次从队列接收回复,并打印出来。
  • 最后,我们等待子进程结束。

总结

管道和队列都是有效的进程间通信机制。管道适用于两个进程之间直接通信的情况,而队列则更适合多个进程之间共享数据,尤其是在数据顺序和安全性方面有较高要求的情况下。选择哪种方法取决于你的具体需求和场景。

3 进行多个进程间的简单通信

当然可以!下面我将提供两个简单的例子来展示如何使用 Python 的 multiprocessing 模块进行多个并行进程间的通信。我们将分别使用管道(Pipe)和队列(Queue)来实现这一目标。

示例 1: 使用管道(Pipe)进行多个进程间的简单通信

在这个例子中,我们将创建一个主进程和两个子进程。主进程将发送乘法运算请求给子进程,子进程将计算结果并将其返回给主进程。

示例代码
import multiprocessingdef worker(conn):"""子进程处理函数"""while True:# 从管道接收消息data = conn.recv()if data is None:breaka, b = data# 计算结果result = a * b# 向管道发送结果conn.send(result)if __name__ == '__main__':# 创建管道parent_conns, child_conns = zip(*[multiprocessing.Pipe() for _ in range(2)])# 创建子进程processes = [multiprocessing.Process(target=worker, args=(conn,)) for conn in child_conns]# 启动子进程for p in processes:p.start()# 发送乘法请求requests = [(1, 2), (3, 4), (5, 6)]for i, (a, b) in enumerate(requests):parent_conns[i % len(parent_conns)].send((a, b))# 接收结果results = []for i, parent_conn in enumerate(parent_conns):for _ in range(len(requests) // len(parent_conns)):result = parent_conn.recv()results.append(result)print(f"Result: {result}")# 发送结束信号for parent_conn in parent_conns:parent_conn.send(None)# 等待子进程结束for p in processes:p.join()print("All results:", results)

示例 2: 使用队列(Queue)进行多个进程间的简单通信

在这个例子中,我们将使用队列来进行多个进程间的通信。我们将创建一个主进程和两个子进程。主进程将发送乘法运算请求到队列中,子进程将从队列中取出请求进行计算,并将结果发送回主进程。

示例代码
import multiprocessingdef worker(input_queue, output_queue):"""子进程处理函数"""while True:# 从队列接收消息data = input_queue.get()if data is None:breaka, b = data# 计算结果result = a * b# 向队列发送结果output_queue.put(result)if __name__ == '__main__':# 创建队列input_queue = multiprocessing.Queue()output_queue = multiprocessing.Queue()# 创建子进程processes = [multiprocessing.Process(target=worker, args=(input_queue, output_queue)) for _ in range(2)]# 启动子进程for p in processes:p.start()# 发送乘法请求requests = [(1, 2), (3, 4), (5, 6)]for request in requests:input_queue.put(request)# 接收结果results = []for _ in range(len(requests)):result = output_queue.get()results.append(result)print(f"Result: {result}")# 发送结束信号for _ in range(len(processes)):input_queue.put(None)# 等待子进程结束for p in processes:p.join()print("All results:", results)

解释

示例 1: 使用管道(Pipe)进行多个进程间的简单通信
  1. 我们创建了两个双向管道,它们由 parent_connchild_conn 组成。
  2. 创建了两个子进程 processes,它们调用 worker 函数,并传入 child_conn 作为参数。
  3. 主进程中,我们依次向管道发送乘法请求。
  4. 子进程中,我们从管道接收请求,计算结果,并将结果通过管道发回给主进程。
  5. 主进程中,我们从管道接收结果,并打印出来。
  6. 最后,我们向管道发送 None 作为结束信号,并等待子进程结束。
示例 2: 使用队列(Queue)进行多个进程间的简单通信
  1. 我们创建了一个输入队列 input_queue 和一个输出队列 output_queue
  2. 创建了两个子进程 processes,它们调用 worker 函数,并传入两个队列作为参数。
  3. 主进程中,我们依次向输入队列发送乘法请求。
  4. 子进程中,我们从输入队列接收请求,计算结果,并将结果通过输出队列发回给主进程。
  5. 主进程中,我们从输出队列接收结果,并打印出来。
  6. 最后,我们向输入队列发送 None 作为结束信号,并等待子进程结束。

总结

这两种方法都可以有效地实现多个进程间的简单通信。使用管道的方式更简单直接,适合两个进程之间的通信。而使用队列的方式更适合多个进程之间的通信,特别是当需要处理多个请求时更为灵活。你可以根据实际情况选择最适合你需求的方法。

4 进程池中的简单通信

当然可以!下面我将提供两个简单的例子来展示如何使用 Python 的 multiprocessing 模块中的 Pool 类进行多个并行进程间的通信。我们将分别使用管道(Pipe)和队列(Queue)来实现这一目标。

示例 1: 使用管道(Pipe)进行进程池中的简单通信

在这个例子中,我们将创建一个主进程和一个进程池。主进程将发送乘法运算请求给进程池中的子进程,子进程将计算结果并将其返回给主进程。

示例代码
import multiprocessingdef worker(conn, a, b):"""子进程处理函数"""# 计算结果result = a * b# 向管道发送结果conn.send(result)if __name__ == '__main__':# 创建管道parent_conn, child_conn = multiprocessing.Pipe()# 创建进程池with multiprocessing.Pool() as pool:# 定义请求requests = [(1, 2), (3, 4), (5, 6)]# 提交任务到进程池results = [pool.apply_async(worker, args=(child_conn, a, b)) for a, b in requests]# 等待所有任务完成for _ in results:result = parent_conn.recv()print(f"Received result: {result}")# 打印所有结果print("All results:", [r.get() for r in results])

示例 2: 使用队列(Queue)进行进程池中的简单通信

在这个例子中,我们将使用队列来进行进程池中的简单通信。我们将创建一个主进程和一个进程池。主进程将发送乘法运算请求到队列中,进程池中的子进程将从队列中取出请求进行计算,并将结果发送回主进程。

示例代码
import multiprocessingdef worker(input_queue, output_queue):"""子进程处理函数"""while True:# 从队列接收消息data = input_queue.get()if data is None:breaka, b = data# 计算结果result = a * b# 向队列发送结果output_queue.put(result)if __name__ == '__main__':# 创建队列input_queue = multiprocessing.Queue()output_queue = multiprocessing.Queue()# 创建进程池with multiprocessing.Pool() as pool:# 提交任务到进程池workers = [pool.apply_async(worker, args=(input_queue, output_queue))]# 发送乘法请求requests = [(1, 2), (3, 4), (5, 6)]for request in requests:input_queue.put(request)# 接收结果results = []for _ in range(len(requests)):result = output_queue.get()results.append(result)print(f"Received result: {result}")# 发送结束信号for _ in range(len(workers)):input_queue.put(None)# 等待所有任务完成for w in workers:w.get()# 打印所有结果print("All results:", results)

解释

示例 1: 使用管道(Pipe)进行进程池中的简单通信
  1. 我们创建了一个双向管道,它由 parent_connchild_conn 组成。
  2. 创建了一个进程池。
  3. 主进程中,我们依次向进程池提交乘法请求,并定义了一个回调函数 worker,该函数将结果通过管道发给主进程。
  4. 进程池内部调度执行任务,并通过管道将结果发送给主进程。
  5. 主进程中,我们从管道接收结果,并打印出来。
  6. 最后,我们通过 results 列表收集所有的结果。
示例 2: 使用队列(Queue)进行进程池中的简单通信
  1. 我们创建了一个输入队列 input_queue 和一个输出队列 output_queue
  2. 创建了一个进程池。
  3. 主进程中,我们依次向输入队列发送乘法请求。
  4. 进程池中的子进程从输入队列接收请求,计算结果,并将结果通过输出队列发回给主进程。
  5. 主进程中,我们从输出队列接收结果,并打印出来。
  6. 最后,我们向输入队列发送 None 作为结束信号,并等待所有任务完成。

总结

这两种方法都可以有效地实现进程池中的简单通信。使用管道的方式更简单直接,适合两个进程之间的通信。而使用队列的方式更适合多个进程之间的通信,特别是当需要处理多个请求时更为灵活。你可以根据实际情况选择最适合你需求的方法。请注意,在使用进程池时,我们通常不需要直接管理进程间的通信,而是利用进程池提供的方法来间接实现。

这篇关于python使用multiprocessing多进程通讯的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/1123256

相关文章

中文分词jieba库的使用与实景应用(一)

知识星球:https://articles.zsxq.com/id_fxvgc803qmr2.html 目录 一.定义: 精确模式(默认模式): 全模式: 搜索引擎模式: paddle 模式(基于深度学习的分词模式): 二 自定义词典 三.文本解析   调整词出现的频率 四. 关键词提取 A. 基于TF-IDF算法的关键词提取 B. 基于TextRank算法的关键词提取

python: 多模块(.py)中全局变量的导入

文章目录 global关键字可变类型和不可变类型数据的内存地址单模块(单个py文件)的全局变量示例总结 多模块(多个py文件)的全局变量from x import x导入全局变量示例 import x导入全局变量示例 总结 global关键字 global 的作用范围是模块(.py)级别: 当你在一个模块(文件)中使用 global 声明变量时,这个变量只在该模块的全局命名空

使用SecondaryNameNode恢复NameNode的数据

1)需求: NameNode进程挂了并且存储的数据也丢失了,如何恢复NameNode 此种方式恢复的数据可能存在小部分数据的丢失。 2)故障模拟 (1)kill -9 NameNode进程 [lytfly@hadoop102 current]$ kill -9 19886 (2)删除NameNode存储的数据(/opt/module/hadoop-3.1.4/data/tmp/dfs/na

Hadoop数据压缩使用介绍

一、压缩原则 (1)运算密集型的Job,少用压缩 (2)IO密集型的Job,多用压缩 二、压缩算法比较 三、压缩位置选择 四、压缩参数配置 1)为了支持多种压缩/解压缩算法,Hadoop引入了编码/解码器 2)要在Hadoop中启用压缩,可以配置如下参数

Makefile简明使用教程

文章目录 规则makefile文件的基本语法:加在命令前的特殊符号:.PHONY伪目标: Makefilev1 直观写法v2 加上中间过程v3 伪目标v4 变量 make 选项-f-n-C Make 是一种流行的构建工具,常用于将源代码转换成可执行文件或者其他形式的输出文件(如库文件、文档等)。Make 可以自动化地执行编译、链接等一系列操作。 规则 makefile文件

使用opencv优化图片(画面变清晰)

文章目录 需求影响照片清晰度的因素 实现降噪测试代码 锐化空间锐化Unsharp Masking频率域锐化对比测试 对比度增强常用算法对比测试 需求 对图像进行优化,使其看起来更清晰,同时保持尺寸不变,通常涉及到图像处理技术如锐化、降噪、对比度增强等 影响照片清晰度的因素 影响照片清晰度的因素有很多,主要可以从以下几个方面来分析 1. 拍摄设备 相机传感器:相机传

【Python编程】Linux创建虚拟环境并配置与notebook相连接

1.创建 使用 venv 创建虚拟环境。例如,在当前目录下创建一个名为 myenv 的虚拟环境: python3 -m venv myenv 2.激活 激活虚拟环境使其成为当前终端会话的活动环境。运行: source myenv/bin/activate 3.与notebook连接 在虚拟环境中,使用 pip 安装 Jupyter 和 ipykernel: pip instal

pdfmake生成pdf的使用

实际项目中有时会有根据填写的表单数据或者其他格式的数据,将数据自动填充到pdf文件中根据固定模板生成pdf文件的需求 文章目录 利用pdfmake生成pdf文件1.下载安装pdfmake第三方包2.封装生成pdf文件的共用配置3.生成pdf文件的文件模板内容4.调用方法生成pdf 利用pdfmake生成pdf文件 1.下载安装pdfmake第三方包 npm i pdfma

零基础学习Redis(10) -- zset类型命令使用

zset是有序集合,内部除了存储元素外,还会存储一个score,存储在zset中的元素会按照score的大小升序排列,不同元素的score可以重复,score相同的元素会按照元素的字典序排列。 1. zset常用命令 1.1 zadd  zadd key [NX | XX] [GT | LT]   [CH] [INCR] score member [score member ...]

【机器学习】高斯过程的基本概念和应用领域以及在python中的实例

引言 高斯过程(Gaussian Process,简称GP)是一种概率模型,用于描述一组随机变量的联合概率分布,其中任何一个有限维度的子集都具有高斯分布 文章目录 引言一、高斯过程1.1 基本定义1.1.1 随机过程1.1.2 高斯分布 1.2 高斯过程的特性1.2.1 联合高斯性1.2.2 均值函数1.2.3 协方差函数(或核函数) 1.3 核函数1.4 高斯过程回归(Gauss