zoukankan      html  css  js  c++  java
  • python网络编程 day33 网络编程——进程拾遗,互斥锁(重要)生产者消费者模型

    一、内容回顾

    • 概念

      • 同步阻塞 :调用一个函数需要等待这个函数的执行结果,并且在执行这个给函数的过程中CPU不工作 # input('>>>>')

      • 同步非阻塞:调用一个函数需要等待这个函数的执行结果,并且在执行这个给函数的过程中CPU工作 # ret = eva('1+2-3+4-5+6')

      • 异步非阻塞:调用一个函数不需要等待这个函数的结果,并且在执行这个函数的过程中,CPU工作 # start()

      • 异步阻塞 :调用一个函数不需要等待这个函数的结果,并且在执行这个函数的过程中,CPU不工作

    • 进程的三状态图

    1611278644554

    • 进程的调度算法

      • 先来先服务

      • 短作业优先

      • 分时的概念

      • 多级反馈算法(包含了上面三个)

    • 进程的开启和关闭

      • 父进程开启了子进程

      • 父进程要负责给子进程回收子进程结束后的资源

    • join 等待子进程执行完后,在执行主进程内的内容

     

    二、今日内容

    1、Process类拾遗

    • 开启进程的另一中方法

      • 继承Process类,并实现Process类的同名方法:run()

    • Process类的一些其他方法属性

      • p.pid 子进程的pid

      • p.join

      • p.ident 和p.pid一样

      • p.name 子进程的名字

      • p.terminate() 强制结束一个子进程 异步非阻塞

      • p.is_alive() 查看进程是否还存在 返回True或False

    • 守护进程

      • 子进程会等待所有的子进程结束,是为了回收子进程的资源

      • daemon = True 表示设置子进程是一个守护进程

      • 守护进程会等待主进程的代码执行结束之后再结束,而不是等待整个主进程结束.

      • 主进程的代码什么时候结束,守护进程就什么时候结束,和其他子进程的执行进度无关

        import time
        from multiprocessing import Process

        def son1():
           while True:
               print('--> in son1')
               time.sleep(1)

        def son2():   # 执行10s
           for i in range(10):
               print('in son2')
               time.sleep(1)

        if __name__ == '__main__':    # 3s
           p1 = Process(target=son1)
           p1.daemon = True    # 表示设置p1是一个守护进程
           p1.start()
           p2 = Process(target=son2,)
           p2.start()
           time.sleep(3)
           print('in main')

         

    2、进程同步 ——lock锁 非常重要

    • 互斥锁:不能再同一个进程中i连续acquire

    • with lock: # 代替acquire和release 并且在此基础上做一些异常处理,保证即便一个进程的代码出错退出了,也会归还钥匙

     

    3、队列

    • 进程之间数据是隔离的

    • 进程之间通信 Inter Process Communication (IPC)

      • 基于文件:同一台机器上的多个进程之间通信

        • 基于socket文件级别的通信来完成数据之间传递

      • 基于网络:同一台机器或者多个机器之间的多进程之间通信

        • 第三方模块

        • memache

        • redis

        • rabbitmq

        • kafka

    • Queue

      队列:先进先出

    • 生产者消费者模型

      • 爬虫的时候

      • 分布式操作: celery 框架:框架本质是两个大的生产者消费者模型

      • 本质:就是让生产数据和消费数据的效率达到平衡并且最大化效率

        #生产者消费者模型
        import time
        from multiprocessing import Queue,Process
        def consumer(q,name):
           while True:
               food = q.get()
               if food:
                   print(f'{name}吃了一个{food}')
               else:
                   break
        def produces(q,name,food):
           for i in range(20):
               print(f'{name}生产了第 {i} 个{food}')
               time.sleep(1)
               q.put(food)

        if __name__ == '__main__':
           q = Queue()
           p = Process(target=produces, args=(q, '大壮', '馒头'))
           p1 = Process(target=produces, args=(q,'wusir','包子'))
           p2 = Process(target=consumer,args=(q,'taibai',))
           p3 = Process(target=consumer, args=(q,'alex'))
           p.start()
           p1.start()
           p2.start()
           p3.start()
           p.join()
           p1.join()
           q.put(None)
           q.put(None)
      •  

  • 相关阅读:
    Salesforce的数据权限机制
    Java并发编程:Java内存模型和volatile
    Java并发编程:synchronized和锁优化
    权限控制和OAuth
    MySQL explain详解
    ConcurrentHashMap源码阅读
    HashMap源码阅读
    领域驱动设计的基础知识总结
    Chris Richardson微服务翻译:重构单体服务为微服务
    Chris Richardson微服务翻译:微服务部署
  • 原文地址:https://www.cnblogs.com/iaoyuyuyuhuanghuang/p/14315469.html
Copyright © 2011-2022 走看看