iOS开发之 runtime(36) ：load 方法加载

logo

本系列博客是本人的源码阅读笔记，如果有 iOS 开发者在看 runtime 的，欢迎大家多多交流。

前言

load 方法中的最后一个函数：

_dyld_objc_notify_register(&map_2_images, load_images, unmap_image);

告诉我们，第一步是 map_2_images，第二步就是 load_images。笔者前面的文章也已经分析过，将文件或者类从 mach-o 里读出来后，进行 remap 等操作后放入相应的 hashmap 中，其实是做了第一步：缓存，为了方便后面调用。而第二步 load_images，则是调用 load 方法。本文将给大家慢慢揭开 load 方法的神秘面纱。

分析

load_images 方法的实现如下：

void load_images(const char *path __unused, const struct mach_header *mh) {
    if (!hasLoadMethods((const headerType *)mh)) return;
    prepare_load_methods((const headerType *)mh);
    call_load_methods();
}

去掉一些无关逻辑（主要是锁操作和注释）可以看出其实该方法就是两部操作：

调用 load 方法之前的一些准备工作
开始调用 load 方法

大家可能会有一些困惑

load 方法之前的 prepare，究竟 prepare 的是什么？为什么要准备？
调用的大概顺序是什么？比如类 A 和类 A 的父类都实现了 load 方法，甚至还有其 category 都实现了，那顺序是怎么样的？下面笔者带大家抽丝剥茧看代码。

准备操作

prepare_load_methods 的代码如下：

void prepare_load_methods(const headerType *mhdr)
{
    size_t count, i;

    runtimeLock.assertWriting();

    classref_t *classlist = 
        _getObjc2NonlazyClassList(mhdr, &count);
    for (i = 0; i < count; i++) {
        schedule_class_load(remapClass(classlist[i]));
    }

    category_t **categorylist = _getObjc2NonlazyCategoryList(mhdr, &count);
    for (i = 0; i < count; i++) {
        category_t *cat = categorylist[i];
        Class cls = remapClass(cat->cls);
        if (!cls) continue;  // category for ignored weak-linked class
        realizeClass(cls);
        assert(cls->ISA()->isRealized());
        add_category_to_loadable_list(cat);
    }
}

相信看过之前文章的读者应该对

_getObjc2NonlazyClassList

这个方法很熟悉了，作用就是获取所有拥有 load 方法的类（class）。
而

_getObjc2NonlazyCategoryList

同理可证，是获取所有拥有 load 方法的分类（category）。
所以这是第一步：取出所有的 load 方法的类或者分类。

至此我们开篇提出的几个问题，估计大家可能应该有一点答案了：

比如类 A 和类 A 的父类都实现了 load 方法，甚至还有其 category 都实现了，那顺序是怎么样的？

因为先加载_getObjc2NonlazyClassList后加载_getObjc2NonlazyCategoryList所以，感觉上应该是先调用当前类的 load 方法，再调用 category 的 load 方法，那事实是不是这样呢？我们继续分析代码。
上面不管是 _getObjc2NonlazyClassList还是_getObjc2NonlazyCategoryList后面都有接下来的操作，我们对这两个后面的代码做分析：

for (i = 0; i < count; i++) {
    schedule_class_load(remapClass(classlist[i]));
}

这段，先 remap 再调用 schedule_class_load所以，remap 大家很熟悉了不做过多介绍了。我们进入 schedule_class_load 看一下：

/***********************************************************************
* prepare_load_methods
* Schedule +load for classes in this image, any un-+load-ed 
* superclasses in other images, and any categories in this image.
**********************************************************************/
// Recursively schedule +load for cls and any un-+load-ed superclasses.
// cls must already be connected.
static void schedule_class_load(Class cls)
{
    if (!cls) return;
    assert(cls->isRealized());  // _read_images should realize

    if (cls->data()->flags & RW_LOADED) return;

    // Ensure superclass-first ordering
    schedule_class_load(cls->superclass);

    add_class_to_loadable_list(cls);
    cls->setInfo(RW_LOADED); 
}

从以上代码可以看出来，其实 schedule_class_load 只是将 cls 通过一个方法add_class_to_loadable_list加到一个列表里,等一下！为什么又调用了自身：

   // Ensure superclass-first ordering
    schedule_class_load(cls->superclass);

是不是意味着，先调用父类的 load 方法，再调用自身的？！

继续分析方法 add_class_to_loadable_list：

void add_class_to_loadable_list(Class cls)
{
    IMP method;

    loadMethodLock.assertLocked();

    method = cls->getLoadMethod();
    if (!method) return;  // Don't bother if cls has no +load method
    
    if (PrintLoading) {
        _objc_inform("LOAD: class '%s' scheduled for +load", 
                     cls->nameForLogging());
    }
    
    if (loadable_classes_used == loadable_classes_allocated) {
        loadable_classes_allocated = loadable_classes_allocated*2 + 16;
        loadable_classes = (struct loadable_class *)
            realloc(loadable_classes,
                              loadable_classes_allocated *
                              sizeof(struct loadable_class));
    }
    
    loadable_classes[loadable_classes_used].cls = cls;
    loadable_classes[loadable_classes_used].method = method;
    loadable_classes_used++;
}

我们可以发现，最终将所有拥有 load 方法的类都加到静态对象 loadable_classes中：

// List of classes that need +load called (pending superclass +load)
// This list always has superclasses first because of the way it is constructed
static struct loadable_class *loadable_classes = nil;
static int loadable_classes_used = 0;
static int loadable_classes_allocated = 0;

类似的 category 的也有类似的方法：

/***********************************************************************
* add_category_to_loadable_list
* Category cat's parent class exists and the category has been attached
* to its class. Schedule this category for +load after its parent class
* becomes connected and has its own +load method called.
**********************************************************************/
void add_category_to_loadable_list(Category cat)
{
    IMP method;

    loadMethodLock.assertLocked();

    method = _category_getLoadMethod(cat);

    // Don't bother if cat has no +load method
    if (!method) return;

    if (PrintLoading) {
        _objc_inform("LOAD: category '%s(%s)' scheduled for +load", 
                     _category_getClassName(cat), _category_getName(cat));
    }
    
    if (loadable_categories_used == loadable_categories_allocated) {
        loadable_categories_allocated = loadable_categories_allocated*2 + 16;
        loadable_categories = (struct loadable_category *)
            realloc(loadable_categories,
                              loadable_categories_allocated *
                              sizeof(struct loadable_category));
    }

    loadable_categories[loadable_categories_used].cat = cat;
    loadable_categories[loadable_categories_used].method = method;
    loadable_categories_used++;
}

以及静态变量：

// List of categories that need +load called (pending parent class +load)
static struct loadable_category *loadable_categories = nil;
static int loadable_categories_used = 0;
static int loadable_categories_allocated = 0;

总结

如果后面的调用方法和按我们这里加载进类列表的顺序一致的话，我们可以得出如下结论：

调用的大概顺序是：比如类 A 和类 A 的父类都实现了 load 方法，甚至还有其 category 都实现了，那顺序是先调用 A 的父类的 load 方法，再调用他的或者他自己的 category 的 load 方法。

这可能就是 load 方法调用时机问题。