Load 和 Initialize 先加载哪个？

父类和子类以及 Category 的关系？

如果是多个 Category 呢？

Load

开发文档的直接解读

加载顺序总结

  • 所有类和分类的 +load 方法都是在被加入到 runtime 的时候调用

  • 父类优先于子类加载（内部通过递归的的方式实现）

  • 在所有本类加载完毕之后再去加载各个分类

  • 同一个类的多个分类加载顺序可查看 Target -> Build Phases -> Compile Sources

比如，现有Student 继承于 Person，Student拥有多个分类，在各个类的 + load 方法进行打印，结果如下

1
2
3
4
5
6
7
2017-06-26 18:30:59.857400+0800 load[70593:5621604] Person ==> Load
2017-06-26 18:30:59.857596+0800 load[70593:5621604] Student ==> Load
2017-06-26 18:30:59.857656+0800 load[70593:5621604] Test2 ==> Load
2017-06-26 18:30:59.857707+0800 load[70593:5621604] Test1 ==> Load
2017-06-26 18:30:59.857724+0800 load[70593:5621604] Student + load2 ==> Load
2017-06-26 18:30:59.857730+0800 load[70593:5621604] Student + load3 ==> Load
2017-06-26 18:30:59.857736+0800 load[70593:5621604] Student + load1 ==> Load

查看 Compile Sources，观察 Student 三个分类的加载顺序，与 load 调用顺序一致

runtime 源码阅读

首先看下 objc-runtime-new.mm 中的 void prepare_load_methods(header_info *hi) 函数，在该函数中准备好 类和分类执行 +load 方法的必要条件，以供接下来的调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
void prepare_load_methods(header_info *hi)
{
    size_t count, i;
    rwlock_assert_writing(&runtimeLock);
    classref_t *classlist =
        _getObjc2NonlazyClassList(hi, &count);
    for (i = 0; i < count; i++) {
        schedule_class_load(remapClass(classlist[i]));
    }
    category_t **categorylist = _getObjc2NonlazyCategoryList(hi, &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);
    }
}

同时，在处理类的时候，也调用了同文件中的另外一个函数 static void schedule_class_load(Class cls)

1
2
3
4
5
6
7
8
9
10
11
12
13
static void schedule_class_load(Class cls)
{
    if (!cls) return;
    assert(cls->isRealized());  // _read_images should realize
    if (cls->data()->flags & RW_LOADED) return;
# warning 此处使用递归的思想实现了先调用父类再调用子类的 +load 方法
    // Ensure superclass-first ordering
    schedule_class_load(cls->superclass);
    add_class_to_loadable_list(cls);
    cls->setInfo(RW_LOADED);
}

当前所有满足 +load 方法调用条件的类和分类就被分别存放在全局变量 loadable_classes （load_images 方法调用）和 loadable_categories 中了

准备好类和分类后，接下来就是对它们的 +load 方法进行调用了。打开文件 objc-loadmethod.m ，找到其中的 void call_load_methods(void) 函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
void call_load_methods(void)
{
    static BOOL loading = NO;
    BOOL more_categories;
    recursive_mutex_assert_locked(&loadMethodLock);
    // 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;
}

同样的，这个函数的作用就是调用上一步准备好的类和分类中的 +load 方法，并且确保类优先于分类的顺序。我们继续查看在这个函数中调用的另外两个关键函数 static void call_class_loads(void) 和 static BOOL call_category_loads(void) 。由于这两个函数的作用大同小异，下面就以篇幅较小的 static void call_class_loads(void) 函数为例进行探讨

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
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, SEL_load);
    }
    // Destroy the detached list.
    if (classes) _free_internal(classes);
}

这个函数的作用就是真正负责调用类的 +load 方法了。它从全局变量 loadable_classes 中取出所有可供调用的类，并进行清零操作。

1
2
3
4
5
6
// 指向 用于保存类信息的内存的首地址
loadable_classes = nil;
// 标识已分配的内存空间大小
loadable_classes_allocated = 0;
// 标识已使用的内存空间大小
loadable_classes_used = 0;

load_images -> load_images_nolock -> prepare_load_methods -> schedule_class_load -> add_class_to_loadable_list 的时候会将未加载的类添加到 loadable_classes

调用类和分类的 +load 方法是直接使用函数内存地址的方式 (*load_method)(cls, SEL_load); ，而不是使用发送消息 objc_msgSend 的方式。

调用 load 方法之前，所有的 framework 都已经加载到了运行时中，所以调用 framework 中的方法都是安全的

Initialize

首先看一下苹果官方文档对 Initialize 的定义

