美文网首页ios进阶
OC 底层探索 - load 和 initialize

OC 底层探索 - load 和 initialize

作者: 师大小海腾 | 来源:发表于2020-02-19 22:50 被阅读0次
    网络配图

    目录

    • 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 元类对象中的类方法列表,查看打印结果。

    // 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

    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方法。

    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函数调用,会优先查找宿主类中靠前的元素,找到同名方法就进行调用,所以优先调用最后编译的分类的方法。

    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_loadscall_category_loads函数中可以得知:可加载的类和分类分别保存在loadable_classesloadable_categories数组中,因此我们只需要搞明白这两个数组中的类和分类的存放顺序,就可以知道调用顺序。

    prepare_load_methods

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

    • 按编译顺序调用类的+load方法,先编译先调用,调用子类的+load之前会先调用父类的+load
    • 按编译顺序调用分类的+load方法,先编译先调用。
    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 类发送一条消息,查看打印结果。

    // 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

    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

    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 消息。

    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方法是直接通过函数地址调用的。

    相关文章

      网友评论

        本文标题:OC 底层探索 - load 和 initialize

        本文链接:https://www.haomeiwen.com/subject/qifofhtx.html