Python通过队列来实现进程间通信的示例

2024-10-14 21:10:11

Python程序中，在进程和进程之间是不共享全局变量的数据的。

我们来看一个例子：

from multiprocessing import Process
import os
import time

nums = [11, 22]

def work1():
  """子进程要执行的代码"""
  print("in process1 pid=%d ,nums=%s" % (os.getpid(), nums))
  for i in range(3):
    nums.append(i)
    time.sleep(1)
    print("in process1 pid=%d ,nums=%s" % (os.getpid(), nums))

def work2():
  """子进程要执行的代码"""
  print("in process2 pid=%d ,nums=%s" % (os.getpid(), nums))

if __name__ == '__main__':
  p1 = Process(target=work1)
  p1.start()
  p1.join()

  p2 = Process(target=work2)
  p2.start()

进程 p1 里对全局变量 nums 循环进行处理，进程 p2 将 nums 打印出来，发现 nums 的值没有变化。

运行结果：

in process1 pid=5788 ,nums=[11, 22]
in process1 pid=5788 ,nums=[11, 22, 0]
in process1 pid=5788 ,nums=[11, 22, 0, 1]
in process1 pid=5788 ,nums=[11, 22, 0, 1, 2]
in process2 pid=11832 ,nums=[11, 22]

通过队列完成进程间通信

但是进程(Process)之间有时需要通信，操作系统提供了很多机制来实现进程间的通信。

可以使用 multiprocessing 模块的 Queue 实现多进程之间的数据传递。

Queue 本身是一个消息队列程序，首先用一个小实例来演示一下 Queue 的工作原理：

from multiprocessing import Queue
# 初始化一个Queue对象，最多可接收三条put消息
q = Queue(3)
q.put("消息1")
q.put("消息2")
print(q.full()) # False
q.put("消息3")
print(q.full()) # True

# 因为消息队列已满下面的try都会抛出异常
# 第一个try会等待2秒后再抛出异常
try:
  q.put("消息4", True, 2)
except:
  print("消息队列已满，现有消息数量:%s" % q.qsize())
# 第二个Try会立刻抛出异常
try:
  q.put_nowait("消息4")
except:
  print("消息列队已满，现有消息数量:%s" % q.qsize())

# 推荐的方式，先判断消息列队是否已满，再写入
if not q.full():
  q.put_nowait("消息4")

# 读取消息时，先判断消息列队是否为空，再读取
if not q.empty():
  for i in range(q.qsize()):
    print(q.get_nowait())

运行结果：

队列 Queue 的使用说明

初始化 Queue()对象时（例如：q=Queue()），若括号中没有指定最大可接收的消息数量，或数量为负值，那么就代表可接受的消息数量没有上限（直到内存的尽头）。

Queue.qsize()：返回当前队列包含的消息数量。

Queue.empty()：如果队列为空，返回True，反之False。

Queue.full()：如果队列满了，返回True，反之False。

Queue.get([block[, timeout]])：获取队列中的一条消息，然后将其从列队中移除，block 默认值为 True。

如果 block 使用默认值，且没有设置 timeout（单位秒），消息队列如果为空，此时程序将被阻塞，停在读取状态，直到从消息队列读到消息为止；如果设置了 timeout，则会等待 timeout 秒，若还没读取到任何消息，则抛出 "Queue.Empty" 异常。
如果 block 值为 False，消息列队如果为空，则会立刻抛出 "Queue.Empty" 异常。

Queue.get_nowait()：相当 Queue.get(False)。

Queue.put(item,[block[, timeout]])：将 item 消息写入队列，block 默认值为 True。

如果 block 使用默认值，且没有设置 timeout（单位秒），消息队列如果已经没有空间可写入，此时程序将被阻塞，停在写入状态，直到从消息队列腾出空间为止；如果设置了timeout，则会等待 timeout 秒，若还没空间，则抛出 "Queue.Full" 异常。
如果 block 值为 False，消息队列如果没有空间可写入，则会立刻抛出 "Queue.Full" 异常。

Queue.put_nowait(item)：相当Queue.put(item, False)。

Queue实例

我们以 Queue 为例，在父进程中创建两个子进程，一个往 Queue 里写数据，一个从 Queue 里读数据。

from multiprocessing import Process, Queue
import os
import time
import random

def write(q):
  # 写数据进程执行的代码:
  for value in ['A', 'B', 'C']:
    print('Put %s to queue...' % value)
    q.put(value)
    time.sleep(random.random())

def read(q):
  # 读数据进程执行的代码:
  while True:
    if not q.empty():
      value = q.get(True)
      print('Get %s from queue.' % value)
      time.sleep(random.random())
    else:
      break

if __name__ == '__main__':
  # 父进程创建Queue，并传给各个子进程：
  q = Queue()
  pw = Process(target=write, args=(q,))
  pr = Process(target=read, args=(q,))
  # 启动子进程pw，写入:
  pw.start()
  # 等待pw结束:
  pw.join()
  # 启动子进程pr，读取:
  pr.start()
  pr.join()
  print('')
  print('所有数据都写入并且读完')

