python基础一 day38 进程池代码

本是古典何须时尚 2024-04-20 11:05 82阅读 0赞

# 为什么会有进程池的概念
        # 效率
        # 每开启进程,开启属于这个进程的内存空间
        # 寄存器 堆栈 文件
        # 进程过多 操作系统的调度
    
    # 进程池
        # python中的 先创建一个属于进程的池子
        # 这个池子指定能存放n个进程
        # 先讲这些进程创建好
    # 更高级的进程池
        # n,m
        # 3   三个进程
        #     + 进程
        # 20  20个
    import time
    from multiprocessing import Pool,Process
    def func(n):
        for i in range(10):
            print(n+1)
    
    def func2(n):
        for i in range(10):
            print(n+2)
    if __name__ == '__main__':
        start = time.time()
        pool = Pool(5)               # 5个进程
        pool.map(func,range(100))    # 100个任务
        pool.map(func2,[('alex',1),'egon'])    # 100个任务
        t1 = time.time() - start
    
        start = time.time()
        p_lst = []
        for i in range(100):
            p = Process(target=func,args=(i,))
            p_lst.append(p)
            p.start()
        for p in p_lst :p.join()
        t2 = time.time() - start
        print(t1,t2)

import os
    import time
    from multiprocessing import Pool
    def func(n):
        print('start func%s'%n,os.getpid())
        time.sleep(1)
        print('end func%s' % n,os.getpid())
    
    if __name__ == '__main__':
        p = Pool(5)
        for i in range(10):
            p.apply_async(func,args=(i,))
        p.close()  # 结束进程池接收任务
        p.join()   # 感知进程池中的任务执行结束

进程池的返回值是进程池特有的：

\# p = Pool()  
\# p.map(funcname,iterable) 默认异步的执行任务,且自带close和join  
\# p.apply 同步调用的  
\# p.apply\_async 异步调用 和主进程完全异步 需要手动close 和 join

# from multiprocessing import Pool
    # def func(i):
    #     return i*i
    #
    # if __name__ == '__main__':
    #     p = Pool(5)
    #     for i in range(10):
    #         res = p.apply(func,args=(i,))   # apply的结果就是func的返回值
    #         print(res)
    
    # import time
    # from multiprocessing import Pool
    # def func(i):
    #     time.sleep(0.5)
    #     return i*i
    #
    # if __name__ == '__main__':
    #     p = Pool(5)
    #     res_l = []
    #     for i in range(10):
    #         res = p.apply_async(func,args=(i,))   # apply的结果就是func的返回值
    #         res_l.append(res)
    #     for res in res_l:print(res.get())# 等着 func的计算结果
    
    # import time
    # from multiprocessing import Pool
    # def func(i):
    #     time.sleep(0.5)
    #     return i*i
    #
    # if __name__ == '__main__':
    #     p = Pool(5)
    #     ret = p.map(func,range(100))
    #     print(ret)

进程池的回调函数：

# 回调函数
    import os
    from multiprocessing import Pool
    def func1(n):
        print('in func1',os.getpid())
        return n*n
    
    def func2(nn):
        print('in func2',os.getpid())
        print(nn)
    
    if __name__ == '__main__':
        print('主进程 :',os.getpid())
        p = Pool(5)
        for i in range(10):
            p.apply_async(func1,args=(10,),callback=func2)
        p.close()
        p.join()

转载于:https://www.cnblogs.com/wang-tan/p/11439937.html