Python Multiprocessing.Process模块中的bootstrap指的是什么？

Question

我在玩多进程包里的Process和Pool模块时，发现总是能看到提到_bootstrap这个方法。

从我看到的情况来看，这个方法会导入一个叫multiprocessing的util.py模块，并使用它的一些方法（还有其他几个方法）来跟踪、记录和管理子进程。

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
        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 isinstance(e.args[0], int):
            exitcode = e.args[0]
        else:
            sys.stderr.write(str(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

我查了一下“bootstrap”这个词，发现它在Python模块中有很多不同的用法，最明显的用法（除了可能是推特的bootstrap框架）是指统计学中测量准确性的过程。

但在这个情况下，似乎这个函数名可能是指一个把各种元素联系在一起的方法？是这样吗？

Answer 1

_bootstrap 函数是在创建一个 multiprocessing.Process 后立刻运行的。它会在进程被“分叉”后执行：

def _launch(self, process_obj):
    code = 1
    parent_r, child_w = os.pipe()
    self.pid = os.fork()
    if self.pid == 0:
        try:
            os.close(parent_r)
            if 'random' in sys.modules:
                import random
                random.seed()
            code = process_obj._bootstrap()
        finally:
            os._exit(code)
    else:
        os.close(child_w)
        util.Finalize(self, os.close, (parent_r,))
        self.sentinel = parent_r

或者在进程被“生成”后执行：

def _main(fd):
    with os.fdopen(fd, 'rb', closefd=True) as from_parent:
        process.current_process()._inheriting = True
        try:
            preparation_data = pickle.load(from_parent)
            prepare(preparation_data)
            self = pickle.load(from_parent)
        finally:
            del process.current_process()._inheriting
    return self._bootstrap()

传给 Process 的 target 函数会从 _bootstrap 中执行：

    try:
        self.run()  # This runs target.
        exitcode = 0
    finally:
        util._exit_function()

所以在这里，“bootstrap”指的是启动计算机时的初始过程。也就是说，当计算机启动时，首先要做的一些事情，这些事情负责真正启动你想要运行的软件。对于 multiprocessing 来说，_bootstrap 负责设置运行你的 target 函数所需的环境，然后在执行完后进行清理。