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. 【hugo】- hugo 博客 添加鼠标单击特效

    hugo 博客 监听鼠标点击事件,添加动画效果 js下载 链接:https://pan.baidu.com/s/1SZu76WdEXRxLCfqJ2lbbtQ 密码:r056 移入hugo博客中 打开 ...

  2. JVM虚拟机 类加载过程与类加载器

    目录 前言 类的生命周期 类加载过程 加载 连接 验证 准备 解析 初始化 类加载器 三大类加载器 双亲委派模型 概念 为什么要使用双亲委派模型 源码分析 反双亲委派模型 参考 前言 类装载器子系统是 ...

  3. Vue.js源码解析-从scripts脚本看vue构建

    目录 1. scripts 脚本构建 1.1 dev 开发环境构建过程 1.1.1 配置文件代码 1.1.2 如何进行代码调试? 1.2 build 生产环境构建过程 1.2.1 scripts/bu ...

  4. pass在if中

    pass在if中是停止if成立后的操作. 如 num=1 while num<=100: if num==50: pass        #当作先占位 elif num>=60 and n ...

  5. （原创）高DPI适配经验系列：（三）字体与字号、缩放锚点

    一.前言 程序最基本的元素,就是文本,也就是字体.如果程序未进行高DPI的适配,最直观的感受便是字体的模糊.所以本篇便来说一下高DPI适配中的字体问题. 高DPI的适配,简单来说便是便是根据不同的DP ...

  6. COS 数据湖最佳实践：基于 Serverless 架构的入湖方案

    01 前言 数据湖(Data Lake)概念自2011年被推出后,其概念定位.架构设计和相关技术都得到了飞速发展和众多实践,数据湖也从单一数据存储池概念演进为包括 ETL 分析.数据转换及数据处理的下 ...

  7. 二进制部署K8S-2集群部署

    二进制部署K8S-2集群部署 感谢老男孩教育王导的公开视频,文档整理自https://www.yuque.com/duduniao/k8s. 因为在后期运行容器需要有大量的物理硬件资源使用的环境是用的 ...

  8. 实例：使用playbook实现httpd安装、配置、以及虚拟主机的配置

    一.安装环境配置 1.在控制节点给受控主机配置本地仓库文件 [root@ansible ~]# vim /etc/yum.repos.d/dvd.repo [AppStream] name=appst ...

  9. CentOS 7 设置默认进入字符界面

    CentOS 7 设置默认进入字符界面原创阳阳唐 最后发布于2018-10-18 10:12:51 阅读数 3363 收藏展开准备修改之前安装的centos7的默认启动方式,安装时是图形用户界面,想让 ...

  10. Linux进阶之链路聚合

    CentOS7用命令配置链路聚合 链路聚合是一个计算机网络术语,将多个物理端口汇聚在一起,形成一个逻辑端口,以实现出入流量在各成员端口的负荷分担,交换机根据用户配置的端口负荷分担策略决定网络封包从哪个 ...