OC - load 和 initialize

目录 1. load 1.1 load 方法的调用 1.2 场景分析 1.3 源码分析 2. initialize 2.1 initialize 方法的调用 2.2 场景分析 2.3 源码分析 3. load 和 initialize 的区别 4. 相关面试题

1. load

1.1 load 方法的调用

• ① 调用时刻： load方法会在Runtime加载类、分类时调用（不管有没有用到这些类，在程序运行起来的时候都会加载进内存，并调用 load方法）； 每个类、分类的 load，在程序运行过程中只调用一次（除非开发者手动调用）。
• ② 调用方式：系统自动调用 load方式为直接通过函数地址调用，开发者手动调用 load方式为消息机制objc_msgSend函数调用。
• ③ 调用顺序： 先调用类的 load，按照编译先后顺序调用（先编译，先调用），调用子类的 load之前会先调用父类的 load； 再调用分类的 load，按照编译先后顺序调用（先编译，先调用）（注意：分类的其它方法是：后编译，优先调用）。

1.2 场景分析

Person 以及它的两个分类 Person (Test)、Person (Test2) 都实现了 test和 load两个方法，且 Person (Test2) 最后编译。调用 Person 的 test，并打印 Person 元类对象中的类方法列表，查看打印结果。

代码语言：javascript复制

// Person
#import <Foundation/Foundation.h>
@interface Person : NSObject
  (void)test;
  (void)load;
@end

#import "Person.h"
@implementation Person
- (void)test {
    NSLog(@"person test");
}
  (void)load {
    NSLog(@"person  load");
}
@end

// Person (Test)
...
// Person (Test2)
...

#import "ViewController.h"
#import "Person.h"
#import <objc/runtime.h>

@implementation ViewController
void printAllMethodNamesOfClass(Class cls)
{
    u_int count;
    Method *methods = class_copyMethodList(cls, &count);
    NSMutableString *methodNames = [NSMutableString string];
    for (int i = 0; i < count ; i  )
    {
        Method method = methods[i];
        NSString *methodName = NSStringFromSelector(method_getName(method));
        [methodNames appendString:methodName];
        [methodNames appendString:@", "];
    }
    free(methods);    
    NSLog(@"%@: %@",cls,methodNames);
}

- (void)viewDidLoad {
    [super viewDidLoad];
    [Person test];    
    // 打印 Person 元类对象中的类方法列表
    printAllMethodNamesOfClass(object_getClass([Person class]));
}
@end

/*
2020-02-18 22:05:33.114202 0800 Category [32631:7237868] person  load
2020-02-18 22:05:33.114929 0800 Category [32631:7237868] Person (Test)  load
2020-02-18 22:05:33.115009 0800 Category [32631:7237868] Person (Test2)  load
2020-02-18 22:05:33.209976 0800 Category [32631:7237868] Person (Test2) test
2020-02-18 22:05:33.210124 0800 Category [32631:7237868] Person: load, test, load, test, load, test,
*/

以上打印结果可以验证 Category 的几个原理：

• ① 分类方法会“覆盖”同名的宿主类方法，不是真正的覆盖，只是顺序超前了，通过Runtime API打印方法可以得知。
• ② 同名分类方法谁能生效取决于编译顺序，最后参与编译的分类中的同名方法会最终生效。

那么，为什么分类也实现了 load方法，却不是只调用 Person (Test2) 的 load，而是全部调用呢？下面我们进入源码分析。

1.3 源码分析

函数调用栈：

• objc-os.mm ① _objc_init：Runtime的入口函数，进行一些初始化操作
• objc-runtime-new.mm ② load_images ③ prepare_load_methods  schedule_class_load  add_class_to_loadable_list  add_category_to_loadable_list ④ call_load_methods  call_class_loads  call_category_loads   (*load_method)(cls, SEL_load) 核心函数

load_images

代码语言：javascript复制

void load_images(const char *path __unused, const struct mach_header *mh)
{
    recursive_mutex_locker_t lock(loadMethodLock);

    // Discover  load methods
    prepare_load_methods((const headerType *)mh);

    // Call  load methods (without classLock - re-entrant)
    call_load_methods();
}

call_load_methods

先调用类的 load方法，再调用分类的 load方法。

代码语言：javascript复制

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
        // ⚠️先调用类的  load 方法
        while (loadable_classes_used > 0) {
            call_class_loads();
        }

        // 2. Call category  loads ONCE
        // ⚠️再调用分类的  load 方法
        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 & call_category_loads

类和分类的 load方法是直接通过函数地址调用，所以都会调用。而其他方法如 test则是通过消息机制objc_msgSend函数调用，会优先查找宿主类中靠前的元素，找到同名方法就进行调用，所以优先调用最后编译的分类的方法。

代码语言：javascript复制

