1 进程Queue介绍

1 进程间数据隔离,两个进程进行通信,借助于Queue

2 进程间通信:IPC
-借助于Queue实现进程间通信
   -借助于文件
   
   -借助于数据库
   -借助于消息队列:rabbitmq,kafka....

1.1 基本使用


from multiprocessing import Process,Queue


if __name__ == '__main__':
# maxsize表示Queue的大小是多少,能放多少东西
queue=Queue(3)
## 放数据
queue.put('zhangsan')
queue.put('liss')
queue.put('wwwww')

queue.put('wwwww',timeout=0.1)

# queue.put_nowait('sdafsd')
#
# res=queue.get()
# print(res)
# res=queue.get()
# print(res)
res=queue.get()
# print(res)
# # 卡住
# # res=queue.get()
# res=queue.get_nowait()
# print(res) '''
# 实例化得到一个对象,数字表示queue的大小(默认不传参,可以当成无限大,但其实有最大值)
queue=Queue(3)
# 放值
# block:是否阻塞
#timeout:等待的时间
queue.put()
#取值
# block:是否阻塞
#timeout:等待的时间
queue.get() # 不等待,如果满了,就报错
queue.put_nowait() # 去取值,如果没有值,直接报错
res=queue.get_nowait() #查看这个queue是否满
queue.full()
#查看queue是否是空的
queue.empty() # 查看queue中有几个值
queue.qsize()
'''
 

2 通过Queue实现进程间通信


from multiprocessing import Process,Queue


import os
import time

def task(queue):
print('我这个进程%s开始放数据了'%os.getpid())
time.sleep(10)
queue.put('lqz is handsome')
print('%s我放完了' % os.getpid())


if __name__ == '__main__':
#不写数字,表示可以任意长度
queue=Queue()
p=Process(target=task,args=[queue,])
p.start()

res=queue.get() #会卡在这
print(res)
 

3 批量生产数据放入Queue再批量取出


from multiprocessing import Process,Queue
import os

def get_task(queue):
res=queue.get()
print('%s这个进程取了数据:%s'%(os.getpid(),res))


def put_task(queue):
queue.put('%s:放了数据'%os.getpid())

if __name__ == '__main__':
queue=Queue(1)
p1=Process(target=put_task,args=[queue])
p2=Process(target=put_task,args=[queue])
p1.start()
p2.start()


p3=Process(target=get_task,args=[queue])
p4=Process(target=get_task,args=[queue])
p3.start()
p4.start()




4 生产者消费者模型(重点)

from multiprocessing import Process, Queue
# import os
#
# import time
# import random
# def producer(queue):
# # 生产的东西,放到Queue中
# for i in range(10):
# data = '%s这个厨师,整了第%s个包子' % (os.getpid(), i)
# print(data)
# # 模拟一下延迟
# time.sleep(random.randint(1,3))
# queue.put('第%s个包子'%i)
#
#
# def consumer(queue):
# # 消费者从queue中取数据,消费(吃包子)
# while True:
#
# res=queue.get()
# # 模拟一下延迟
# time.sleep(random.randint(1, 3))
# print('%s这个消费者,吃了%s'%(os.getpid(),res))
#
#
#
# if __name__ == '__main__':
# queue=Queue(3)
# p=Process(target=producer,args=[queue,])
# p.start()
#
# p1=Process(target=consumer,args=[queue,])
# p1.start()


###### 改良(生产者以及不生产东西了,但是消费者还在等着拿)
# import os
#
# import time
# import random
# def producer(queue):
# # 生产的东西,放到Queue中
# for i in range(10):
# data = '%s这个厨师,整了第%s个包子' % (os.getpid(), i)
# print(data)
# # 模拟一下延迟
# time.sleep(random.randint(1,3))
# queue.put('第%s个包子'%i)
# # 生产完了,在queue中放一个None
# queue.put(None)
#
#
# def consumer(queue):
# # 消费者从queue中取数据,消费(吃包子)
# while True:
#
# res=queue.get()
# if not res:break # 如果去到空,说明打烊了(生产者不生产了),退出
# # 模拟一下延迟
# time.sleep(random.randint(1, 3))
# print('%s这个消费者,吃了%s'%(os.getpid(),res))
#
#
#
# if __name__ == '__main__':
# queue=Queue(3)
# p=Process(target=producer,args=[queue,])
# p.start()
#
# p1=Process(target=consumer,args=[queue,])
# p1.start()


#### 把put none 放在主进程中执行
import os

# import time
# import random
# def producer(queue):
# # 生产的东西,放到Queue中
# for i in range(10):
# data = '%s这个厨师,整了第%s个包子' % (os.getpid(), i)
# print(data)
# # 模拟一下延迟
# time.sleep(random.randint(1,3))
# queue.put('第%s个包子'%i)
#
#
#
# def consumer(queue):
# # 消费者从queue中取数据,消费(吃包子)
# while True:
#
# res=queue.get()
# if not res:break # 如果去到空,说明打烊了(生产者不生产了),退出
# # 模拟一下延迟
# time.sleep(random.randint(1, 3))
# print('%s这个消费者,吃了%s'%(os.getpid(),res))
#
#
#
# if __name__ == '__main__':
# queue=Queue(3)
# p=Process(target=producer,args=[queue,])
# p.start()
#
# p1=Process(target=consumer,args=[queue,])
# p1.start()
#
# # 如果把put None放在这,会有问题
# # 主进程会先执行这句话,消费进程读到None,直接结束,生产者进程没有结束,于是生产一直在生产,消费已经不消费了
# # 直到Queue满了,就一直卡在这了
# # queue.put(None)
#
# ### 现在就要放在这,你把问题解决
# p.join()
# queue.put(None)


5 多个生产者多个消费者的生产者消费者模型

# 多个生产者在生产,多个消费者在消费
# import time
# import random
# def producer(queue,food):
# # 生产的东西,放到Queue中
# for i in range(10):
# data = '%s这个厨师,做了第%s个%s' % (os.getpid(), i,food)
# print(data)
# # 模拟一下延迟
# time.sleep(random.randint(1,3))
# queue.put('第%s个%s'%(i,food))
#
#
# def consumer(queue):
# # 消费者从queue中取数据,消费(吃包子)
# while True:
# res=queue.get()
# if not res:break # 如果去到空,说明打烊了(生产者不生产了),退出
# # 模拟一下延迟
# time.sleep(random.randint(1, 3))
# print('%s这个消费者,吃了%s'%(os.getpid(),res))
#
#
#
# if __name__ == '__main__':
# queue=Queue(3)
# ##起了三个生产者
# p1=Process(target=producer,args=[queue,'包子'])
# p2=Process(target=producer,args=[queue,'骨头'])
# p3=Process(target=producer,args=[queue,'泔水'])
# p1.start()
# p2.start()
# p3.start()
#
#
#
# # 起了两个消费者
# c1=Process(target=consumer,args=[queue,])
# c2=Process(target=consumer,args=[queue,])
# c1.start()
# c2.start()
#
# ##等三个生产者都生产完,放三个None
# p1.join()
# p2.join()
# p3.join()
# queue.put(None)
# queue.put(None)
# queue.put(None)

##如果消费者多,比生产者多出来的消费者不会停

import time
import random


def producer(queue, food,name):
# 生产的东西,放到Queue中
for i in range(10):
data = '%s:这个厨师,做了第%s个%s' % (name, i, food)
print(data)
# 模拟一下延迟
time.sleep(random.randint(1, 3))
queue.put('第%s个%s' % (i, food))


def consumer(queue,name):
# 消费者从queue中取数据,消费(吃包子)
while True:
try:
res = queue.get(timeout=20)
# 模拟一下延迟
time.sleep(random.randint(1, 3))
print('%s这个消费者,吃了%s' % (name, res))
except Exception as e:
print(e)
break


if __name__ == '__main__':
queue = Queue(3)
##起了三个生产者
p1 = Process(target=producer, args=[queue, '包子','egon'])
p2 = Process(target=producer, args=[queue, '骨头','lqz'])
p3 = Process(target=producer, args=[queue, '泔水','jsason'])
p1.start()
p2.start()
p3.start()

# 起了两个消费者
c1 = Process(target=consumer, args=[queue, '孟良'])
c2 = Process(target=consumer, args=[queue,'池劲涛' ])
c3 = Process(target=consumer, args=[queue,'池劲涛' ])
c4 = Process(target=consumer, args=[queue,'池劲涛' ])
c1.start()
c2.start()
c3.start()
c4.start()

6 进程间数据共享(了解)


from multiprocessing import Process,Manager,Lock

# 魔法方法:类内以__开头__结尾的方法,都叫魔法方法,某种情况下会触发它的执行
'''
__init__ :类()触发
__new__:
__getattr__
__setattr__
__getitem__
__setitem__

