南山忆的技术博客

回忆是抓不住的月光，握紧就变黑暗

0%

刨根问底+load方法

Posted on Edited on

  首先我们都知道在iOS应用启动的时候会调用所有类和其分类的+load方法。子类的load方法会在父类方法执行完成之后执行，分类的+load会在主类执行之后执行。不可继承，子类没有实现的时候，文件加载的时候是不会调用父类的load方法的。那么为什么+load的方法会有这样的特性，runtime又有哪些巧妙的处理呢。今天我们来刨根问底一下+load方法。

  首先解释两个变量和两个结构体，可以先看一眼有个印象，后面遇到再回来仔细察看

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//每次调用add_class_to_loadable_list()方法都会++，记录这个方法的调用次数，也相当于Class中+load方法列表的个数 
static int loadable_classes_used = 0;
//同上，只不过对应的是add_category_to_loadable_list()方法和Category中的+load方法列表
static int loadable_categories_used = 0;
//存储了+load方法所属的Class和+load方法的IMP
struct loadable_class {
    Class cls;  // may be nil
    IMP method;
};
//同上，只不过对应的是Category
struct loadable_category {
    Category cat;  // may be nil
    IMP method;
};
//存储Class和categoty这两个struct数据的是数组

1. Category方法列表的装载

1.1 调用栈

  我们还是通过runtime的源码来分析这个问题首先看分类的方法是什么时候加到主类的methed_list_t列表中的。下图为调用栈：
  可以看到调用次序是这样的，我们重点看_read_images方法。

1
map_images() —>map_images_nolock()—>_read_images()
1.2 _read_images（）

  源码较长，这里我只贴对我们有用的部分

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
void _read_images(header_info **hList, uint32_t hCount, int totalClasses, int unoptimizedTotalClasses)
{
//前面的都省略
// Discover categories. 
    for (EACH_HEADER) {
        category_t **catlist = 
            _getObjc2CategoryList(hi, &count);
        bool hasClassProperties = hi->info()->hasCategoryClassProperties();

        for (i = 0; i < count; i++) {
            category_t *cat = catlist[i];
            Class cls = remapClass(cat->cls);

            if (!cls) {
                // Category's target class is missing (probably weak-linked).
                // Disavow any knowledge of this category.
                catlist[i] = nil;
                if (PrintConnecting) {
                    _objc_inform("CLASS: IGNORING category \?\?\?(%s) %p with "
                                 "missing weak-linked target class", 
                                 cat->name, cat);
                }
                continue;
            }

            // Process this category. 
            // First, register the category with its target class. 
            // Then, rebuild the class's method lists (etc) if 
            // the class is realized. 
            bool classExists = NO;
            if (cat->instanceMethods ||  cat->protocols  
                ||  cat->instanceProperties) 
            {
                addUnattachedCategoryForClass(cat, cls, hi);
                if (cls->isRealized()) {
                    remethodizeClass(cls);
                    classExists = YES;
                }
                if (PrintConnecting) {
                    _objc_inform("CLASS: found category -%s(%s) %s", 
                                 cls->nameForLogging(), cat->name, 
                                 classExists ? "on existing class" : "");
                }
            }

            if (cat->classMethods  ||  cat->protocols  
                ||  (hasClassProperties && cat->_classProperties)) 
            {
                addUnattachedCategoryForClass(cat, cls->ISA(), hi);
                if (cls->ISA()->isRealized()) {
                    remethodizeClass(cls->ISA());
                }
                if (PrintConnecting) {
                    _objc_inform("CLASS: found category +%s(%s)", 
                                 cls->nameForLogging(), cat->name);
                }
            }
        }
    }
//后面的也省略
}

  注意到里面的addUnattachedCategoryForClass方法了吗，OC里面都喜欢这种见文知义的命名方法，直译过来就是为类添加未附加的类别。在这个方法里面，会找到未添加的类别列表对Class和Category做一个映射关联。而在remethodizeClass()方法里面会调用attachCategories把Category中的方法列表加到Class的methed_list_t里面去。而且是插入到Class方法列表的前面（这就是Category中重写主类的方法导致的方法覆盖的原因）

2. +load方法的调用

2.1 调用栈

  我们接着来看+load的方法的调用，如下图所示，这些会在Category方法装载之后!下图为调用栈

