生产者消费者模型,管道,进程之间共享内存,进程池

课程回顾:

  并行:在同一时间点上多个任务同时执行

  并发:在同一时间段上多个任务同时执行

  进程的三大基本状态:

    就绪状态:所有进程需要的资源都获取到了,除了CPU

    执行状态:获取到了所有资源包括CPU,进程处于运行状态

    阻塞状态:程序停滞不在运行,放弃CPU,进程此时处于内存里

  什么叫进程?

    正在运行的程序

    有代码段,数据段,PCB(进程控制块)

  进程是资源分配的基本单位.

  进程之间能不能直接通信?

    正常情况下,多进程之间是无法进行通信的.因为每个进程都有自己独立的空间

  锁: 为了多进程通信时,保护数据的安全性

    一把锁配一把钥匙

    l = Lock()

    l.acquire()

    l.release()

  信号量:

    一把锁配多把钥匙

    sem = Semaphore(num)    ### num 钥匙的数量

  事件:

    e = Event()

    e.is_set()  返回一个bool值

    e.wait()    阻塞和非阻塞

    e.set()    把is_set的bool值变为True

    e.clear()    把is_set的bool值变为False

今日内容:

    1.生产者消费者模型

      主要是为解耦

      借助对列来实现生产者消费者模型

      

      栈:先进后出(First In Last Out)    简称:  FILO

      队列:先进先出(First In First Out)   简称:  FIFO

    

    import queue #不能进行多线程之间的数据模型

      (1)from multiprocessing import Queue  借助Queue解决生产者消费者模型

        队列是安全的.

        q = Queue(num)

        #num : 队列的最大长度

        q.get()#阻塞等待获取数据,如果有数据直接获取,如果没有数据,阻塞等待

        q.put()#阻塞,如果可以继续往队列中放数据,就直接放,不能放就阻塞等待

        q.get_nowait()#不阻塞,如果有数据直接获取,如果没有数据就报错

        q.put_nowait()#不阻塞,如果可以继续往队列中放数据,就直接放,不能放就报错

      (2)from multiprocessing import JoinableQueue  #可连接的队列

        JoinableQueue是继承Queue,所以可以使用Queue中的方法

        并且JoinableQueue又多了两个方法

        q.join()  用于生产者,等待 q.task_done的返回结果,通过返回结果,生产者就能获得消费者消费了多少个数据

        q.task_done  用于消费者,是指每消费队列中一个数据,就给join返回一个标识.

   2.管道(了解)

     from multipressing import Pipe

     con1,con2 = Pipe()

     管道是不安全的.

     管道是用于多进程之间通信的一种方式.

     如果在单进程中使用管道:  那么就是con1收数据,就是con2发数据.

                    如果是con1发数据,就是con2收数据

     如果在多进程中使用管道,那么就必须是  父进程使用con1收,子进程就必须使用con2发

                       父进程使用con1发,子进程就必须使用con2收

                       父进程使用con2收,子进程就必须使用con1发

                       父进程使用con2发,子进程就必须使用con1收

     在管道中有一个著名的错误叫做EOFError.是指,父进程中如果关闭了发送端,子进程还继续接收数据,那么就会引发EOFError.

   3.进程之间的共享内存

     from multiprocessing import Manager,Value

     m = Manager()

     num = m.dict({键:值})

     num = m.list([1,2,3])

   4.进程池

    进程池:一个池子,里面有固定数量的进程.这些进程一直处于待命状态,一旦有任务来,马上就有进程去处理

    因为在实际业务中,任务量是有多有少的,如果任务量特别的多,不可能要开对应那么多的进程数

    开启那么多进程首先就需要消耗大量的时间让操作系统来为你管理它,其次还需要消耗大量时间让cpu帮你调度它.

    进程池还会帮程序员去管理进程池中的进程

    from multiprocessing import Pool

    p = Pool(os.cpu_count() + 1)

    进程最好开p个   p就是cpu核数加上1

    

    进程池有三个方法:

      map(func,iterable)

      func: 进程池中的进程执行的任务函数

      iterable: 可迭代对象,是吧可迭代对象中的每一个元素一次传给任务函数当参数

    apply(func,args=()):  同步的效率,也就是说池中的进程一个一个的去执行任务

      func:进程池中的进程执行的任务函数

      args:可迭代对象型的参数,是传给任务函数的参数

      同步处理任务时,不需要close和join

      同步处理任务时,进程池中的所有进程都是普通进程(主进程需要等待其执行结束)

    apply_async(func,args=(),callback=None):  异步的效率,也就是说池中的进程都一次性都去执行任务

    func:进程池中的进程执行的任务函数

    args:可迭代带对象型的参数,是传给任务函数的参数

    callback:回调函数,就是说每当进程池中有进程处理完任务了,返回的结果可以交给函数,由回调函数进行进一步的处理,回调函数只有异步才有,同步是没有的

    异步处理任务时,进程池中的所有进程都是守护进程(主进程代码执行完毕守护进程就结束)

    异步处理任务时,必须加上close和join

原文地址:https://www.cnblogs.com/jerry-hou/p/11999823.html

时间: 2024-08-15 02:29:11

生产者消费者模型,管道,进程之间共享内存,进程池的相关文章

