应用程序加载（六）-- 面试题load方法的调用顺序

应用程序加载（一） -- dyld流程分析
应用程序加载（二） -- dyld&objc关联以及类的加载初探
应用程序加载（三）-- 类的加载
应用程序加载（四）-- 分类的加载
应用程序加载（五）-- 类扩展和关联对象

---

用一道面试题来终结应用程序加载篇章。

面试题：类和分类中有同名方法，调用时会执行哪个？

方法的调用就是底层消息发送（objc_msgSend）。最终会到方法列表中去查找整个方法的sel，由于分类的方法在类方法的前面，所有会调用分类方法。

但是有一个方法，系统会在main之前自动调用一次，就是+load方法。

而我们手动调用load的时候，调用的是==分类==中的方法。

1.示例代码

定义一个Person类和一个分类

//类
@interface Person : NSObject
@end
@implementation Person
+ (void)load {
    NSLog(@"%s", __func__);
}
@end

//分类
@interface Person (DZ)
@end
@implementation Person (DZ)
+ (void)load {
    NSLog(@"%s", __func__);
}
@end

//main中调用
int main(int argc, char * argv[]) {
    NSString * appDelegateClassName;
    @autoreleasepool {
        // Setup code that might create autoreleased objects goes here.
        appDelegateClassName = NSStringFromClass([AppDelegate class]);
        
        NSLog(@"===手动调用===");
        [Person load];
    }
    return UIApplicationMain(argc, argv, nil, appDelegateClassName);
}

运行结果：

• load方法在main之前的系统调用中，先执行类的，后执行分类的
• 在我们手动调用的时候，与普通方法相同，调用分类中的方法

接下来我们看看系统是合适调用的load方法，和是怎么调用的

2.源码分析

load方法是在底层代码的load_images中调用的

void
load_images(const char *path __unused, const struct mach_header *mh)
{
    if (!didInitialAttachCategories && didCallDyldNotifyRegister) {
        didInitialAttachCategories = true;
        loadAllCategories();
    }

    // Return without taking locks if there are no +load methods here.
    if (!hasLoadMethods((const headerType *)mh)) return;

    recursive_mutex_locker_t lock(loadMethodLock);

    // Discover load methods 发现load方法
    {
        mutex_locker_t lock2(runtimeLock);
        prepare_load_methods((const headerType *)mh);
    }

    // Call +load methods (without runtimeLock - re-entrant) 调用load方法
    call_load_methods();
}

• 之前的文章中讲过load_images是如何调用的，这里就不再多赘述了
• 通过注释，了解到，先去发现load方法，然后去调用

2.1 发现load方法

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

    runtimeLock.assertLocked();
    
    //非懒加载类
    classref_t const *classlist = 
        _getObjc2NonlazyClassList(mhdr, &count);
    for (i = 0; i < count; i++) {
        schedule_class_load(remapClass(classlist[i]));
    }
    
    //非懒加载分类
    category_t * const *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
        if (cls->isSwiftStable()) {
            _objc_fatal("Swift class extensions and categories on Swift "
                        "classes are not allowed to have +load methods");
        }
        realizeClassWithoutSwift(cls, nil);
        ASSERT(cls->ISA()->isRealized());
        add_category_to_loadable_list(cat);
    }
}

• 先处理非懒加载类，调用schedule_class_load函数
• 在处理非揽件在分类，调用add_category_to_loadable_list函数

继续看看这两个函数中是如何处理的。

2.1.1 非懒加载类

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

• 通过传入的参数cls， 然后递归优先处理父类schedule_class_load(cls->superclass);
• 紧接着调用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));
    }
    
    //保存cls 和 cls中的方法
    loadable_classes[loadable_classes_used].cls = cls;
    loadable_classes[loadable_classes_used].method = method;
    loadable_classes_used++;
}

• 这里就是对cls和method进行了存储

2.1.2非懒加载分类

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

• 代码和类中类似，也是进行了存储工作

2.2 调用load方法

“发现”的相关源码看完了，接着就该看看“调用”相关源码

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

• 此处注释写的很清楚了，先执行call_class_loads，调用类的load
• 再执行call_category_loads，调用分类的load

2.2.1 类load调用

static void call_class_loads(void)
{
    int i;
    
    // Detach current loadable list.
    struct loadable_class *classes = loadable_classes;
    int used = loadable_classes_used;
    loadable_classes = nil;
    loadable_classes_allocated = 0;
    loadable_classes_used = 0;
    
    // Call all +loads for the detached list.
    for (i = 0; i < used; i++) {
        Class cls = classes[i].cls;
        load_method_t load_method = (load_method_t)classes[i].method;
        if (!cls) continue; 

        if (PrintLoading) {
            _objc_inform("LOAD: +[%s load]\n", cls->nameForLogging());
        }
        //函数指针调用
        (*load_method)(cls, @selector(load));
    }
    
    // Destroy the detached list.
    if (classes) free(classes);
}

• 通过“发现”流程中保存的数据，进行循环处理
• 注意一下，此时load方法的调用是通过函数指针的方法，而不是消息发送。

2.2.2 分类load调用

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;
        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, @selector(load));
            cats[i].cat = nil;
        }
    }
    
    //省略不关心的代码
    ...
}

• 与类中的处理类似
• 分类中的load方法也是通过函数指针方式调用

3.手动调用load

手动调用load方法，是通过消息发送（objc_msgSend）的方式。因此回去查找方法列表，优先查到的是分类中的，所以调用的就是分类的load方法。

可以通过断点调试

然后打开汇编查看底层调用

总结

分类和类中有同名方法的时候

1. 手动调用方法，是进行消息发送的方式，分类方法排在类的方法前面，所以优先调用分类中的方法
2. 但是load方法，在main之前，系统会调用一次，调用顺序是优先调用类中的load，然后调用分类中的load