2.2 load_images()

  load_images()方法会多次调用（每个类都会调用一次）。我们来看load_images()方法的具体内容

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
void
load_images(const char *path __unused, const struct mach_header *mh)
{
    // 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
    {
        rwlock_writer_t lock2(runtimeLock);
        prepare_load_methods((const headerType *)mh);
    }

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

  里面有prepare_load_methods()和call_load_methods()这两个主要方法，先来看第一个

2.3 prepare_load_methods()
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(const headerType *mhdr)
{
    size_t count, i;

    runtimeLock.assertWriting();

    classref_t *classlist = 
        _getObjc2NonlazyClassList(mhdr, &count);
    for (i = 0; i < count; i++) {
        schedule_class_load(remapClass(classlist[i]));
    }
#pragma mark - 我是分割线—————————————————————————————————
    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
        realizeClass(cls);
        assert(cls->ISA()->isRealized());
        add_category_to_loadable_list(cat);
    }
}

  这里面又分两个重要的部分，上面分割线之前是Class中的+load方法加入到对应的list中去，那怎么保证的父类先调用呢

2.3.1 schedule_class_load() & add_class_to_loadable_list()
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
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); 
}
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));
    }
    //往数组中添加loadable_classes结构体，并赋值
    loadable_classes[loadable_classes_used].cls = cls;
    loadable_classes[loadable_classes_used].method = method;
    loadable_classes_used++;
}

  schedule_class_load()方法做了递归调用一直调用到superclass为空，在schedule_class_load()方法中会调用add_class_to_loadable_list。这样就保证了父类的+load方法是加载到list前面的，从父类到子类依次往数组中添加。执行的时候也是从前往后遍历数组调用。
  add_class_to_loadable_list()方法的实现，我们可以很清楚的看到loadable_classes的初始化策略与溢出时的扩容策略。每次需要扩容都会在原来的基础之上*2+16。

2.3.2 add_category_to_loadable_list()
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
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[loadable_categories_used].cat = cat;
    loadable_categories[loadable_categories_used].method = method;
    loadable_categories_used++;
}

  我们来看分割线之后的部分，在Class的+load方法处理完成时候才会来处理Category中的+load方法，这里用到了add_category_to_loadable_list()可以看到与add_class_to_loadable_list()方法的内容基本一样只是标志位和数组的名字不同而已。add_category_to_loadable_list()在Category中的+load方法加入到对应的列表中。至此prepare_load_methods()方法执行完毕。

2.4 call_load_methods()

  接下来我们来看call_load_methods()方法的具体内容

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;

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

  看代码这里还用到了aotureleasePool，这个是题外话了，撇开不谈。我们来看今天的重点，首先是一个do while循环，循环条件有两个。第一个loadable_classes_used（查看文章开头），第二个是call_category_loads()方法的返回值，这个返回值是什么呢，其实就是loadable_categories_used>0。在这里先后调用所有Class列表中的+load方法，Category列表中的+load方法call_class_loads()和call_category_loads()两个方法的代码我就不贴了。代码有点多，影响阅读，有兴趣可以去看runtime的源码。

3. 总结与问题

3.1总结

  分析下来，基本回答了文章开头所述的+load方法特征的原因。总结如下：
  1、Category方法列表的装载是在_read_images的时候发生的，这个调用比较早在map_images之后，load_images前。
  2、+load方法的调用是在load_images是发生的，而且load_image会重复调用（每个类都会调用）。而load_images调在_read_images之后，也就是说是在Category中的方法插入到Class中的方法列表之后调用的。
  3、+load方法的调用是又专门的方法负责的，Class和Category分别有一个数组保存+load方法（数组内保存的是loadable_class，和loadable_category结构体参考文章开头的介绍）。所以不会被Category方法的装载导致方法覆盖。
  4、Class的数组，加入的次序也是有保证的，从最高级的父类到子类一次加入，调用的时候能保证先父类后子类。
  5、Category数组，调用是在Class中的方法列表调用完成之后，保证了次序。

3.2问题

  call_class_loads()的实现比较简单，就是一个for循环依次调用+load。call_category_loads()内部的实现就复杂了不少，还有许多复杂的代码，笔者也是没有太看懂内部的那些判断和循环，也不敢在这里误人子弟。如果有哪位明白的请不吝指教。