码迷,mamicode.com
首页 > 其他好文 > 详细

multiprocessing 模块

时间:2019-02-10 20:40:57      阅读:194      评论:0      收藏:0      [点我收藏+]

标签:查看   sync   param   command   第一个   time   模块   mon   否则   

multiprocessing模块

进程对象

  • 创建
    • p = Process(target=foo, args=(param,))
  • 属性
    • p.daemon: True为守护进程, 守护进程内无法再开启子进程,否则抛出异常:AssertionError: daemonic processes are not allowed to have children, 父进程结束则自己也立刻结束; False则为非守护进程, 自身进程运行与父进程是否结束无关; p.daemon = True | False 必须在p.start()之前调用
    • p.name: 进程名
    • p.pid: 进程pid; 如果当前进程为父进程, 则p.pid与os.getpid()的结果一样
    • p.exitcode: 为None表示进程正在运行, 为-n表示由于某一个信号结束了
    • p.start(): 启动一个进程, 内部会调用p.run()方法
    • p.join(): 调用p.join()语句的进程需要等待p进程结束才能继续执行, p.join()中会调用wait函数
    • p.terminate(): 强制终止p进程, 但是不会立即终止, 所以如果在p.terminate()后紧接着是p.is_alive()则返回True, 但是如果紧接着会后面再来一个p.is_alive()就会返回False了, 第一个p.is_alive()会催促p结束
    • p.is_alive(): p进程是否还在运行
  • 僵尸进程与进程

    • 僵尸进程
      • 父进程还在执行, 但是子进程结束了, 父进程没有调用wait或者waitpid函数回收子进程的资源导致子进程死亡了但是仍然占用着进程资源
      • 对系统有害, 会造成资源浪费
        • 解决
          1. 如果已经产生了僵尸进程: 杀掉父进程, 让子进程成为孤儿进程从而交给init进程管理即可
          2. 预防僵尸进程: p为进程对象, 父进程p调用join()方法
    • 孤儿进程
      • 父进程结束, 但是子进程还在执行
      • 孤儿进程对系统无害, 孤儿进程会被init进程管理
  • 注意: Windows与类Unix系统创建子进程的方式不同
    • 类Unix
      • 类Unix系统采用fork()系统调用函数创建子进程, 字如其名, 子进程就是父进程的一个副本, 拷贝的过程中cs:ip的指针指向指令的哪个位置也是一致的(这多亏了虚拟内存), 也就是说, 复制出来的子进程不是从头开始执行的, 是从父进程调用fork()函数语句的下一条指令开始执行的, 随着技术的发展, fork()现在采用的是CoW实现
    • Windows
      • Windows上创建子进程的函数为CreateProcess(), 也是字如其名, 是创建一个进程而不是复制一个进程。CreateProcess()函数的API是

        
            BOOL CreateProcessA(
                LPCSTR                lpApplicationName, // 进程要执行的.exe文件名
                LPSTR                 lpCommandLine, // 执行的.exe的命令行参数
                LPSECURITY_ATTRIBUTES lpProcessAttributes,
                LPSECURITY_ATTRIBUTES lpThreadAttributes,
                BOOL                  bInheritHandles,
                DWORD                 dwCreationFlags,
                LPVOID                lpEnvironment,
                LPCSTR                lpCurrentDirectory,
                LPSTARTUPINFOA        lpStartupInfo,
                LPPROCESS_INFORMATION lpProcessInformation
            );
      • 我们主要看API的第1和第2个参数, 很明显, CreateProcess()API可以创建一个与当前父进程完全不同的子进程, 因为它接受一个.exe文件的路径, 该路径可以是任何一个.exe文件, 将该.exe文件加载到内存中CPU从头开始执行代码, 如果要实现与类Unix中fork()函数类似的功能, CreateProcess()的第一个参数应该为父进程的.exe文件的位置, 这样就创建出来一个与父进程一样的子进程了, 但是刚才说了是类似, 肯定有不同, 类Unix中fork出来的子进程的入口是父进程fork语句的下一条指令, 而CreateProcess是从头开始执行子进程

    • Windows底层采用CreateProcess函数创建子进程在Python中出现的问题
      • 在main.py中
        ```py

        import time
        import multiprocessing
        from multiprocessing import Process

        def foo():
        time.sleep(3)
        print(‘this is foo function‘)

        p = Process(target=foo)
        p.start()

        print(‘Finish‘)
        ```
      • 在命令行执行python3 main.py, 报错: 常见了无限个进程
      • 分析
        • Windows 底层调用CreateProcess函数创建子进程, 创建的子进程会从头开始执行程序, 对于main.py, 创建一个子进程, 就会再走一遍import time..., 这个时候肯定还会遇到Process(), 没有办法, 在CreateProcess一次, 一次类推, 一直创建子进程
        • 解决方案
          • 依据Python中主进程的__name__ == __main__而子进程__name__ != __main__规避
          • 代码
          
          import time
          import multiprocessing
          from multiprocessing import Process
          
          def foo():
              time.sleep(3)
              print(‘this is foo function‘)
          
          if __name__ == ‘__main__‘:
              p = Process(target=foo)
              p.start()
              print(‘Finish‘)