5 并发编程--队列&生产者消费者模型

1.队列的介绍 进程彼此之间互相隔离,要实现进程间通信(IPC),multiprocessing模块支持两种形式:队列和管道,这两种方式都是使用消息传递的 创建队列的类(底层就是以管道和锁定的方式实现): Queue([maxsize]):创建共享的进程队列,Queue是多进程安全的队列,可以使用Queue实现多进程之间的数据传递. 参数介绍: maxsize是队列中允许最大项数,省略则无大小限制. 但需要明确: 1.队列内存放的是消息而非大数据 2.队列占用的是内存空间,因而maxsize即便

35 守护进程 互斥锁 IPC 共享内存 的方式 生产者消费者模型

守护进程 进程:一个正在运行的程序. 主进程创建守护进程: 1.守护进程会在主进程代码执行结束后就终止, 2.守护进程内无法再开启子进程,否则抛出异常. 注意:进程之间是互相独立的,主进程代码运行结束,守护进程随即终止. 例子:from multiprocessing import Processimport time def task(): print('老了....') time.sleep(2) print('睡了一会..') if __name__ == '__main__': prin

joinablequeue模块 生产者消费者模型 Manager模块 进程池 管道

一.生产者消费者 主要是为解耦(借助队列来实现生产者消费者模型) import queue  # 不能进行多进程之间的数据传输 (1)from multiprocessing import Queue    借助Queue解决生产者消费者模型,队列是安全的. q = Queue(num) num :为队列的最大长度 q.get() # 阻塞等待获取数据,如果有数据直接获取,如果没有数据,阻塞等待 q.put() # 阻塞,如果可以继续往队列中放数据,就直接放,不能放就阻塞等待 q.get_now

进程 >> 互斥锁、队列与管道、生产者消费者模型

目录 1.互斥锁 2.队列与管道 3.生产者消费者模型(Queue) 4.生产者消费者模型(JoinableQueue) 1.互斥锁 首先导入Lock模块 实例化一把锁 但是每次生成子进程的时候都会重新实例化一把锁,我们的目的是想让所有的子进程使用同一把锁,所以需要把锁传递给子进程在使用 锁名.acquire():开锁->所有子进程开始抢位置 锁名.release():关锁->位置排好了,开始执锁起来执行. join与互斥锁的区别:join是把所有的子进程代码变为串行的,而互斥锁则可以规定那几

13.1 多线程操作共享内存、生产者消费者模型、多线程服务器框架

生产者消费者模型如下: 程序如下: 1 #include <unistd.h> 2 #include <sys/types.h> 3 4 #include <stdlib.h> 5 #include <stdio.h> 6 #include <errno.h> 7 #include <string.h> 8 9 #include <pthread.h> 10 11 int g_Count = 0; 12 13 int nN

python并发编程之多进程(二):互斥锁(同步锁)&amp;进程其他属性&amp;进程间通信(queue)&amp;生产者消费者模型

一,互斥锁,同步锁 进程之间数据不共享,但是共享同一套文件系统,所以访问同一个文件,或同一个打印终端,是没有问题的, 竞争带来的结果就是错乱,如何控制,就是加锁处理 part1:多个进程共享同一打印终端 #并发运行,效率高,但竞争同一打印终端,带来了打印错乱 from multiprocessing import Process import os,time def work(): print('%s is running' %os.getpid()) time.sleep(2) print('

13 join 线程锁之Lock\Rlock\信号量 将线程变为守护进程 Event事件  queue队列 生产者消费者模型 Queue队列 开发一个线程池

本节内容 操作系统发展史介绍 进程.与线程区别 python GIL全局解释器锁 线程 语法 join 线程锁之Lock\Rlock\信号量 将线程变为守护进程 Event事件 queue队列 生产者消费者模型 Queue队列 开发一个线程池 进程 语法 进程间通讯 进程池 操作系统发展史 手工操作(无操作系统) 1946年第一台计算机诞生--20世纪50年代中期,还未出现操作系统,计算机工作采用手工操作方式. 手工操作程序员将对应于程序和数据的已穿孔的纸带(或卡片)装入输入机,然后启动输入机把

进击的Python【第九章】:paramiko模块、线程与进程、各种线程锁、queue队列、生产者消费者模型

一.paramiko模块 他是什么东西? paramiko模块是用python语言写的一个模块,遵循SSH2协议,支持以加密和认证的方式,进行远程服务器的连接. 先来个实例: 1 import paramiko 2 # 创建SSH对象 3 ssh = paramiko.SSHClient() 4 5 # 允许连接不在know_hosts文件中的主机 6 ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) 7 # 连接服务器 8 ss

python—day29 守护进程、互斥锁、模拟抢票、IPC通信机制、生产者消费者模型

1.守护进程: 什么是守护进程,假如你是皇帝,每日每夜守护你的就是太监,守护进程就相当于太监,当皇帝驾崩后太监也需要陪葬,所以守护进程当父进程销毁时就一起销毁: 1 from multiprocessing import Process 2 3 import time 4 5 def task(name): 6 7 time.sleep(0.5) 8 print('%s' %name) 9 10 11 if __name__ == '__main__': 12 p = Process(targe