django源码分析之自动加载(autoreload模块)

自动加载模块(autoreload)

在用runserver启动服务的开发者模式下，Django提供了一种auto-reloader的机制，让用户修改的代码不需要手动重启服务就能生效，它会自动加载新的代码。这个功能大大提高了开发调试的效率。

代码分析

autoreload模块的调用发生在runserver里面，具体代码如下：

def run(self, **options):
    """Run the server, using the autoreloader if needed."""
    use_reloader = options['use_reloader']

    if use_reloader:
        # 自动加载模块的入口
        autoreload.main(self.inner_run, None, options)
    else:
        self.inner_run(None, **options)

runserver.run()根据用户传入的use_reloader来判断是否使用auto-reloader机制（在启动命令中是否加--noreload）。可以看出，真正干活的是self.inner_run，而负责自动加载的则是django.utils.autoreload，入口在autoreload.main()，具体位置在django/utils/autoreload.py。

def main(main_func, args=None, kwargs=None):
    if args is None:
        args = ()
    if kwargs is None:
        kwargs = {}

    wrapped_main_func = check_errors(main_func)
    python_reloader(wrapped_main_func, args, kwargs)

autoreload.main()主要针对main_func加了一层错误处理相关的封装，接下来看autoreload.python_reloader。

def python_reloader(main_func, args, kwargs):
    # 判断是否存在环境变量RUN_MAIN，且值被设置为true，后续会讲解什么情况下会存在它
    if os.environ.get("RUN_MAIN") == "true":
        # 启动新线程来执行main_func
        _thread.start_new_thread(main_func, args, kwargs)
        try:
            # 这里是检查文件更新的地方，后面讲解
            reloader_thread()
        except KeyboardInterrupt:
            pass
    # 第一次进来的时候，必然会进这个分支，因为没有地方设置过RUN_MAIN
    else:
        try:
            # 其实这里会创建一个新的子进程来运行服务，后面分析
            exit_code = restart_with_reloader()
            # 退出服务
            if exit_code < 0:
                os.kill(os.getpid(), -exit_code)
            else:
                sys.exit(exit_code)
        except KeyboardInterrupt:
            pass

python_reloader比较关键，很明显一开始不存在值为true的环境变量RUN_MAIN，所以第一次肯定会进else分支执行restart_with_reloader()：

def restart_with_reloader():
    import django.__main__
    while True:
        # 大概就是生成命令行 python manage.py runserver
        args = [sys.executable] + ['-W%s' % o for o in sys.warnoptions]
        if sys.argv[0] == django.__main__.__file__:
            # The server was started with `python -m django runserver`.
            args += ['-m', 'django']
            args += sys.argv[1:]
        else:
            args += sys.argv
        # 这里设置了环境变量RUN_MAIN，且值为true
        new_environ = {**os.environ, 'RUN_MAIN': 'true'}
        # 这里 再调了一遍命令行 python manage.py runserver
        exit_code = subprocess.call(args, env=new_environ)
        # hard code，>_>,3在这里是一个特殊的退出码，有特殊的用处，下文马上会提到
        if exit_code != 3:
            return exit_code

restart_with_reloader()重新执行了一遍runserver命令，同时设置了值为true的环境变量RUN_MAIN。咋一看，这是一个死循环！其实并不会，环境变量RUN_MAIN防止了这种事情的发生。subprocess.call创建了重新执行runserver命令的子进程，这个子进程会过runserver.run()->autoreload.main()->autoreload.python_reloader这样一条调用链路。然后到autoreload.python_reloader后，因为刚设置了RUN_MAIN，所以新的子进程再进来的时候，它就会进第一个分支了，而不是else分支，也就不会导致死循环，再贴下相关代码。

def python_reloader(main_func, args, kwargs):
    # 判断是否存在环境变量RUN_MAIN，且值被设置为true，后续会讲解什么情况下会存在它
    if os.environ.get("RUN_MAIN") == "true":
        # 启动新线程来执行main_func
        _thread.start_new_thread(main_func, args, kwargs)
        try:
            # 这里是检查文件更新的地方，后面讲解
            reloader_thread()
        except KeyboardInterrupt:
            pass
    # 第一次进来的时候，必然会进这个分支，因为没有地方设置过RUN_MAIN
    else:
        ...

这次新的进程会创建新的线程来执行main_func（上文中的self.inner_run），它才真正启动了服务。而新进程的当前线程去执行reloader_thread(),没错，它就是去执行文件更新检查的逻辑了：

def reloader_thread():
    # 这个是针对unix的设备，貌似是处理写Terminal的信号的逻辑
    ensure_echo_on()
    # 检查文件更新的两种方法
    if USE_INOTIFY:
        # 第一种方法是通过Linux的Inotify来监控文件系统，前提是系统支持。
        fn = inotify_code_changed
    else:
        # 如果系统不支持Inotify特性，就用code_changed，本质上就是对比文件的修改时间。
        fn = code_changed
    while RUN_RELOADER:
        # 循环执行，每一秒会去检查文件是否有更新
        change = fn()
        if change == FILE_MODIFIED:
            # 这里的3就和上文对应上了，如果发现是py文件有修改，就强制退出当前进程，退出码是3，然后restart_with_reloader判断是3，就继续重新subprocess.call生成一个新进程。
            sys.exit(3)  # force reload
        elif change == I18N_MODIFIED:
            # 如果是语音包相关的文件，就通过reset_translations重新加载
            reset_translations()
        time.sleep(1)

到这里已经很明朗了，reloader_thread()每隔1秒去检查文件是否有更新，如果有更新，则退出当前的进程，退出码为3，在上文的restart_with_reloader里，如果退出码为3，在父进程的while循环里面，会重新生成一个子进程，然后重新加载新文件来运行服务。所以不需要我们手动去重启服务，是因为autoreload自动帮我们重启了服务。
最后再看下code_changed，其中一种检查文件更新的方法，它主要通过文件修改时间来判断：

def code_changed():
    global _mtimes, _win
    for filename in gen_filenames():
        # 获取文件属性
        stat = os.stat(filename)
        # 获取文件最后一次修改时间
        mtime = stat.st_mtime
        if _win:
            mtime -= stat.st_ctime
        if filename not in _mtimes:
            _mtimes[filename] = mtime
            continue
        # 判断文件当前修改时间，和上次保存的修改时间是否一致
        if mtime != _mtimes[filename]:
            _mtimes = {}
            try:
                del _error_files[_error_files.index(filename)]
            except ValueError:
                pass
            # 通过判断被修改文件的类型，来做相应的操作
            return I18N_MODIFIED if filename.endswith('.mo') else FILE_MODIFIED
    return False

总结

以上就是autoreload机制的流程：执行runserver命令启动服务时，主进程并没有去启动服务，而是相当于一个守护进程的作用，它会通过subprocess创建子进程，该子进程会创建一个新线程来启动服务，然后子进程的主线程负责检测文件更新，如果发生文件更新则退出该子进程，返回约定的退出码3，守护进程检查子进程的退出码（exist code）如果与约定的退出码一致，则重新启动一个新的子进程继续工作。
需要说明的是autoreload模块是一个独立的模块，也还算比较通用，如果有需要的话，是可以直接拿来主义用的。