进程共享

  • 一般来说进程中定义的数据是不会共享的, 父进程的数据与子进程中的数据无关, 对于一个一般的全局变量也是不共享的; 在这样势必会导致程序运行效率低下, 在Windows中在不同进程中打印id(an_obj), 显示出来的id是不同的, 因为Windows中的进程实质上不是fork出来的而是CreateProcessAPI产生的, 子进程要从头开始走一遍, 具体内容在上文注意中提到, 但是在类Unix中打印出来的id是一样的, 因为是fork出来的;

进程同步

  • 进程之间的数据是不共享的, 但是文件系统, 屏幕等是共享的, 可以共同访问一个文件, 一个屏幕(终端), 所以会产生这些资源的竞争, 为此我们需要控制他们的竞争关系
  • 为了控制资源的访问, 诞生了进程锁, 这里很特别, 我们知道两个进程(A与B)之间的资源是独立的, 但是multiprocessing中的对象(Lock, Queue等)在两个进程中内部会有复杂的映射, 目的就是要达到资源共享
    • 在main程序中定义了multiprocessing.Lock(), 在main中fork出A和B两个子进程执行一个同一段代码(代码一样, 但是不是同一段代码, 是复制出来的两份独立的代码), lock作为参数传入. A中lock.acquire()时, 按道理来说, 进程A与B是独立的, A中调用了acquire()应该不会影响B, 但是Python内部做了复杂的映射, 当A中lock.acquire()时也会对B中同一段代码上锁; 因为lock在内核空间

IPC

  • Queue(建议多使用Queue)
    1. Queue内部有锁机制, 并且支持数据共享
    2. q.put方法用以插入数据到队列中,put方法还有两个可选参数:blocked和timeout。如果blocked为True(默认值),并且timeout为正值,该方法会阻塞timeout指定的时间,直到该队列有剩余的空间。如果超时,会抛出Queue.Full异常。如果blocked为False,但该Queue已满,会立即抛出Queue.Full异常。
    3. q.get方法可以从队列读取并且删除一个元素。同样,get方法有两个可选参数:blocked和timeout。如果blocked为True(默认值),并且timeout为正值,那么在等待时间内没有取到任何元素,会抛出Queue.Empty异常。如果blocked为False,有两种情况存在,如果Queue有一个值可用,则立即返回该值,否则,如果队列为空,则立即抛出Queue.Empty异常.
    4. q.empty():调用此方法时q为空则返回True,该结果不可靠,比如在返回True的过程中,如果队列中又加入了项目。
    5. q.full():调用此方法时q已满则返回True,该结果不可靠,比如在返回True的过程中,如果队列中的项目被取走。
    6. q.qsize():返回队列中目前项目的正确数量,结果也不可靠,理由同q.empty()和q.full()一样
  • Pipe
    1. 与Linux C语言中的Pipe有一些不同, Python中的Pipe更加高级, C中的Pipe只能是父子进程之间进行数据交互, 但是Python中的Pipe除了父子之间还可以是其他的进程之间
    2. Pipe中一端recv或者send时, 如果所有其他端口都被close(所有涉及到该Pipe的进程)了, 才会抛出EOFError异常
    3. send(obj)和recv()方法使用pickle模块对对象进行序列化
    4. Pipe编程中的close(), send(), recv()等操作一定要在fork完了所有的进程执行, 否则会产生很多意想不到的错误
  • Manager(共享数据, 内部没有锁, 需要自己加锁)
    1. 就是C中的mmap
    2. 一般配合lock与with使用, 因为Manger自己不会加锁
    lock = Lock()
    with Manager() as m:
        d = m.dict({‘data‘: 100})
        p = Process(target=foo, args=(d, lock))
        p.start()
  • Semaphore(信号量)
    1. 信号量规定了一个资源最多最多可以被多少个进程访问, 多出来的会被阻塞
    2. Semaphore(size)
    3. acquire() 锁资源
    4. release() 释放资源锁
  • Pool
    1. Pool(3), 创建一个有3个进程的进程池, 从无到有, 最多有3个, 之后就一直是3个
    2. apply 与 apply_async
      • apply
        • 同步执行进程, 会阻塞当前主进程
        • 会立即返回进程执行的结果
      • apply_async
        • 异步执行进程, 不会立即返回结果, 不会阻塞
        • 返回的对象为ApplyResult, 获取结果只需要调用对象的get方法, 但是调用get方法, 需要调用p.close(), 再调用p.join()方法之后才能取结果, 否则主程序结束了, 进程池中的任务还没来得及全部执行完也都跟着主进程一起结束了, 这与我们直接使用Process不同, 要获取结果get, 建议将所有的进程都执行完再批量查看结果

multiprocessing 模块

标签:查看   sync   param   command   第一个   time   模块   mon   否则   

原文地址:https://www.cnblogs.com/megachen/p/10360030.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!