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. The content of element type "web-app" must match "(icon?,display- name?,description?,distributable?,context-param*,filter*,filter-mapping*,listener*,servlet*,servlet- mapping*,session-config?

    web.xml头部配置: <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE web-app P ...

  2. 将本地代码上传到云效git存放

    前提已开通云效账号,然后进行云效首页的研发---代码 创建git组 创建git库 生成https://code.aliyun.com/test-demo1/v1的git库 准备将本地的test-dem ...

  3. 死磕Spring之AOP篇 - Spring 事务详解

    该系列文章是本人在学习 Spring 的过程中总结下来的,里面涉及到相关源码,可能对读者不太友好,请结合我的源码注释 Spring 源码分析 GitHub 地址 进行阅读. Spring 版本:5.1 ...

  4. 关于Aborted connection告警日志的分析

    前言: 有时候,连接MySQL的会话经常会异常退出,错误日志里会看到"Got an error reading communication packets"类型的告警.本篇文章我们 ...

  5. STL实现的底层数据结构简介

    STL实现的底层数据结构简介 C++ STL 的实现: 1.vector  底层数据结构为数组 ,支持快速随机访问 2.list    底层数据结构为双向链表,支持快速增删 3.deque   底层数 ...

  6. computed和watch的区别

    严格上来说,计算属性能够实现的效果,watch都可以实现.只是有时候watch写起来比较麻烦. 但是watch能够实现的效果computed不一定能够实现. 1:watch内部可以包含异步操作,com ...

  7. Java并发-显式锁篇【可重入锁+读写锁】

    作者:汤圆 个人博客:javalover.cc 前言 在前面并发的开篇,我们介绍过内置锁synchronized: 这节我们再介绍下显式锁Lock 显式锁包括:可重入锁ReentrantLock.读写 ...

  8. nosql数据库之Redis持久化、备份和主从配置

    一.持久化方式 Redis提供了两种数据备份的方式,一种是RDB,另外一种是AOF.   RDB AOF 开启/关闭 开启:默认开启:关闭:把配置文件中所有的save注释就是关闭了 开启:在配置文件中 ...

  9. 11.14 mii-tool：管理网络接口的状态

    mii-tool命令用于查看.管理网络接口,默认情况下网卡的状态是自动协商的,但是有时也会出现不正常的情况,可以使用mii-tool进行调整. mii-tool [option] [interface ...

  10. 内部排序算法（交换排序，插入排序）注意点（C语言实现）

    对于算法思想的理解可以参考下面的这个帖子,十大经典排序算法(动图演示) - 一像素 - 博客园,因为算法的逻辑和数学很像,相应的基础资料一般也能在网上找到,所以,本帖子这谈论一些重要的注意点,其他人讲 ...