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. MySQL数据迁移那些事儿

    前言: 在平时工作中,经常会遇到数据迁移的需求,比如要迁移某个表.某个库或某个实例.根据不同的需求可能要采取不同的迁移方案,数据迁移过程中也可能会遇到各种大小问题.本篇文章,我们一起来看下 MySQL ...

  2. 中国排名前100的IC设计公司

    中国排名前100的IC设计公司 北京地区大唐微电子技术有限公司北京北大众志微系统科技有限责任公司北京中星微电子有限公司中国华大集成电路设计中心  北京中电华大电子设计有限责任公司  北京清华同方微电子 ...

  3. SprintBoot使用Validation

    1.为什么要使用Validation 在开发过程中有没有使用一堆的if来判断字段是否为空.电话号码是否正确.某个输入是否符合长度等对字段的判断.这样的代码可读性差,而且还不美观,那么使用Validat ...

  4. JAVA基础——包机制

    包机制 包的语法格式package pkg1[.pkg2[.pkg3...]] 一般利用 公司域名倒置 作为包名; 例如www.baidu.com,则建立报的名字com.baidu.www 一般不要让 ...

  5. 使用 yum-cron 自动更新 Linux系统

    使用 yum-cron 自动更新 Linux系统   Linux系统技术交流QQ群(1675603)验证问题答案:刘遄 我知道如何使用 yum 命令行 更新系统,但是我想用 cron 任务自动更新软件 ...

  6. Docker Swarm（八）滚动更新、回滚服务

    滚动更新.回滚服务 默认情况下, swarm一次只更新一个副本,并且两个副本之间没有等待时间,我们可以通过: # 定义并行更新的副本数量--update-parallelism# 定义滚动更新的时间间 ...

  7. shell基础之变量及表达式

    本节内容 1. shell变量简介 2. 定义变量 3. 使用变量 4. 修改变量的值 5. 单引号和双引号的区别 6. 将命令的结果赋值给变量 7. 删除变量 8. 变量类型 9. 特殊变量列表 1 ...

  8. STM32 中的CEC

    http://www.cnblogs.com/qdrs/articles/7645117.html

  9. NB-IOT技术与发展问答

    http://blog.csdn.net/pan0755/article/details/70145936 该部分分享的是物联网各垂直应用领域里,NB-IoT技术的部署,看看适合NB-IoT技术的垂直 ...

  10. CSS（2）盒子模型、定位浮动

    盒子模型 盒子模型:一个盒子中主要的属性就5个.width与height.padding.border.margin.盒子模型标准有两种为标准盒模型和IE盒模型.学习上以标准盒子模型为主 width和 ...