Main函数之前的Load
整个运行时初始化时 _objc_init 注册的回调
dyld_register_image_state_change_handler(dyld_image_state_dependents_initialized, 0/not batch/, &load_images);
每当有新的镜像加载之后，都会执行 load_images 方法进行回调，并传入最新镜像的信息列表 infoList：
那么，什么是镜像？
镜像并不是一个 Objective-C 的代码文件，它应该是一个 target 的编译产物。这里注意了 这里用词 编译产物，理所当然的想到了 动态库，下面的打印镜像的信息，镜像的路径，我们看到了动态库
const char * load_images(enum dyld_image_states state, uint32_t infoCount,
const struct dyld_image_info infoList[])
{
bool found;
// Return without taking locks if there are no +load methods here.
found = false;
for (uint32_t i = 0; i < infoCount; i++) {
//Quick scan Load 无论是ClassList还是CategoryList，真就返回，停止遍历
if (hasLoadMethods((const headerType *)infoList[i].imageLoadAddress)) {
found = true;
break;
}
}
if (!found) return nil;
recursive_mutex_locker_t lock(loadMethodLock);
// Discover load methods
{
rwlock_writer_t lock2(runtimeLock);
found = load_images_nolock(state, infoCount, infoList);
}
//上面完成了添加类及分类到loadable_classes及loadable_categories，然后开始执行方法
// Call +load methods
if (found) {
call_load_methods();
}
return nil;
}
bool load_images_nolock(enum dyld_image_states state,uint32_t infoCount,
const struct dyld_image_info infoList[])
{
bool found = NO;
uint32_t i;
i = infoCount;
while (i--) {
const headerType *mhdr = (headerType*)infoList[i].imageLoadAddress;
if (!hasLoadMethods(mhdr)) continue;
//对infoList遍历，如果没有Load方法，继续循环，有就对load 方法的调用进行准备
prepare_load_methods(mhdr);
found = YES;
}
return found;
}
void prepare_load_methods(const headerType *mhdr)
{
size_t count, i;
runtimeLock.assertWriting();
//通过 _getObjc2NonlazyClassList 获取所有的类的列表之后
classref_t *classlist = _getObjc2NonlazyClassList(mhdr, &count);
// 通过 remapClass 获取类对应的指针，调用 schedule_class_load 递归地安排当前类和没有调用 + load 父类进入列表。
for (i = 0; i < count; i++) {
schedule_class_load(remapClass(classlist[i]));
}
// 这里，类与其load方法添加到loadable_classes数组
// 然后添加分类到对应数组
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);实现几乎与 add_class_to_loadable_list 完全相同
}
// 这里我们完成了向loadable_classes及loadable_categories添加类/分类及其load方法
}
static void schedule_class_load(Class cls)
{
if (!cls) return;
assert(cls->isRealized());
if (cls->data()->flags & RW_LOADED) return; 父类如果已经调用 + load 父类则返回
schedule_class_load(cls->superclass); //递归，父类
add_class_to_loadable_list(cls); // 添加将类加入 loadable_classes 集合
// 通过递归，我们知道父类与其load添加在子类之前。
cls->setInfo(RW_LOADED);
}
void call_load_methods(void)
{
static bool loading = NO;
bool more_categories;
loadMethodLock.assertLocked();
if (loading) return;
loading = YES;
void *pool = objc_autoreleasePoolPush();
/*
不停调用类的 + load 方法，直到 loadable_classes 为空
调用一次 call_category_loads 加载分类
如果有 loadable_classes 或者更多的分类，继续循环调用 load 方法
*/
do {
while (loadable_classes_used > 0) {
call_class_loads(); 从 loadable_classes 中取出对应类和方法，执行 load。
}
more_categories = call_category_loads();
} while (loadable_classes_used > 0 || more_categories);
objc_autoreleasePoolPop(pool);
loading = NO;
}
static void call_class_loads(void)
{
int i;
struct loadable_class *classes = loadable_classes;
int used = loadable_classes_used;
loadable_classes = nil;
loadable_classes_allocated = 0;
loadable_classes_used = 0;
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;
(*load_method)(cls, SEL_load); // 调用 +[XXObject load] 方法。
}
if (classes) free(classes);
}
static bool call_category_loads(void)
{
int i, shift;
bool new_categories_added = NO;
// 1. 获取当前可以加载的分类列表
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;
for (i = 0; i < used; i++) {
Category cat = cats[i].cat;
load_method_t load_method = (load_method_t)cats[i].method;
Class cls;
if (!cat) continue;
cls = _category_getClass(cat);
if (cls && cls->isLoadable()) {
// 2. 如果当前类是可加载的 cls && cls->isLoadable() （可能分类的镜像在类的镜像之前加载到运行时，需要判断类是否已经加载到内存中（调用 load 方法） 保证类的Load方法调用在分类之前）
(*load_method)(cls, SEL_load); // 调用分类的 load 方法
cats[i].cat = nil;
}
}
// 3. 将所有加载过的分类移除 loadable_categories` 列表
将移除cat = nil的元素
shift = 0;
for (i = 0; i < used; i++) {
if (cats[i].cat) {
cats[i-shift] = cats[i];
} else {
shift++;
}
}
used -= shift;
// 4. 为 `loadable_categories` 重新分配内存，并重新设置它的值
new_categories_added = (loadable_categories_used > 0);
for (i = 0; i < loadable_categories_used; i++) {
if (used == allocated) {
allocated = allocated*2 + 16;
cats = (struct loadable_category *)
realloc(cats, allocated *
sizeof(struct loadable_category));
}
cats[used++] = loadable_categories[i];
}
if (loadable_categories) free(loadable_categories);
if (used) {
loadable_categories = cats;
loadable_categories_used = used;
loadable_categories_allocated = allocated;
} else {
if (cats) free(cats);
loadable_categories = nil;
loadable_categories_used = 0;
loadable_categories_allocated = 0;
}
return new_categories_added;
}
总结
1 当 Objective-C 运行时初始化的时候，会通过 dyld_register_image_state_change_handler 在每次有新的镜像加入运行时的时候，进行回调。
2 执行 load_images 将所有包含 load 方法的文件加入列表 loadable_classes ，然后从这个列表中找到对应的 load 方法的实现，调用 load 方法
这里我们看到，逻辑很简单先添加类到loadable_classes，然后分类添加到loadable_categories
3 添加顺序（schedule_class_load），父类先于子类，类先于分类，而调用时因为数组有序，父类先于子类调用，又因为代码顺序（call_load_methods），类先于分类调用