typedef void(*load_method_t)(id, SEL); //函数指针

struct loadable_class {
    Class cls;  // may be nil
    IMP method; // 类的  load 方法的地址
};

struct loadable_category {
    Category cat;  // may be nil
    IMP method;    // 分类的  load 方法的地址
};

static void call_class_loads(void)
{
    int i;
    
    // Detach current loadable list.
    // ⚠️一堆可加载的类，将它们保存到存放 loadable_class 结构体类型元素的数组
    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;
        // ⚠️从数组中取出一个类的 method，这个 method 就是类的  load 方法的地址
        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 方法
        (*load_method)(cls, SEL_load);
    }
    
    // Destroy the detached list.
    if (classes) free(classes);
}

static bool call_category_loads(void)
{
    int i, shift;
    bool new_categories_added = NO;
    
    // Detach current loadable list.
    // ⚠️一堆可加载的分类，将它们保存到存放 loadable_category 结构体类型元素的数组
    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;
        // ⚠️从数组中取出一个分类的 method，这个 method 就是分类的  load 方法的地址
        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 方法
            (*load_method)(cls, SEL_load);
            cats[i].cat = nil;
        }
    }
    ......
}

从call_load_methods函数中我们可以得知：先调用类的 load方法，再调用分类的 load方法。

那么在类或者分类中 load方法的调用顺序是怎么样的呢？

从call_class_loads和call_category_loads函数中可以得知：可加载的类和分类分别保存在loadable_classes和loadable_categories数组中，因此我们只需要搞明白这两个数组中的类和分类的存放顺序，就可以知道调用顺序。

prepare_load_methods

按编译顺序将可加载的类添加进loadable_classes数组，先添加父类，再添加子类；按编译顺序将可加载的分类添加进loadable_categories数组。所以：

• 按编译顺序调用类的 load方法，先编译先调用，调用子类的 load之前会先调用父类的 load；
• 按编译顺序调用分类的 load方法，先编译先调用。

代码语言：javascript复制

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

    runtimeLock.assertLocked();

    // 按编译顺序取得类数组
    classref_t *classlist =
        _getObjc2NonlazyClassList(mhdr, &count);
    for (i = 0; i < count; i  ) {
        // 将可加载的类添加到 loadable_classes 数组中
        // 先添加父类，再添加子类
        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
        if (cls->isSwiftStable()) {
            _objc_fatal("Swift class extensions and categories on Swift "
                        "classes are not allowed to have  load methods");
        }
        realizeClassWithoutSwift(cls);
        assert(cls->ISA()->isRealized());
        // 将可加载的分类添加到 loadable_categories 数组中
        add_category_to_loadable_list(cat);
    }
}

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

    // 将可加载的类添加到 loadable_classes 数组中
    add_class_to_loadable_list(cls);
    cls->setInfo(RW_LOADED); 
}

2. initialize

2.1 initialize 方法的调用

• ① 调用时刻： initialize方法会在类第一次接收到消息时调用。 如果子类没有实现 initialize方法，会调用父类的 initialize，所以父类的 initialize方法可能会被调用多次，但不代表父类初始化多次，每个类只会初始化一次。
• ② 调用方式：消息机制objc_msgSend函数调用。
• ③ 调用顺序： 先调用父类的 initialize，再调用子类的 initialize （先初识化父类，再初始化子类）

2.2 场景分析

Person 、Person 的两个分类 Person (Test)、Person (Test2) 以及它的子类 Student 都实现了 initialize方法，且 Person (Test2) 最后编译。给 Student 类发送一条消息，查看打印结果。

代码语言：javascript复制

// Person
#import "Person.h"
@implementation Person
  (void)initialize {
    NSLog(@"person  initialize");
}
@end

// Person (Test)
...
// Person (Test2)
...
// Student
...

#import "ViewController.h"
#import "Student.h"
- (void)viewDidLoad {
    [super viewDidLoad];

    [Student alloc];
}

/*
2020-02-19 20:48:59.230852 0800 Category [34163:7694237] Person (Test2)  initialize
2020-02-19 20:48:59.231052 0800 Category [34163:7694237] Student  initialize
*/

从以上打印结果可以得出结论：

• ① initialize方法会在类第一次接收到消息时调用；
• ② 先调用父类的 initialize，再调用子类的 initialize；
• ③ 调用了分类的 initialize，没有调用宿主类的 initialize。说明 initialize方法的调用方式为消息机制，而非像 load那样直接通过函数地址调用。

2.3 源码分析

OC 中的方法调用（也称消息发送），其实都是转换为objc_msgSend()函数的调用。 initialize方法会在类第一次接收到消息时调用，说明在objc_msgSend()函数内部会判断是不是第一次发送消息，是的话就调用 initialize方法。

关于objc_msgSend()函数的具体调用流程可以查看我的文章 深入浅出 Runtime（三）：objc_msgSend方法调用流程。