'''

# def task(dic,lock):
# # lock.acquire()
# # dic['count']-=1
# # lock.release()
# with lock:
# dic['count'] -= 1
#
# if __name__ == '__main__':
# lock = Lock()
# with Manager() as m:
# # 如果直接定义dict,这个dict在多个进程中其实是多份,进程如果改,只改了自己的
# #如果定义的是m.dict({'count': 100}),多个进程之间就可以共享这个数据
# dic = m.dict({'count': 100})
#
# p_l = []
# for i in range(100):
# p = Process(target=task, args=(dic, lock))
# p_l.append(p)
# p.start()
# for p in p_l:
# p.join()





def task(dic,lock):
with lock:
dic['count'] -= 1

if __name__ == '__main__':
lock = Lock()
dic={'count':100}
p_l = []
for i in range(100):
p = Process(target=task, args=(dic, lock))
p_l.append(p)
p.start()
for p in p_l:
p.join()



print(dic)

7 线程概念

如果把我们上课的过程看成一个进程的话,那么我们要做的是耳朵听老师讲课,手上还要记笔记,脑子还要思考问题,这样才能高效的完成听课的任务。而如果只提供进程这个机制的话,上面这三件事将不能同时执行,同一时间只能做一件事,听的时候就不能记笔记,也不能用脑子思考,这是其一;如果老师在黑板上写演算过程,我们开始记笔记,而老师突然有一步推不下去了,阻塞住了,他在那边思考着,而我们呢,也不能干其他事,即使你想趁此时思考一下刚才没听懂的一个问题都不行,这是其二


#进程是资源分配的最小单位,线程是CPU调度的最小单位。每一个进程中至少有一个线程。


from threading import Thread
from queue import Queue
import os
import time def task():
time.sleep(3)
print('我是子线程执行的')
print(os.getpid()) if __name__ == '__main__':
# 启动线程 ctime = time.time()
t = Thread(target=task)
t.start()
# task()
time.sleep(3)
print(os.getpid())
print(time.time() - ctime)

总结

1 Queue:进程间通信
-实例化得到一个对象
-对象.put()
-对象.get() 2 生产者消费者模型
3 通过共享变量来共享数据(进程间数据是隔离的)
-Manager实现多个进程操作同一个变量
-加锁
4 线程,每个进程下最少有一个线程,cup调度的最小单位
5 python如何开启线程

03:进程Queue --- 生产者消费者模型的更多相关文章

  1. python 进程锁 生产者消费者模型 队列 (进程其他方法,守护进程,数据共享,进程隔离验证)

    #######################总结######### 主要理解 锁      生产者消费者模型 解耦用的   队列 共享资源的时候 是不安全的 所以用到后面的锁 守护进程:p.daem ...

  2. Learning-Python【34】:进程之生产者消费者模型

    一.什么是生产者消费者模型 生产者指的是生产数据的任务,消费者指的是处理数据的任务,在并发编程中,如果生产者处理速度很快,而消费者处理速度很慢,那么生产者就必须等待消费者处理完,才能继续生产数据.同样 ...

  3. 5 并发编程-(进程)-队列&生产者消费者模型

    1.队列的介绍 进程彼此之间互相隔离,要实现进程间通信(IPC),multiprocessing模块支持两种形式:队列和管道,这两种方式都是使用消息传递的 创建队列的类(底层就是以管道和锁定的方式实现 ...

  4. day35——生产者消费者模型、线程

    day35 进程:生产者消费者模型 编程思想,模型,设计模式,理论等等,都是交给你一种编程的方法,以后你遇到类似的情况,套用即可 生产者消费者模型的三要素 生产者:产生数据的 消费者:接收数据做进一步 ...

  5. Python学习笔记——进阶篇【第九周】———线程、进程、协程篇(队列Queue和生产者消费者模型)

    Python之路,进程.线程.协程篇 本节内容 进程.与线程区别 cpu运行原理 python GIL全局解释器锁 线程 语法 join 线程锁之Lock\Rlock\信号量 将线程变为守护进程 Ev ...

  6. python并发编程之多进程(二):互斥锁(同步锁)&进程其他属性&进程间通信(queue)&生产者消费者模型

    一,互斥锁,同步锁 进程之间数据不共享,但是共享同一套文件系统,所以访问同一个文件,或同一个打印终端,是没有问题的, 竞争带来的结果就是错乱,如何控制,就是加锁处理 part1:多个进程共享同一打印终 ...

  7. python开发进程:互斥锁(同步锁)&进程其他属性&进程间通信(queue)&生产者消费者模型

    一,互斥锁,同步锁 进程之间数据不共享,但是共享同一套文件系统,所以访问同一个文件,或同一个打印终端,是没有问题的, 竞争带来的结果就是错乱,如何控制,就是加锁处理 part1:多个进程共享同一打印终 ...

  8. Python守护进程、进程互斥锁、进程间通信ICP(Queue队列)、生产者消费者模型

    知识点一:守护进程 守护进程:p1.daemon=True 守护进程其实就是一个“子进程“,守护=>伴随 守护进程会伴随主进程的代码运行完毕后而死掉 进程:当父进程需要将一个任务并发出去执行,需 ...

  9. 进击的Python【第九章】:paramiko模块、线程与进程、各种线程锁、queue队列、生产者消费者模型

    一.paramiko模块 他是什么东西? paramiko模块是用python语言写的一个模块,遵循SSH2协议,支持以加密和认证的方式,进行远程服务器的连接. 先来个实例: import param ...

随机推荐

  1. Day003 +和字符串使用的问题

    先看一段代码 int a=10; int b=20; System.out.println(""+a+b); System.out.println(a+b+"" ...

  2. Maven不扫描java文件夹下的配置文件解决办法

    <build> <resources> <resource> <directory>src/main/java</directory> &l ...

  3. ThinkPHP5查询-select与find理解

    出现问题 在tp5框架中判断select查询结果是否为空时,无论查询条件是否满足,判断查询结果都不为空 解析问题 select查询的是多条数据,若查询数据为空,则返回一个空的二维数组 array(ar ...

  4. php 解析富文本编辑器中的hmtl内容,富文本样式正确输出

    说明:富文本编辑器中的内容在直接获获取后需要解析以后才能在页面中正确显示 我在后端这样处理: $content = htmlspecialchars_decode($info['intro']); h ...

  5. 浅谈持续集成(CI)、持续交付(CD)、持续部署(CD)

    CI/CD是实现敏捷和Devops理念的一种方法,具体而言,CI/CD 可让持续自动化和持续监控贯穿于应用的 整个生命周期(从集成和测试阶段,到交付和部署).这些关联的事务通常被统称为"CI ...

  6. MySQL中几种常见的日志

    前言: 在 MySQL 系统中,有着诸多不同类型的日志.各种日志都有着自己的用途,通过分析日志,我们可以优化数据库性能,排除故障,甚至能够还原数据.这些不同类型的日志有助于我们更清晰的了解数据库,在日 ...

  7. Python自动扫描出微信不是好友名单

    前言 最近找几个老友准备聊天发现几个已经被删除好友名单,做为潜水党多年的我已经不知道成为多少人的黑名单,但是好友列表却依然有不是好友的名单,面对庞大的好友数量想要清除谈何容易.虽然可以发消息给所有人, ...

  8. java并发编程:深入了解synchronized

    简介 synchronized是Java语言的关键字,可用来给对象和方法或者代码块加锁,当它锁定一个方法或者一个代码块的时候,同一时刻最多只有一个线程执行这段代码.同时它还保证了共享变量的内存可见性. ...

  9. Spec2006使用说明

    Spec2006使用说明 五 10 十月 2014 By penglee 工具介绍 SPEC CPU 2006 benchmark是SPEC新一代的行业标准化的CPU测试基准套件.重点测试系统的处理器 ...

  10. vimdiff env.txt export.txt set.txt

    1. 环境变量 简单理解了变量的概念,就很容易理解环境变量了.环境变量的作用域比自定义变量的要大,如 Shell 的环境变量作用于自身和它的子进程.在所有的 UNIX 和类 UNIX 系统中,每个进程 ...