运行结果：

以上就是Python通过队列来实现进程间通信的示例的详细内容，更多关于python实现进程间通信的资料请关注我们其它相关文章！

python进程间通信Queue工作过程详解

Process之间有时需要通信,操作系统提供了很多机制来实现进程间的通信. 1. Queue的使用可以使用multiprocessing模块的Queue实现多进程之间的数据传递,Queue本身是一个消息列队程序,首先用一个小实例来演示一下Queue的工作原理: import multiprocessing q = multiprocessing.Queue(3) # 初始化的Queue对象,最多能put三条消息 q.put("消息1") q.put("消息2")
Python通过4种方式实现进程数据通信

python提供了4种方式来满足进程间的数据通信 1. 使用multiprocessing.Queue可以在进程间通信,但不能在Pool池创建的进程间进行通信 2. 使用multiprocessing.Manager.Queue可以在Pool进程池创建的进程间进行通信 3. 通过Pipe进行线程间的通信, pipe进程间通信的性能高于Queue,但是它只能在两个进程间进行通信 4. 使用Manager类提供的数据结构可以进行进程间的通信 from multiprocessing import P
Python RabbitMQ实现简单的进程间通信示例

RabbitMQ 消息队列 PY threading Queue 进程Queue 父进程与子进程,或同一父进程下的多个子进程进行交互缺点:两个不同Python文件不能通过上面两个Queue进行交互 erlong 基于这个语言创建的一种中间商 win中需要先安装erlong才能使用 rabbitmq_server start 安装 Python module pip install pika or easy_install pika or 源码 rabbit 默认端口15672
Python进程的通信Queue、Pipe实例分析

