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, 'a'])

    c2 = Process(target=consumer, args=[queue,'b' ])

    c3 = Process(target=consumer, args=[queue,'c' ])

    c4 = Process(target=consumer, args=[queue,'d' ])

    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)

day19.进程通信与线程1的更多相关文章

  1. java多线程上篇（三） -- 进程通信和线程死锁简单介绍

    进程通信指的是进程间的信息交换 ,IPC(Inter-Process Communication,进程间通信) 进程通信就相当于一种工作方式.沟通形式,进程通信主要指的就是操作系统提供的进程通信工具( ...

  2. day36——死锁、递归锁、信号量、GIL、多线程实现socket通信、线程池和进程池

    day36 死锁现象与递归锁 死锁现象 是指两个或两个以上的进程或线程在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外力作用,它们都将无法推进下去.此时称系统处于死锁状态或系统产生了死锁,这 ...

  3. Windows线程+进程通信

    一 Windows线程进程 1)定义 按照MS的定义, Windows中的进程简单地说就是一个内存中的可执行程序, 提供程序运行的各种资源. 进程拥有虚拟的地址空间, 可执行代码, 数据, 对象句柄集 ...

  4. Android 进程通信机制之 AIDL

    什么是 AIDL AIDL 全称 Android Interface Definition Language,即 安卓接口描述语言.听起来很深奥,其实它的本质就是生成进程间通信接口的辅助工具.它的存在 ...

  5. Linux下进程通信的八种方法

    Linux下进程通信的八种方法:管道(pipe),命名管道(FIFO),内存映射(mapped memeory),消息队列(message queue),共享内存(shared memory),信号量 ...

  6. 进程通信之一 使用WM_COPYDATA C++及C#实现（转）

    进程间通信最简单的方式就是发送WM_COPYDATA消息.本文提供C++及C#程序相互通信的二种实现方式.这样消息的接收端可以用C++实现,发送端可以用C++或C#实现.     发送WM_COPYD ...

  7. 【Chromium中文文档】跨进程通信 (IPC)

    跨进程通信 (IPC) 转载请注明出处:https://ahangchen.gitbooks.io/chromium_doc_zh/content/zh//General_Architecture/I ...

  8. C#通过接口与线程通信(捕获线程状态)介绍

    C#通过接口与线程通信(捕获线程状态)介绍 摘要:本文介绍C#通过接口与线程通信(捕获线程状态),并提供简单的示例代码供参考. 提示:本文所提到的线程状态变化,并不是指线程启动.暂停.停止,而是说线程 ...

  9. 微端游戏启动器LAUNCHER的制作之MFC版一（序和进程通信）

    额...刚开始信誓旦旦说要写launcher制作的博客,还没写完就被抛到脑后了真是没毅力.最近把之前写的wpf的launcher改成了mfc版,遇到很多问题,写了三个星期才写完,好好记录一下吧.我也想 ...

随机推荐

  1. CSS中Position属性static、absolute、fixed、relative

    在html中网页可以看成一个立体的空间,一个完整的页面是由很多个页面堆积形成的,如下图所示   CSS中Position属性有四个可选值,它们分别是:static.absolute.fixed.rel ...

  2. yum安装MySQL8 - Centos8

    官方地址:https://dev.mysql.com/doc/refman/8.0/en/linux-installation-yum-repo.html 参考博客地址:https://www.jia ...

  3. 翻译：《实用的Python编程》02_06_List_comprehension

    目录 | 上一节 (2.5 collections模块) | 下一节 (2.7 对象模型) 2.6 列表推导式 一个常见的任务是处理列表中的项(译注:元素).本节介绍列表推导式,完成此任务的强大工具. ...

  4. iOS之CoreBluetooth

    思路 手机与设备间的通讯方式CoreBluetooth是比较常见且通用的.在iOS开发中需明晰以下几点 蓝牙4.0最多可联机7个设备,iPhone6以上都是蓝牙4.0 两台iPhone并不直接通过蓝牙 ...

  5. Get和Post请求方式

    Get和Post是两种不同的类型的请求. 它们主要有3点不同. 1.get请求通过浏览器地址栏传递表单数据.post请求通过form data 传递数据,不会通过地址栏. 2.get请求安全性较低,p ...

  6. 记一次Drone无法触发构建的问题

    问题 好巧不巧,当你晚上准备上线的时候,在下午临近下班的时候CI&CD工具出问题了,提交代码不能触发构建,不能上线了,Drone平台那边也下班了,正好CICD依赖的公司git仓库也出问题了(就 ...

  7. Elasticsearch核心技术（一）：Elasticsearch环境搭建

    磨刀不误砍柴工,要学习Elasticsearch,首先要搭建起来一套学习环境,本文为手把手教你在MacOS上面搭建Elasticsearch学习环境. 1.1 Elasticsearch安装 Elas ...

  8. JS时间格式转成字符串

    formatNumber = n => { n = n.toString(); return n[1] ? n : '0' + n }; // 时间格式化 formatTime = date = ...

  9. mysql内一些可以报错注入的查询语句

        一.exp() 取反参数 该函数简单来说就是,以e为底的对数,在当传递一个大于709的值时,函数exp()就会引起一个溢出错误,取反则可以导致很小的数值变得很大,比如说0 这样既可配合使用,e ...

  10. 漏洞复现-ActiveMq任意文件写入漏洞（CVE-2016-3088）

          0x00 实验环境 攻击机:Win 10 靶机也可作为攻击机:Ubuntu18 (docker搭建的vulhub靶场) 0x01 影响版本 未禁用PUT.MOVE等高危方法的ActiveM ...