python 2.6 multiprocessing 的使用

原文出处：http://www.rainsts.net/article.asp?id=1016

 

Python Standard Library 从 2.6 起增加了子进程级别的并行开发支持 —— multiprocessing。

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import os, time
from multiprocessing import *

def test(x):
    print current_process().pid, x
    time.sleep(1)

if __name__ == "__main__":
    print "main:", os.getpid()
    p = Pool(5)
    p.map(test, range(13))

输出:

$ ./test.py

main: 1208
1209 0
1210 1
1211 2
1212 3
1213 4
1210 5
1209 6
1212 7
1211 8
1213 9
1209 10
1210 11
1212 12

从输出结果，我们可以看出多个子进程 "并行" 完成了 "计算" 任务。

1. Process

我们先从最根本的 Process 入手，看看是如何启动子进程完成并行计算的。上面的 Pool 不过是创建多个 Process，然后将数据(args)提交给多个子进程完成而已。

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import os, time
from multiprocessing import *

def test(x):
    print current_process().pid, x
    time.sleep(1)

if __name__ == "__main__":
    print "main:", os.getpid()

    p = Process(target = test, args = [100])
    p.start()
    p.join()

输出:

$ ./test.py

main: 1229
1230 100

为了更好掌握这个 "并行" 利器，需要 "深入" 探究子进程的执行流程和生命周期。multiprocessing 在接口设计上参考了 threading，而我们分析的起点就是 Process.start()。

class Process(object):
    '''
    Process objects represent activity that is run in a separate process

    The class is analagous to `threading.Thread`
    '''

    _Popen = None

    def __init__(self, group=None, target=None, name=None, args=(), kwargs={}):
        ...
        self._parent_pid = os.getpid()
        self._popen = None
        self._target = target
        self._args = tuple(args)
        self._kwargs = dict(kwargs)
        ...

    def start(self):
        ...

        if self._Popen is not None:
            Popen = self._Popen
        else:
            from .forking import Popen

        self._popen = Popen(self)
        _current_process._children.add(self)

继续，这个 Popen 是关键，打开 forking.py。

class Popen(object):

    def __init__(self, process_obj):
        ...
        self.pid = os.fork()
        if self.pid == 0:
            ...
            code = process_obj._bootstrap()
            sys.stdout.flush()
            sys.stderr.flush()
            os._exit(code)

这里调用了关键的 fork()，子进程由此而生。接下来子进程调用了 Process._bootstrap()。注意，这里还调用了 "os._exit(code)"，这表明子进程与 Process.Start() "self._popen = Popen(self)" 之后的代码分道扬镳。

class Process(object):

    def _bootstrap(self):
        from . import util
        global _current_process

        try:
            self._children = set()
            self._counter = itertools.count(1)

            try:
                sys.stdin.close()
                sys.stdin = open(os.devnull)
            except (OSError, ValueError):
                pass

            _current_process = self # 重置了 _current_process ！
            util._finalizer_registry.clear()
            util._run_after_forkers()
            util.info('child process calling self.run()')

            try:
                self.run()
                exitcode = 0
            finally:
                util._exit_function()

        except SystemExit, e:
            if not e.args:
                exitcode = 1
            elif type(e.args[0]) is int:
                exitcode = e.args[0]
            else:
                sys.stderr.write(e.args[0] + '/n')
                sys.stderr.flush()
                exitcode = 1
        except:
            exitcode = 1
            import traceback
            sys.stderr.write('Process %s:/n' % self.name)
            sys.stderr.flush()
            traceback.print_exc()

        util.info('process exiting with exitcode %d' % exitcode)
        return exitcode

这个方法看着复杂，初始化子进程环境，并对异常等做出处理，但关键的就是 "self.run()" 这一行。

class Process(object):
    def run(self):
        if self._target:
            self._target(*self._args, **self._kwargs)

子进程在这里调用了我们创建 Process 对象时传递的 target 参数，也就是上例中的 test()。如此，我们就大概明白了子进程创建和调用的整个过程，似乎并不复杂。不过事情还没完，我们需要继续 "了解" 父进程在创建子进程之后做了什么。

回到 Process.start()，Popen 创建并调用子进程，而父进程则继续执行下一步。

class Process(object):

    def start(self):
        ...

        if self._Popen is not None:
            Popen = self._Popen
        else:
            from .forking import Popen

        self._popen = Popen(self)
        _current_process._children.add(self)

这个 _current_process 默认应该代表父进程，只是从何而来？在 process.py 最后面有这些代码。

class _MainProcess(Process):

    def __init__(self):
        self._identity = ()
        self._daemonic = False
        self._name = 'MainProcess'
        self._parent_pid = None
        self._popen = None
        self._counter = itertools.count(1)
        self._children = set()
        self._authkey = AuthenticationString(os.urandom(32))
        self._tempdir = None

_current_process = _MainProcess()
del _MainProcess

只是对当前进程(父进程)的简单包装。父进程通过 Process.start() 创建子进程，并添加到一个子进程列表(_children)中。那么父进程如何处理子进程的退出呢？要知道不小心会搞出很多僵尸进程(参见 《fork: 杀僵尸练级》)。

在 multiprocessing.__init__.py 中引入了 util。

from multiprocessing.util import SUBDEBUG, SUBWARNING

在 util.py 尾部有这些代码。

from multiprocessing.process import current_process, active_children

def _exit_function():
    global _exiting

    info('process shutting down')
    debug('running all "atexit" finalizers with priority >= 0')
    _run_finalizers(0)

    for p in active_children():
        if p._daemonic:
            info('calling terminate() for daemon %s', p.name)
            p._popen.terminate()

    for p in active_children():
        info('calling join() for process %s', p.name)
        p.join()

    debug('running the remaining "atexit" finalizers')
    _run_finalizers()

atexit.register(_exit_function)

active_children 由 process 导入。

def current_process():
    '''Return process object representing the current process'''
    return _current_process

def active_children():
    '''Return list of process objects corresponding to live child processes'''
    _cleanup()
    return list(_current_process._children)

_exit_function 会在父进程(或子进程，子进程可以创建自己的子进程)退出时检查其子进程列表，并调用 join 等待子进程退出。如果子进程是 daemon，则直接调用 terminate (发送 SIGTERM 信号) 终止。

class Process(object):

    def join(self, timeout=None):
        ...
        res = self._popen.wait(timeout)
        if res is not None:
            _current_process._children.discard(self)

class Popen(object):

    def wait(self, timeout=None):
        if timeout is None:
            return self.poll(0)
        ...
        while 1:
            res = self.poll()
            ...
        return res

    def poll(self, flag=os.WNOHANG):
        if self.returncode is None:
            pid, sts = os.waitpid(self.pid, flag)
            if pid == self.pid:
                if os.WIFSIGNALED(sts):
                    self.returncode = -os.WTERMSIG(sts)
            else:
                assert os.WIFEXITED(sts)
                self.returncode = os.WEXITSTATUS(sts)
        return self.returncode

    def terminate(self):
        if self.returncode is None:
        try:
            os.kill(self.pid, signal.SIGTERM)
        except OSError, e:
            if self.wait(timeout=0.1) is None:
            raise

Process.join() 调用 Popen.wait()，而 wait() 内部则通过 poll() 调用 os.waitpid() 等待子进程终止，如此这般才算完成了一个完整的流程。

附注: 子进程同样也会在其退出时调用 uitl._exit_function。

------------ 分隔线 -----------------

本文主要分析 multiprocessing 的相关原理，有关使用细节可参考标准库帮助文件。