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. JavaWeb——JDBC

    内容索引 1. JDBC基本概念 2. 快速入门 3. 对JDBC中各个接口和类详解 JDBC: 1. 概念:Java DataBase Connectivity Java 数据库连接, Java语言 ...

  2. redis 未授权访问（写公钥、写计划任务）

    写公钥 ssh-keygen -t rsa # 生成key (echo -e "\n\n"; cat id_rsa.pub; echo -e "\n\n") & ...

  3. MySQL数据迁移那些事儿

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

  4. copy函数与ostream_iterator、reverse_iterator

    #include <iostream> #include <iterator> #include <vector> int main() { using names ...

  5. 折腾Linux内核编译

    计网提高实验.指导书给的是远古版本2.6.39.2,轻易在某hub上找到下载地址 查表 看起来Ubuntu 11.04离得最近,遂下一个镜像 懒得上google检索了,编译准备先follow这篇博客试 ...

  6. 通俗易懂的JS之Proxy

    与掘金文章同步,地址:https://juejin.cn/post/6964398933229436935 什么是代理模式 引入一个现实生活中的案例 我们作为用户需要去如何评估一个房子的好坏.如何办理 ...

  7. KMP（The Knuth-Morris-Pratt Algorithm）

    本文代码来自于中国大学MOOC KMP课件下载 注释内容为自己理解,如有错误请评论,或者私信给我,谢谢 #include <stdio.h> #include "stdlib.h ...

  8. [bug] Shell：paths must precede expression

    参考 https://www.cnblogs.com/peter1994/p/7297656.html

  9. [Scala] 高级特性

    泛型 泛型类 1 package day0603 2 3 class GenericClassInt { 4 private var content:Int=10 5 def set(value:In ...

  10. Scala 安装与配置

    安装准备 由于 Scala 运行于 Java 平台,因此 Scala 之前需要确保系统安装 JDK Windows 中安装 Scala 1. 下载 scala-2.11.2.msi 安装包 点击安装文 ...