• Python-网络编程之进程


    多进程Multiprocessing

      multiprocessing是python的多进程管理包,和threading.Thread类似。

    下面是一个简单的多进程例子:

    from multiprocessing import Process
    import time
    def f(name):
        time.sleep(2)
        print('hello', name)
     
    if __name__ == '__main__':
        p = Process(target=f, args=('bob',))
        p.start()
        p.join()
    

    为了更加清楚地了解多进程之间的关系,将进程ID号打印出来:

    # _*_coding:utf-8_*_
    
    from multiprocessing import Process
    import os
    
    
    def info(title):
        print(title)
        print('module name:', __name__)
        print('parent process:', os.getppid())
        print('process id:', os.getpid())
        print("
    
    ")
    
    
    def f(name):
        info('33[31;1mfunction f33[0m')
        print('hello', name)
    
    
    if __name__ == '__main__':
        info('33[32;1mmain process line33[0m')
        p = Process(target=f, args=('bob',))
        p.start()
        p.join()
    

    进程间通信

    不同进程间内存是不共享的,要想实现两个进程间的数据交换,可以用以下方法:

    Queues

    使用方法跟threading里的queue差不多。

    # _*_coding:utf-8_*_
    
    from multiprocessing import Process, Queue
    
    
    def f(q):
        q.put([42, None, 'hello'])
    
    
    if __name__ == '__main__':
        q = Queue()
        p = Process(target=f, args=(q,))    # 启动多线程
        p.start()
        print(q.get())  # "[42, None, 'hello']" # 从队列q中获取数据
        p.join()
    

    Pipes管道

    # _*_coding:utf-8_*_
    
    from multiprocessing import Process, Queue, Pipe
    
    def f(conn):
        conn.send([42, None, 'hello'])
        conn.close()
    
    
    if __name__ == '__main__':
        parent_conn, child_conn = Pipe()    # 管道一个出口,一个入口
        p = Process(target=f, args=(child_conn,))
        p.start()
        print(parent_conn.recv())  # prints "[42, None, 'hello']"
        p.join()
    

    Managers

    # _*_coding:utf-8_*_
    
    from multiprocessing import Process, Queue, Pipe, Manager
    
    def f(d, l):
        d[1] = '1'
        d['2'] = 2
        d[0.25] = None
        l.append(1)
        print(l)
    
    
    if __name__ == '__main__':
        with Manager() as manager:
            d = manager.dict()
    
            l = manager.list(range(5))
            p_list = []
            for i in range(10):
                p = Process(target=f, args=(d, l))
                p.start()
                p_list.append(p)
            for res in p_list:
                res.join()
    
            print(d)
            print(l)
    

    进程同步

    from multiprocessing import Process, Lock
     
    def f(l, i):
        l.acquire()
        try:
            print('hello world', i)
        finally:
            l.release()
     
    if __name__ == '__main__':
        lock = Lock()
     
        for num in range(10):
            Process(target=f, args=(lock, num)).start()
    

    进程池

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

    进程池中有两个方法:

    • apply
    • apply_async
    # _*_coding:utf-8_*_
    
    from multiprocessing import Process, Pool, freeze_support
    import time
    
    
    def Foo(i):
        time.sleep(2)
        return i + 100
    
    
    def Bar(arg):
        print('-->exec done:', arg)
    
    
    if __name__ == '__main__':
        freeze_support()
        pool = Pool(5)  # 创建5个线程池
    
        for i in range(10):
            pool.apply_async(func=Foo, args=(i,), callback=Bar)
            # pool.apply(func=Foo, args=(i,))
    
        print('end')
        pool.close()    # 关闭pool,使其不在接受新的任务。
        pool.join()  # 进程池中进程执行完毕后再关闭,如果注释,那么程序直接关闭。
        # 主进程阻塞,等待子进程的退出, join方法要在close或terminate之后使用。
    
  • 相关阅读:
    博弈论进阶之树的删边游戏与无向图的删边游戏
    博弈论进阶之Every-SG
    HDU 3595 GG and MM(Every-SG)
    博弈论入门之斐波那契博弈
    博弈论入门之威佐夫博弈
    博弈论进阶之Multi-SG
    博弈论进阶之Anti-SG游戏与SJ定理
    博弈论进阶之SG函数
    【每天一个Linux命令】12. Linux中which命令的用法
    《数学之美》之悟——学懂数学为何如此重要?
  • 原文地址:https://www.cnblogs.com/kirusx/p/7113693.html
Copyright © 2020-2023  润新知