reload函数

原生imp.relaod函数：

• 模块代码将重新编译，模块级别的代码被重新执行，init函数将不再次执行
• 在Python中一切皆为对象，包括函数、变量等，模块中的函数、变量等全部包含在模块字典中，即module_dict，reload方法执行后module_dict中的keys对应的values为新的对象。
• 所有reload之前旧的对象在引用计数为0时被回收。

这就意味着imp.reload在使用过程中有很多问题，比如：

1. 不支持from xxx import xxx形式导入的重新加载
2. 只支持拓展模块的重新加载，sys、__main__等内置模块不能使用。我们最好不要重新加载除拓展模块外的其他模块。
3. reload某个模块，该模块的依赖模块不能自动reload，且只能先reload依赖的模块
4. 所有引用旧的对象的变量不会更换引用新的对象。重新加载类，其已实例化对象引用的方法不会变化，继续使用旧类的定义，对于派生类的对象同样如此。

reloader模块

这个库为Python实现了一个基于依赖关系的模块重载器。不像前面imp.reload函数，此重载程序将重新加载请求的模块和依赖于该模块的所有其他模块。对reload函数的问题进行了一定程度上的改进。

需要注意的是，reloader最终还是会调用imp.reload函数来进行reload。

主要分为三个重要步骤：

• 记录模块之间的依赖
• 重新加载模块
• 自定义重新重新加载函数

reloader模块提供了enable、disable、get_dependencies、reload四个接口，应用时调用enable就开始记录模块之间的依赖，使用reload便开始按依赖顺序加载模块。

记录依赖

通过建立模块之间的加载依赖图，可以实现正确的重新加载顺序。
实现的逻辑是通过重载全局的imprt hook函数（__import__）来实现。当需要热更新时，保存原始的__import__函数。当热更新时，我们重新import的行为，记为函数_import，递归调用_import导入模块并将此模块加入其父模块的依赖列表，即可构建模块依赖图。热更新后，恢复原有的__import__函数。

实例代码如下：

import builtins

_baseimport = builtins.__import__
_dependencies = dict()
_parent = None

def _import(name, globals=None, locals=None, fromlist=None, level=-1):
    # Track our current parent module.  This is used to find our current
    # place in the dependency graph.
    global _parent
    parent = _parent
    _parent = name

    # Perform the actual import using the base import function.
    m = _baseimport(name, globals, locals, fromlist, level)

    # If we have a parent (i.e. this is a nested import) and this is a
    # reloadable (source-based) module, we append ourself to our parent's
    # dependency list.
    if parent is not None and hasattr(m, '__file__'):
        l = _dependencies.setdefault(parent, [])
        l.append(m)

    # Lastly, we always restore our global _parent pointer.
    _parent = parent

    return m

builtins.__import__ = _import

重载模块

递归遍历需要重新加载的模块，这是一个典型的递归调用，visited集合是为了重复导入模块。示例代码如下：

import imp

def _reload(m, visited):
    """Internal module reloading routine."""
    name = m.__name__

    # Start by adding this module to our set of visited modules.  We use
    # this set to avoid running into infinite recursion while walking the
    # module dependency graph.
    visited.add(m)

    # Start by reloading all of our dependencies in reverse order.  Note
    # that we recursively call ourself to perform the nested reloads.
    deps = _dependencies.get(name, None)
    if deps is not None:
        for dep in reversed(deps):
            if dep not in visited:
                _reload(dep, visited)

    # Clear this module's list of dependencies.  Some import statements
    # may have been removed.  We'll rebuild the dependency list as part
    # of the reload operation below.
    try:
        del _dependencies[name]
    except KeyError:
        pass

    # Because we're triggering a reload and not an import, the module
    # itself won't run through our _import hook.  In order for this
    # module's dependencies (which will pass through the _import hook) to
    # be associated with this module, we need to set our parent pointer
    # beforehand.
    global _parent
    _parent = name

    # Perform the reload operation.
    imp.reload(m)

    # Reset our parent pointer.
    _parent = None

def reload(m):
    """Reload an existing module.

    Any known dependencies of the module will also be reloaded."""
    _reload(m, set())

自定义__reload__函数

我们可以在模块中自定义__reload__，用于进行数据处理。

def _deepcopy_module_dict(m):
    """Make a deep copy of a module's dictionary."""
    import copy

    # We can't deepcopy() everything in the module's dictionary because
    # some items, such as '__builtins__', aren't deepcopy()-able.
    # To work around that, we start by making a shallow copy of the
    # dictionary, giving us a way to remove keys before performing the
    # deep copy.
    d = vars(m).copy()
    del d['__builtins__']
    return copy.deepcopy(d)

# If the module has a __reload__(d) function, we'll call it with a
# copy of the original module's dictionary after it's been reloaded.
callback = getattr(m, '__reload__', None)
if callback is not None:
    d = _deepcopy_module_dict(m)
    imp.reload(m)
    callback(d)
else:
    imp.reload(m)

reloader黑名单

可以使用blacklist参数来设置reload的黑名单：
reloader.enable(blacklist=['os', 'ConfigParser'])

reloader的问题

只解决了imp.reload的模块依赖顺序问题，但是问题1/2/4依旧未解决。在需要reload的模块中自定义__reload__虽然可以解决问题4，但是自己写__reload__显然比较麻烦且容易出错，于是有了下面优化方案。

热更新优化

函数和方法的更新

该方案可以解决imp.reload的问题3和问题4，这种方案本质是对reload后对老代码的模块/对象引用的方法更新到新代码，而变量的值不变。

需要到两个知识点：

• 一个是使用到Python探针技术的sys.meta_path，使得可以在import时自定义做点什么事
• 第二个是使用到了imp.load_module(name, file, pathname, description)，加载模块， 如果模块已经被加载, 等同于reload()。

单个函数更新逻辑：把老的function的func_code、func_doc、func_dict、func_defaults引用新function的属性

更新流程：

• 先对sys.modules遍历，找到有代码改动或者新增的modules
• 对modules进行import，然后通过sys.meta_path机制，对每个module进行后面操作
• 如果是新加的module，直接return，否则进行后面操作
• 通过inspect.getmembers(module)找到module所有的function和type类型的对象。
• 对于module的function类型对象，如果有新增function就直接add到老模块中，对已有的function，使用函数更新逻辑更新。
• 对于module的type类型的，对type对象引用的function进行增删改，变量不变。

优点：

• 无论这些function/class以什么方式引用，只要不深入直接引用到func_code/func_default对象，均可动态更新到；
• 有代码改动的模块都会更新一遍，不用考虑模块依赖问题。

缺点：

• 不能动态更新class的派生关系相关的信息

新对象替换旧对象

module被热更新后，找出所有对module中的class/function...有引用的对象，逐个执行新对象替换旧对象的操作。

这个方案实现起来相对简单，但是运行效率过低，一般不做考虑。

其它

• 在热更新期间可以暂停gc
• 配表数据就不仅仅是更新函数，还要更新数据

虽然使用函数和方法的更新的热更新方法基本能满足需求，但是reload终究会让系统卡一段时间，还有优化方案是不要代码自动判断需要更新哪些模块，而是通过指令来指定。但是哪怕这样也还是会有一小段卡顿时间，后面会讲一下另一个热更新方案，可以解决卡顿问题。

引用

Python imp.reload
pypi/reloader
Reloading Python Modules
Python探针技术
python之imp模块