• python 多线程和多进程2


    1.    多进程 multiprocessing模块

      python中由于GIL锁的存在使多线程并非真正的多线程,所以为了充分利用多核CPU,在python中大部分情况下需要使用多进程。

      (1)Process类调用

    from multiprocessing import Process
    import os
    
    def run_proc(name):
        print('run child process %s (%s)...' % (name, os.getpid()))
    
    if __name__ == '__main__':
        print('parent process %s.' %os.getpid())
        p = Process(target=run_proc,args=('test',))
        print('child process will start')
        p.start()
        p.join()
        print('child process end.')

      (2)进程队列Queue,进程间通讯数据传递

    from multiprocessing import Process,Queue
    
    def f(q,n):
        q.put([n,'hello'])
        print(q.get())
    
    if __name__ == '__main__':
        q = Queue()
        for i in range(5):
            p = Process(target=f,args=(q,i))
            p.start()

      (3)进程Manager,进程间数据共享

    from multiprocessing import Process,Manager
    #使用manager实现进程共享
    def f(d,l):
        d[1] = '1'
        d['2'] = 2
        d[0.25] = None
        l.reverse()
    if __name__ == '__main__':
        manager = Manager()
        d = manager.dict()           #生成一个字典,可以在进程间共享和传递
        l = manager.list(range(10))  #生成一个列表,可以在进程间共享和传递
        print(d)
        print(l)
        for i in range(10):
            p = Process(target=f,args=(d,l))
            p.start()
            p.join()
        print(d)
        print(l)

      (4)进程锁

    from multiprocessing import Process,Lock
    #进程锁
    def f(l,i):
        l.acquire()
        print('how are you',i)
        l.release()
    
    if __name__ == '__main__':
        lock = Lock()
        for num in range(10):
            p = Process(target=f,args=(lock,num))
            p.start()
            p.join()

      (5)进程池,进程池内部维护一个进程序列,当使用时则取获取进程,如果进程池中序列中没有可获取的进程,那么进程就等待,直到进程池中有可用的进程。

    from multiprocessing import Pool
    import time
    #使用pool产生多进程
    def f(x):
        print(x*x)
        time.sleep(2)
        return x*x
    pool = Pool(processes=5)
    res_list = []
    for i in range(10):
        res = pool.apply_async(f,[i,])
    pool.close()          #等待子进程执行完毕关闭进程池
    pool.join()
        

      进程池中所用到的方法:

        a.  apply:从进程池中取一个进程并执行

        b.  apply_async:apply的异步

        c.  terminate:立刻关闭进程池

        d.  join:主进程等待子进程执行完毕,必须在close或terminate之后

        e.  close:等待所有进程结束后,关闭进程池

  • 相关阅读:
    第四次实验报告
    第三次实验报告
    第五章循环结构课后反思
    第二次实验报告
    第一次实验报告
    第一次作业
    第九章 结构体与共用体
    第八章实验报告
    第七章数组实验
    第六章函数与宏定义实验报告(2)
  • 原文地址:https://www.cnblogs.com/homle/p/8724572.html
Copyright © 2020-2023  润新知