探究 +load 方法本质

这次其实是通过阅读源码的方式，观察iOS是如何调用的load 方法。

下载源码，找到load 相关的函数。
如何下载源码，翻看我之前的几篇博客。

入口文件当然是objc-os.mm
搜索_objc_load_image

OBJC_EXPORT void _objc_load_image(HMODULE image, header_info *hinfo)
{
    prepare_load_methods(hinfo);
    call_load_methods();
}

prepare_load_methods:准备调用+load
call_load_methods：调用+load

1.我们进入到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);
    }
}

1）schedule_class_load
loadable_classes:类的+load 方法加入到loadable_classes数组中,而且是递归加载，先加入父类的+load，然后再加入子类的+load，源码如下：

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); 
}

2）loadable_categories:类别的+load 方法加入到loadable_categories数组中，加入顺序是编译顺序

以上就是call_load_methods 准备工作

2.我们进入到call_load_methods

void call_load_methods(void)
{
    static bool loading = NO;
    bool more_categories;

    loadMethodLock.assertLocked();

    // Re-entrant calls do nothing; the outermost call will finish the job.
    if (loading) return;
    loading = YES;

    void *pool = objc_autoreleasePoolPush();

    do {
        // 1. Repeatedly call class +loads until there aren't any more
        while (loadable_classes_used > 0) {
            call_class_loads();
        }

        // 2. Call category +loads ONCE
        more_categories = call_category_loads();

        // 3. Run more +loads if there are classes OR more untried categories
    } while (loadable_classes_used > 0  ||  more_categories);

    objc_autoreleasePoolPop(pool);

    loading = NO;
}

1）阅读源码可以发现第一个规律：call_class_loads() 和 call_category_loads() ，
说明了，类的+load 方法 是 早于分类中的+load 方法,而且源码注释明确说明。

// 1. Repeatedly call class +loads until there aren't any more
// 2. Call category +loads ONCE

static bool call_category_loads(void)
{
    int i, shift;
    bool new_categories_added = NO;
    
    // Detach current loadable list.
    struct loadable_category *cats = loadable_categories;
    int used = loadable_categories_used;
    int allocated = loadable_categories_allocated;
    loadable_categories = nil;
    loadable_categories_allocated = 0;
    loadable_categories_used = 0;

    // Call all +loads for the detached list.
    for (i = 0; i < used; i++) {
        Category cat = cats[i].cat;
        load_method_t load_method = (load_method_t)cats[i].method; //load 方法
        Class cls;
        if (!cat) continue;

        cls = _category_getClass(cat);
        if (cls  &&  cls->isLoadable()) {
            if (PrintLoading) {
                _objc_inform("LOAD: +[%s(%s) load]\n", 
                             cls->nameForLogging(), 
                             _category_getName(cat));
            }
            (*load_method)(cls, SEL_load);
            cats[i].cat = nil;
        }
    }
}

2）之前说category,分类中的方法会覆盖类的方法实现，但是+load方法类中也会调用？
其实看源码可知道，+load 方法直接通过内存地址值调用的，不是通过消息机制。

总结：

1.+load 方法在runtime加载类和类别的时候调用。
2.每个类和类别的+load 方法只会调用一次。
3.对于类调用+load方法：递归先调用父类，然后再调用子类；对于不同类调用+load方法：编译顺序。
4.对于分类调用+load方法：编译顺序。
5.+load方法直接通过内存地址值直接调用，不是通过消息机制。（区别于其他方法，其他方法会覆盖）