打开 objc-runtime-new.mm，找到以下函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// 当我们给某个类发送消息的时候，runtime会调用这个函数在类中查找相应方法的实现或转发
#warning 考虑以上特性，说明该类接收到第一条消息之前才会调用 +initialize 方法
IMP lookUpImpOrForward(Class cls, SEL sel, id inst,
                       bool initialize, bool cache, bool resolver)
{
    ...
        rwlock_unlock_write(&runtimeLock);
    }
    # warning 注：当类没有初始化时， runtime 会调用 void _class_initialize(Class cls) 函数对该类进行初始化
    if (initialize  &&  !cls->isInitialized()) {
        _class_initialize (_class_getNonMetaClass(cls, inst));
        // 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
    }
    // The lock is held to make method-lookup + cache-fill atomic 
    // with respect to method addition. Otherwise, a category could 
    ...
}

接下来看看具体的初始化代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
void _class_initialize(Class cls)
{
    ...
    Class supercls;
    BOOL reallyInitialize = NO;
#warning 同样使用递归的思想实现了先调用父类再调用子类的顺序
    // 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);
    }
    // Try to atomically set CLS_INITIALIZING.
    monitor_enter(&classInitLock);
    if (!cls->isInitialized() && !cls->isInitializing()) {
        cls->setInitializing();
        reallyInitialize = YES;
    }
    monitor_exit(&classInitLock);
    if (reallyInitialize) {
        // We successfully set the CLS_INITIALIZING bit. Initialize the class.
        // Record that we're initializing this class so we can message it.
        _setThisThreadIsInitializingClass(cls);
        // Send the +initialize message.
        // Note that +initialize is sent to the superclass (again) if 
        // this class doesn't implement +initialize. 2157218
        if (PrintInitializing) {
            _objc_inform("INITIALIZE: calling +[%s initialize]",
                         cls->nameForLogging());
        }
#warning 注意这里使用了 objc_msgSend，就意味着该方法就和其他普通方法一样，子类要沿用父类的方法，分类会会覆盖本类中的方法。
#warning 同时，如果子类没有实现但父类实现了该方法，那么父类的该方法就要被实现多次
        ((void(*)(Class, SEL))objc_msgSend)(cls, SEL_initialize);
        if (PrintInitializing) {
            _objc_inform("INITIALIZE: finished +[%s initialize]",
    ...
}

  • 针对 Category，经测试发现：Category 中 Initialize 方法会覆盖其本类中的方法(和其他普通方法效果一样)

  • 在 Initialize 方法内部可以进行一些不方便在编译期进行初始化的静态变量的赋值

1
2
3
4
5
6
7
8
9
10
11
12
13
#warning Person.m
// int 等基本类型可以在编译期进行赋值
static int numCount = 0; 
// 对象无法在编译器进行赋值
static NSMutableArray *dataSource;
+ (void)initialize {
    if (self == [Person class]) {
        // 不能在编译期赋值的对象在这里进行赋值
        dataSource = [[NSMutableArray alloc] init];
    }
}

异常情况：在A类的load 方法中调用了B类的类方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@implementation Father
+ (void)load {
    NSLog(@"father==> load===%@", [Dog class]);
}
+(void)initialize {
    NSLog(@"Father===>initialize");
}
@end
#warning 打印结果如下
2017-08-09 11:19:09.838 tests[34274:8415363] Dog===>initialize
2017-08-09 11:19:09.839 tests[34274:8415363] father==> load===Dog
2017-08-09 11:19:09.839 tests[34274:8415363] Dog==> load
2017-08-09 11:19:09.840 tests[34274:8415363] child==> load
2017-08-09 11:19:09.840 tests[34274:8415363] child + hahha==> load
2017-08-09 11:19:09.840 tests[34274:8415363] main

以下是Compile Source 截图

总结

  • 正常情况下(即没有在 load 方法中调用相关类方法)，load 和 Initialize 方法都在实例化对象之前调用，load相当于装载方法，都在main()函数之前调用，Initialize方法都在main() 函数之后调用。

  • 如果在A类的 load 方法中调用 B 类的类方法，那么在调用A的Load 方法之前，会先调用一下B类的initialize 方法，但是B类的load 方法还是按照 Compile Source 顺序进行加载

  • 所有类的 load 方法都会被调用，先调用父类、再调用子类，多个分类会按照Compile Sources 顺序加载。但是Initialize 方法会被覆盖，子类父类分类中只会执行一个

  • load 方法内部一般用来实现 Method Swizzle，Initialize方法一般用来初始化全局变量或者静态变量

  • 两个方法都不能主动调用，也不需要通过 super 继承父类方法，但是 Initialize 方法会在子类没有实现的时候调用父类的该方法，而 load 不会

Load和Initialize的往死了问是一种怎样的体验相关推荐

  1. Load和Initialize往死了问是一种怎样的体验？

    2017.08.08 这个问题有点炒冷饭了,写了 demo 才更深入的了解这个问题,就当做个简单的笔记吧 一. Load和Initialize的往死了问是一种怎样的体验? Load 和 Initial ...

  2. 在c语言中load,一道题理清Objective-C中的load和initialize

    Objective-C中有两个方法比较特殊,他们会在Runtime时根据情况自动调用,下面我们简单分析一下调用时机以及使用场景~ 一般在iOS初中级面试时偶尔会被问到load和initialize方法 ...

  3. iOS—分类、load 、initialize

    文章目录 分类 分类的结构 load方法的调用顺序 initialize load和initialize区别 分类在运行期做了什么 为什么category不能添加成员变量 分类能否添加属性 使用关联对 ...

  4. 你需要了解的load和initialize

    NSObject类有两种初始化方式load和initialize load + (void)load; 复制代码 对于加入运行期系统的类及分类,必定会调用此方法,且仅调用一次. iOS会在应用程序启动 ...

  5. iOS---Objective-C: +load vs +initialize

    在 NSObject 类中有两个非常特殊的类方法 +load 和 +initialize ,用于类的初始化.这两个看似非常简单的类方法在许多方面会让人感到困惑,比如: 子类.父类.分类中的相应方法什么 ...

  6. oc---类方法load和initialize的区别

    在iOS开发中,就像Application有生命周期回调方法一样,在Objective-C的类被加载和初始化的时候,也可以收到方法回调,可以在适当的情况下做一些定制处理.而这正是本篇文章所要介绍的lo ...

  7. 解读OC中的load和initialize

    在 Objective-C 中,NSObject 是绝大多数类的基类.而在 NSObject 中有两个类方法 load 和 initialize,那这两个方法是在什么时机被调用呢?父类.Categor ...

  8. C语言试题106之有一对兔子，从出生后第 3 个月起每个月都生一对兔子，小兔子长到第三个月 后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？

    1.题目 题目:有一对兔子,从出生后第 3 个月起每个月都生一对兔子,小兔子长到第三个月 后每个月又生一对兔子,假如兔子都不死,问每个月的兔子总数为多少? 分析:兔子的规律为数列 1,1,2,3,5, ...

  9. 实例011：养兔子 有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？

    实例011:养兔子 题目:有一对兔子,从出生后第3个月起每个月都生一对兔子,小兔子长到第三个月后每个月又生一对兔子,假如兔子都不死,问每个月的兔子总数为多少? 分析:出生下来为第0个月,满月为1月兔, ...

最新文章

  1. 快过年了，博客园里的文章也变少了
  2. java别踩白块_java别踩白块（基础功能）
  3. j2ee安全介绍--转
  4. document.all
  5. 佳能2020转印带拆卸图解_RF人文街拍小钢炮 佳能RF35mm F1.8 MACRO IS STM
  6. 睡眠音频分割及识别问题(一)
  7. ie8 ajax访问不了https,ie8不支持https协议的api接口么
  8. c盘local文件太大_win7 c盘清理的方法教程
  9. button按钮提交form表单的js方法不要使用关键字login
  10. C语言：输出菱形图案
  11. SD卡无法格式化的原因分析
  12. golang 实现 tcp-聊天室
  13. Java中浏览量怎么实现_Java刷视频浏览量点赞量的实现代码
  14. kali Linux的简单介绍
  15. 2022年「博客之星」参赛博主：顽石九变
  16. nginx 防止恶意域名解析_Nginx 防止被域名恶意解析的办法
  17. 时隔24年，《失孤》原型父子相认！身体特征结合DNA对比，公安如何定位被拐儿童...
  18. RGB与HSV是什么，为什么要进行转换
  19. 全栈工程师实战：从 0 开发云笔记
  20. 不要以你的现状来判断你的未来

热门文章

  1. 列联表分析程序，以卢淑华书上的例子为例
  2. Linux查看ssd块大小性能,如何衡量Linux中对SSD执行的总写入量？
  3. java 异步 web_Java web spring异步方法实现步骤解析
  4. weblogic oracle连接池配置文件,关于WebLogic 访问Oracle 数据库（建立连接池）问题...
  5. java反射泛型类型,【Java反射】Java 泛型基础
  6. json 反射java 实体_Java 将JSON反射到实体类
  7. 数字图像处理——第五章 图像复原
  8. c++枚举类型(二) c++11 枚举类
  9. 论文辅助笔记（代码实现）：Bayesian Probabilistic Matrix Factorizationusing Markov Chain Monte Carlo
  10. NTU 课程 CE7454:信息论概述