专栏首页iOS 技术分享OC - load 和 initialize

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

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

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • iOS - 多线程(二):pthread、NSThread

    GitHub:https://github.com/dolphin1208/Thread

    师大小海腾
  • iOS - 多线程(三):GCD

    GCD 中的任务有两种封装:dispatch_block_t 和 dispatch_function_t。

    师大小海腾
  • iOS - 多线程(四):NSOperation

    NSOperation 需要和 NSOperationQueue 配合使用来实现多线程方案。单独使用 NSOperation 的话, 它是属于同步操作, 并不具...

    师大小海腾
  • iOS Category实现原理 (补充)

    void call_load_methods(void) { static bool loading = NO; bool more_cate...

    用户1941540
  • runtime的那些事(三)——NSObject初始化 load 与 initialize

     作为iOS开发,多少都与 load 方法打过交道——在程序 main 函数调用前,类被注册加载到内存时,load 方法会被调用。也就是说每个类的 load 方...

    我只不过是出来写写代码
  • 类方法load和initialize的区别

    Objective-C作为一门面向对象语言,有类和对象的概念。编译后,类相关的数据结构会保留在目标文件中,在运行时得到解析和使用。在应用程序运行起来的时候,类的...

    用户3539187
  • 免费GPU哪家强?谷歌Kaggle vs. Colab

    作者 | Jeff Hale 译者 | Monanfei 责编 | 夕颜 出品 | AI科技大本营(id:rgznai100)

    AI科技大本营
  • Windows Win7建立wifi热点,手机共享WIFI上网

    2、启用并设定虚拟WiFi网卡:运行命令:netsh wlan set hostednetwork mode=allow ssid=mywifi key=12...

    授客
  • MLOD:基于鲁棒特征融合方法的多视点三维目标检测

    注:这是一篇2019年9月发表在arXiv【1】激光雷达和摄像头数据融合的目标检测论文。

    SIGAI学习与实践平台
  • .glusterfs 目录说明

        .glusterfs目录大小基本是等于当前brick中的所有文件大小,原因是里面主要存放的是brick中文件的硬链接。

    党志强

扫码关注云+社区

领取腾讯云代金券