下面我们通过Runtime源码objc4-750版本的来分析 initialize方法的调用流程。（我查看了最新版本的 initialize的函数调用栈与旧版本有差异，不过原理相同）

函数调用栈：

• objc-msg-arm64.s ① _objc_msgSend
• objc-runtime-new.mm ② class_getInstanceMethod：调用方法之前需要先获取方法 ③ lookUpImpOrNil ④ lookUpImpOrForward ⑤ _class_initialize：初始化类的函数 ⑥ callInitialize ⑦ objc_msgSend(cls, SEL_initialize)：给 cls 对象发送 initialize 消息

lookUpImpOrForward

代码语言：javascript复制

IMP lookUpImpOrForward(Class cls, SEL sel, id inst, 
                       bool initialize, bool cache, bool resolver)
{
    ......

    // ⚠️如果 receiverClass 需要初始化且还未初始化，就进行初始化操作
    // 调用 _class_initialize(cls)，该函数中会递归遍历父类，判断父类是否存在且还未初始化 _class_initialize(cls->superclass)
    // 调用 callInitialize(cls) ，给 cls 发送一条 initialize 消息((void(*)(Class, SEL))objc_msgSend)(cls, SEL_initialize)
    // 所以  initialize 方法会在类第一次接收到消息时调用
    // 调用方式：objc_msgSend()
    // 调用顺序：先调用父类的  initialize，再调用子类的  initialize (先初始化父类，再初始化子类，每个类只会初始化1次）
    if (initialize  &&  !cls->isInitialized()) {
        runtimeLock.unlockRead();
        _class_initialize (_class_getNonMetaClass(cls, inst));
        runtimeLock.read();
        // If sel == initialize, _class_initialize will send  initialize and 
        // then the messenger will send  initialize again after this 
        // procedure finishes. Of course, if this is not being called 
        // from the messenger then it won't happen. 2778172
    }
    ......
}

_class_initialize

代码语言：javascript复制

void _class_initialize(Class cls)
{
    assert(!cls->isMetaClass());

    Class supercls;
    bool reallyInitialize = NO;

    // Make sure super is done initializing BEFORE beginning to initialize cls.
    // See note about deadlock above.
    /* 递归调用
       如果存在父类且父类未初始化，先初始化父类
     */
    supercls = cls->superclass;
    if (supercls  &&  !supercls->isInitialized()) {
        _class_initialize(supercls);
    }
    ......

#if __OBJC2__
        @try
#endif
        {
            // 调用 callInitialize
            callInitialize(cls);

    ......
}

callInitialize

调用objc_msgSend函数，给 cls 对象发送 initialize 消息。

代码语言：javascript复制

void callInitialize(Class cls)
{
    ((void(*)(Class, SEL))objc_msgSend)(cls, SEL_initialize);
    asm("");
}

3. load 和 initialize 的区别

区别	load	initialize
调用时刻	在Runtime加载类、分类时调用（不管有没有用到这些类，在程序运行起来的时候都会加载进内存，并调用 load方法）。每个类、分类的 load，在程序运行过程中只调用一次（除非开发者手动调用）。	在类第一次接收到消息时调用。如果子类没有实现 initialize方法，会调用父类的 initialize，所以父类的 initialize方法可能会被调用多次，但不代表父类初始化多次，每个类只会初始化一次。
调用方式	① 系统自动调用 load方式为直接通过函数地址调用；② 开发者手动调用 load方式为消息机制objc_msgSend函数调用。	消息机制objc_msgSend函数调用。
调用顺序	① 先调用类的 load，按照编译先后顺序调用（先编译，先调用），调用子类的 load之前会先调用父类的 load；② 再调用分类的 load，按照编译先后顺序调用（先编译，先调用）（注意：分类的其它方法是：后编译，优先调用）。	① 先调用父类的 initialize，② 再调用子类的 initialize（先初识化父类，再初始化子类）。

4. 相关面试题

Q：Category 中有 load 方法吗？ load 方法是什么时候调用的？ load 方法能继承吗？

1. 分类中有 load方法；
2. load方法在Runtime加载类、分类的时候调用；
3. load方法可以继承，但是一般情况下不会手动去调用 load方法，都是让系统自动调用。

Q：手动调用 Student 类的 load 方法，但是 Student 类没有实现该方法，为什么会去调用父类的 load 方法，且是调用父类的分类的 load 方法呢？

因为 load方法可以继承，[Student load]手动调用方式为是消息机制objc_msgSend函数的调用，会去类方法列表里找对应的方法，由于 Student 类没有实现，就会去父类的方法列表中查找，且优先调用分类的 load方法。而系统自动调用的 load方法是直接通过函数地址调用的。

打包 objective-c 日志服务

0 人点赞