• python全栈开发 * 进程池,线程理论 ,threading模块 * 180727


    一.进程池  (同步 异步  返回值)
    缺点:
    开启进程慢
    几个CPU就能同时运行几个程序 进程的个数不是无线开启的
    应用:
    100个任务
    进程池
    如果必须用多个进程
    且是高计算型 没有IO型的程序
    希望并行 最充分的使用CPU
    示例:
    import os
            import time
            from multiprocessing import Pool
            def func1():
            time.sleep(2)
            print(os.getpid(),i)
    
            if __name__=="__main__"":
                p=Pool(5)
                for i in range(100):
                    p.apply_async(func=func1,args=(i,))
                p.close()
                p.join()
                print("主进程结束")
    

      


    1. 同步请求 获取返回值
     import os
        import time
        from multiprocessing import Pool,Process
    
    
        def haha(num):
            time.sleep(0.5)
            print(os.getpid(),num)
            return True
    
    
        if __name__=="__main__":
            p=Pool(5)
            for i in range(20):
               ret=p.apply(func=haha,args=(i,))
               print(ret)
    

     结果:一个一个的显示打印内容和返回值

     2. 异步请求   不获取返回值
    import os
        import time
        from multiprocessing import Pool,Process
    
    
        def haha(num):
            time.sleep(0.5)
            print(os.getpid(),num)
    
    
        if __name__=="__main__":
            p=Pool(5)
            for i in range(20):
                p.apply_async(func=haha,args=(i,))
            p.close()
            p.join()
    

     结果五个五个的显示打印内容


    3. 异步请求 获取返回值
    import os
        import time
        from multiprocessing import Pool,Process
        def haha(num):
            time.sleep(1)
            print(os.getpid(),num)
            return True
    
        if __name__=="__main__":
            r_l=[]
            p=Pool(5)
            for i in range(20):
                ret=p.apply_async(func=haha,args=(i,))
                r_l.append(ret)
            p.close()
            p.join()
            for ret in r_l:
                print(ret.get())
    

     结果 等待所有任务都执行完毕之后再统一获取结果

    异步 apply_async总结1:
    如果需要主进程等待,需要p.join
    但是join的行为是依赖close


    4. 异步请求 获取返回值 一个任务执行完毕之后就可以获取到一个结果(顺序是按照提交任务的顺序)

    import os
    import time
    from multiprocessing import Pool,Process
    def haha(num):
        time.sleep(5)
        print(os.getpid(),num)
        return True
    
    
    if __name__=="__main__":
        r_l=[]
        p=Pool(5)
        for i in range(20):
            ret=p.apply_async(func=haha,args=(i,))
            r_l.append(ret)
        for ret in r_l:
            print(ret.get())
    

     结果:一个任务执行完毕之后就可以获取到一个结果(顺序是按照提交任务的顺序)


    异步 apply_async总结2.
    如果函数有返回值:
        可以通过ret.get()来获取返回值
        但是如果一边提交一边获取返回值会让程序变成同步
        所以要想保留异步的效果应该将返回对象保存在列表中,所有任务提交完成之后再来取结果.
        这种方式也可以去掉join,来完成主进程的阻塞等待池中的任务执行完毕
         如果是异步的提交任务,那么任务提交之后进程池和主进程也异步了,
        主进程不会自动等待进程池中的任务执行完毕.
    
    二.回调函数
    import os
    import time
    import random
    from multiprocessing import Pool
    def haha(num):
        time.sleep(3)
        print("pid :",os.getpid(),num)
        return num
    def back(arg):
        print("callback :",os.getpid(),arg)
    
    
    if __name__=="__main__":
        print("主进程",os.getpid())
        p=Pool(5)
        for i in range(20):
            ret=p.apply_async(func=haha,args=(i,),callback=back)
        p.close()
        p.join()
       #需要回调函数的场景:进程池中任何一个任务一旦处理完了,就立即告知主进程:我好了额,你可以处理我的结果了。
       # 主进程则调用一个函数去处理该结果,该函数即回调函数
    进程总结:
    import os
    import time
    import random
    from multiprocessing import Pool
    def haha(num):
        time.sleep(3)
        print("pid :",os.getpid(),num)
        return num
    def back(arg):
        print("callback :",os.getpid(),arg)
    
    
    if __name__=="__main__":
        print("主进程",os.getpid())
        p=Pool(5)
        for i in range(20):
            ret=p.apply_async(func=haha,args=(i,),callback=back)
        p.close()
        p.join()
       #需要回调函数的场景:进程池中任何一个任务一旦处理完了,就立即告知主进程:我好了额,你可以处理我的结果了。
       # 主进程则调用一个函数去处理该结果,该函数即回调函数


    三.进程与线程对比:
    进程
        是计算机中最小的资源分配单位
        在利用多个CPU执行的过程中,对多个程序的资源进行管理和隔离
    进程的弊端
    开启和关闭 以及 切换 都会带来很大的时间开销
    过多的进程还会造成操作系统调度的压力
    
    线程
        线程是CPU调度的最小单位
        每个进程中至少有一个线程
        实际上执行代码的是线程
    线程属于进程
        进程负责获取操作系统分配给我的资源
        线程负责执行代码
    从代码的角度上看:
        多进程:
            开启和结束   时间花销大
            切换的效率低
            内存隔离
        多线程:
            开启和结束   时间开销非常小
            切换效率高
            内存不隔离
        Cpython解释器下的全局解释器锁
            在同一个进程中的多个线程在同一时刻只能有一个线程访问CPU
            多线程无法形成并行
            锁的线程
        什么时候才会用到CPU
            程序计算的时候
        IO阻塞
            是不会用到CPU的
        Jpython解释器就没有全局解释器锁
        pypy解释器没有全局解释器锁
    4CPU
        起四个进程
            进程里起线程

    四.Threading模块
    示例:
    import os
    import time
    from threading import Thread
    
    
    def func():
        time.sleep(3)
        print(123,os.getpid())
    
    
    print(456,os.getpid())
    for i in range(10):
        Thread(target=func).start()
        time.sleep(3)


  • 相关阅读:
    LVS DR模式的简单应用
    Linux新加硬盘如何识别 分区 持续挂载
    13周作业
    12周作业
    2次月考
    10周作业
    9周作业
    8周作业
    7周作业
    6周作业
  • 原文地址:https://www.cnblogs.com/J-7-H-2-F-7/p/9385107.html
Copyright © 2020-2023  润新知