首先我们都知道在iOS应用启动的时候会调用所有类和其分类的+load方法。子类的load方法会在父类方法执行完成之后执行，分类的+load会在主类执行之后执行。不可继承，子类没有实现的时候，文件加载的时候是不会调用父类的load方法的。那么为什么+load的方法会有这样的特性，runtime又有哪些巧妙的处理呢。今天我们来刨根问底一下+load方法。
首先解释两个变量和两个结构体，可以先看一眼有个印象，后面遇到再回来仔细察看
//每次调用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方法。
map_images() —>map_images_nolock()—>_read_images()
1.2 _read_images（）
源码较长，这里我只贴对我们有用的部分
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()方法的具体内容
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()
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()
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()
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()方法的具体内容
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()内部的实现就复杂了不少，还有许多复杂的代码，笔者也是没有太看懂内部的那些判断和循环，也不敢在这里误人子弟。如果有哪位明白的请不吝指教。
