iOS开发之 runtime(36) ：load 方法加载
logo
本系列博客是本人的源码阅读笔记，如果有 iOS 开发者在看 runtime 的，欢迎大家多多交流。为了方便讨论，本人新建了一个微信群(iOS技术讨论群)，想要加入的，请添加本人微信：zhujinhui207407，【加我前请备注：ios 】，本人博客http://www.kyson.cn 也在不停的更新中，欢迎一起讨论
本文完整版详见笔者小专栏：https://xiaozhuanlan.com/runtime
前言
load 方法中的最后一个函数：
_dyld_objc_notify_register(&map_2_images, load_images, unmap_image);
告诉我们，第一步是 map_2_images，第二步就是 load_images。笔者前面的文章也已经分析过，将文件或者类从 mach-o 里读出来后，进行 remap 等操作后放入相应的 hashmap 中，其实是做了第一步：缓存，为了方便后面调用。而第二步 load_images，则是调用 load 方法。本文将给大家慢慢揭开 load 方法的神秘面纱。
分析
load_images 方法的实现如下：
void load_images(const char *path __unused, const struct mach_header *mh) {
if (!hasLoadMethods((const headerType *)mh)) return;
prepare_load_methods((const headerType *)mh);
call_load_methods();
}
去掉一些无关逻辑（主要是锁操作和注释）可以看出其实该方法就是两部操作：
- 调用 load 方法之前的一些准备工作
- 开始调用 load 方法
大家可能会有一些困惑
- load 方法之前的 prepare，究竟 prepare 的是什么？为什么要准备？
- 调用的大概顺序是什么？比如类 A 和 类 A 的父类都实现了 load 方法，甚至还有其 category 都实现了，那顺序是怎么样的？下面笔者带大家抽丝剥茧看代码。
准备操作
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]));
}
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);
}
}
相信看过之前文章的读者应该对
_getObjc2NonlazyClassList
这个方法很熟悉了，作用就是获取所有拥有 load 方法的类（class）。
而
_getObjc2NonlazyCategoryList
同理可证，是获取所有拥有 load 方法的 分类（category）。
所以这是第一步：取出所有的 load 方法的类或者分类。
至此我们开篇提出的几个问题，估计大家可能应该有一点答案了：
- 比如类 A 和 类 A 的父类都实现了 load 方法，甚至还有其 category 都实现了，那顺序是怎么样的？
因为先加载_getObjc2NonlazyClassList后加载_getObjc2NonlazyCategoryList所以，感觉上应该是先调用当前类的 load 方法，再调用 category 的 load 方法，那事实是不是这样呢？我们继续分析代码。
上面不管是 _getObjc2NonlazyClassList还是_getObjc2NonlazyCategoryList后面都有接下来的操作，我们对这两个后面的代码做分析：
for (i = 0; i < count; i++) {
schedule_class_load(remapClass(classlist[i]));
}
这段，先 remap 再调用 schedule_class_load所以，remap 大家很熟悉了不做过多介绍了。我们进入 schedule_class_load 看一下：
/***********************************************************************
* prepare_load_methods
* Schedule +load for classes in this image, any un-+load-ed
* superclasses in other images, and any categories in this image.
**********************************************************************/
// Recursively schedule +load for cls and any un-+load-ed superclasses.
// cls must already be connected.
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);
}
从以上代码可以看出来，其实 schedule_class_load 只是将 cls 通过一个方法add_class_to_loadable_list加到一个列表里,等一下！为什么又调用了自身：
// Ensure superclass-first ordering
schedule_class_load(cls->superclass);
是不是意味着，先调用父类的 load 方法，再调用自身的？！
继续分析方法 add_class_to_loadable_list：
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_used].cls = cls;
loadable_classes[loadable_classes_used].method = method;
loadable_classes_used++;
}
我们可以发现，最终将所有拥有 load 方法的类都加到静态对象 loadable_classes中：
// List of classes that need +load called (pending superclass +load)
// This list always has superclasses first because of the way it is constructed
static struct loadable_class *loadable_classes = nil;
static int loadable_classes_used = 0;
static int loadable_classes_allocated = 0;
类似的 category 的也有类似的方法：
/***********************************************************************
* add_category_to_loadable_list
* Category cat's parent class exists and the category has been attached
* to its class. Schedule this category for +load after its parent class
* becomes connected and has its own +load method called.
**********************************************************************/
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_used].cat = cat;
loadable_categories[loadable_categories_used].method = method;
loadable_categories_used++;
}
以及静态变量：
// List of categories that need +load called (pending parent class +load)
static struct loadable_category *loadable_categories = nil;
static int loadable_categories_used = 0;
static int loadable_categories_allocated = 0;
总结
如果后面的调用方法和按我们这里加载进类列表的顺序一致的话，我们可以得出如下结论：
调用的大概顺序是：比如类 A 和 类 A 的父类都实现了 load 方法，甚至还有其 category 都实现了，那顺序是先调用 A 的父类的 load 方法，再调用他的或者他自己的 category 的 load 方法。
这可能就是 load 方法调用时机问题。