本文实例讲述了Python进程的通信Queue.Pipe.分享给大家供大家参考,具体如下: 内容相关: 概念:进程的通信 Queue:创建与使用 Pipe:创建与使用进程通信的概念进程的资源空间是相互独立的,一般而言是不能相互访问的.但很多情况下进程间需要互相通信,来完成系统的某项功能.进程通过与内核及其它进程之间的互相通信来协调它们的行为. 通信方法: 数据传输:一个进程将它的数据发送给另一个进程[如socket一般,把需要通信的数据传输给对方] 管道:使用一片独立的区域[不在双方的资源空
Python进程间通信Queue消息队列用法分析

本文实例讲述了Python进程间通信Queue消息队列用法.分享给大家供大家参考,具体如下: 进程间通信-Queue Process之间有时需要通信,操作系统提供了很多机制来实现进程间的通信. 1. Queue的使用可以使用multiprocessing模块的Queue实现多进程之间的数据传递,Queue本身是一个消息列队程序,首先用一个小实例来演示下Queue的工作原理: 代码如下: #coding=utf-8 from multiprocessing import Queue #初始化一个
Python队列、进程间通信、线程案例

进程互斥锁多进程同时抢购余票 # 并发运行,效率高,但竞争写同一文件,数据写入错乱 # data.json文件内容为 {"ticket_num": 1} import json import time from multiprocessing import Process def search(user): with open('data.json', 'r', encoding='utf-8') as f: dic = json.load(f) print(f'用户{user}查看
Python进程间通信multiprocess代码实例

仔细说来,multiprocess不是一个模块而是python中一个操作.管理进程的包. 之所以叫multi是取自multiple的多功能的意思,在这个包中几乎包含了和进程有关的所有子模块.由于提供的子模块非常多,为了方便大家归类记忆,我将这部分大致分为四个部分:创建进程部分,进程同步部分,进程池部分,进程之间数据共享.重点强调:进程没有任何共享状态,进程修改的数据,改动仅限于该进程内,但是通过一些特殊的方法,可以实现进程之间数据的共享. 有了之前多线程使用以及线程间queue的基础,多进程以及
python多进程间通信代码实例

这篇文章主要介绍了python多进程间通信代码实例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下这里使用pipe代码如下: import time from multiprocessing import Process import multiprocessing class D: @staticmethod def test(pipe): while True: for i in range(10): pipe.send(i) time.s
Python进程间通信 multiProcessing Queue队列实现详解

一.进程间通信 IPC(Inter-Process Communication) IPC机制:实现进程之间通讯管道:pipe 基于共享的内存空间队列:pipe+锁的概念--->queue 二.队列(Queue) 2.1 概念-----multiProcess.Queue 创建共享的进程队列,Queue是多进程安全的队列,可以使用Queue实现多进程之间的数据传递. Queue([maxsize])创建共享的进程队列. 参数 :maxsize是队列中允许的最大项数.如果省略此参数,则无大小限制
Python通过队列来实现进程间通信的示例

Python程序中,在进程和进程之间是不共享全局变量的数据的. 我们来看一个例子: from multiprocessing import Process import os import time nums = [11, 22] def work1(): """子进程要执行的代码""" print("in process1 pid=%d ,nums=%s" % (os.getpid(), nums)) for i in ra
Python通过队列实现进程间通信详情

目录一.前言二.队列简介三.多进程队列的使用四.使用队列在进程间通信一.前言在多进程中,每个进程之间是什么关系呢?其实每个进程都有自己的地址空间.内存.数据栈以及其他记录其运行状态的辅助数据.下面通过一个例子,验证一下进程之间能否直接共享信息. 定义一个全局变量g_num,分别创建2个子进程对g_num执行不同的操作,并输出操作后的结果. 代码如下: # _*_ coding:utf-8 _*_ from multiprocessing import Process def plus
Python tornado队列示例-一个并发web爬虫代码分享

Queue Tornado的tornado.queue模块为基于协程的应用程序实现了一个异步生产者/消费者模式的队列.这与python标准库为多线程环境实现的queue模块类似. 一个协程执行到yieldqueue.get会暂停,直到队列中有条目.如果queue有上限,一个协程执行yieldqueue.put将会暂停,直到队列中有空闲的位置. 在一个queue内部维护了一个未完成任务的引用计数,每调用一次put操作便会增加引用计数,而调用task_done操作将会减少引用计数. 下面是一个简单的
Python实现队列的方法示例小结【数组，链表】

本文实例讲述了Python实现队列的方法.分享给大家供大家参考,具体如下: Python实现队列队列(FIFO),添加元素在队列尾,删除元素在队列头操作列表实现队列:利用python列表方法代码如下: # 列表实现队列 class listQueue(object): def __init__(self): self.items = [] def is_empty(self): return self.items == None def size(self): return len(sel
Python 使用threading+Queue实现线程池示例

一.线程池 1.为什么需要使用线程池 1.1 创建/销毁线程伴随着系统开销,过于频繁的创建/销毁线程,会很大程度上影响处理效率. 记创建线程消耗时间T1,执行任务消耗时间T2,销毁线程消耗时间T3,如果T1+T3>T2,那说明开启一个线程来执行这个任务太不划算了!在线程池缓存线程可用已有的闲置线程来执行新任务,避免了创建/销毁带来的系统开销. 1.2 线程并发数量过多,抢占系统资源从而导致阻塞. 线程能共享系统资源,如果同时执行的线程过多,就有可能导致系统资源不足而产生阻塞的情况. 1.3 对线
Python实现RabbitMQ6种消息模型的示例代码

RabbitMQ与Redis对比 RabbitMQ是一种比较流行的消息中间件,之前我一直使用redis作为消息中间件,但是生产环境比较推荐RabbitMQ来替代Redis,所以我去查询了一些RabbitMQ的资料.相比于Redis,RabbitMQ优点很多,比如: 具有消息消费确认机制队列,消息,都可以选择是否持久化,粒度更小.更灵活. 可以实现负载均衡 RabbitMQ应用场景异步处理:比如用户注册时的确认邮件.短信等交由rabbitMQ进行异步处理应用解耦:比如收发消息双方可以使用
python使用多线程查询数据库的实现示例

一.背景: 当数据量过大时,一个程序的执行时间就会主要花费在等待单次查询返回结果,在这个过程中cpu无疑是处于等待io的空闲状态的,这样既浪费了cpu资源,又花费了大量时间(当然这里主要说多线程,批量查询不在考虑范围,总会存在不能批量查询的情况),在这种非密集型运算(及大量占用cpu资源)的情况下在python中无疑运用多线程是一个非常棒的选择. 二.知识点: 数据库连接池的运用及优势,python中多线程的运用,队列的运用数据库连接池:限制了数据库的连接最大个数,每次连接都是可以重复使用的,
python遍历路径破解表单的示例

首先是利用python遍历路径,采用字典爆破的形式,当然如果只是单纯的爆破路径,简单写一个多线程脚本就行了.这里考虑如何对爆破到的路径进行第二步利用,此处尝试对猜解到的路径进行表单发现及登陆爆破处理. 首先就是路径爆破,采用多线程队列,爆破路径,判断形式为200响应码. while not self._queue.empty(): queue = self._queue.get(timeout=0.5) try: r = requests.get(self.url+queue,timeout=
Python实现曲线点抽稀算法的示例

本文介绍了Python实现曲线点抽稀算法的示例,分享给大家,具体如下: 目录何为抽稀道格拉斯-普克(Douglas-Peuker)算法垂距限值法最后正文何为抽稀在处理矢量化数据时,记录中往往会有很多重复数据,对进一步数据处理带来诸多不便.多余的数据一方面浪费了较多的存储空间,另一方面造成所要表达的图形不光滑或不符合标准.因此要通过某种规则,在保证矢量曲线形状不变的情况下, 最大限度地减少数据点个数,这个过程称为抽稀. 通俗的讲就是对曲线进行采样简化,即在曲线上取有限个点,将其变为折

Python通过队列来实现进程间通信的示例

相关推荐

随机推荐