三个问题：
- 类、分类、父类的+(void)load方法调用顺序？
- load是如何加载的？
- load是如何被调用的？
我们来先看事例，再从源码剖析加载和调用构成。
创建一个Person、Person的两个分类、Son继承于Person，它们的.m全都重写+(void)load并答应方法名，此时的资源文件的顺序是：
来看看打印结果：
2021-12-23 17:40:05.125728+0800 Test[2936:87778] +[Person load]
2021-12-23 17:40:05.126166+0800 Test[2936:87778] +[Son load]
2021-12-23 17:40:05.126246+0800 Test[2936:87778] +[Person(Test1) load]
2021-12-23 17:40:05.126319+0800 Test[2936:87778] +[Person(Test2) load]
结论一：
类、分类、父类的+(void)load方法调用顺序：
父类 > 类 > 分类
结论二：
所有的类都会走一次load方法
分类的load并不会覆盖本类的load
load的加载过程
从源码中的万物之始_objc_init函数开始：
void _objc_init(void)
{
static bool initialized = false;
if (initialized) return;
initialized = true;
// fixme defer initialization until an objc-using image is found?
environ_init();
tls_init();
static_init();
lock_init();
exception_init();
_dyld_objc_notify_register(&map_images, load_images, unmap_image);
}
我们加载镜像文件在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就是load调用前加载过程
call_load_methods就是load的调用过程
直接来看load是如何被加载的：
void prepare_load_methods(const headerType *mhdr)
{
size_t count, i;
runtimeLock.assertWriting();
// runtime获得类对象的列表，因为这是系统级别的函数，classlist中类的顺序与类的编译顺序相同。
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());
// 分类load的加载
add_category_to_loadable_list(cat);
}
}
从源码中看出来类对象和分类是分开处理的。
类的load方法加载过程
从prepare_load_methods中拿到类加载相关代码：
// runtime获得类对象的列表，因为这是系统级别的函数，classlist中类的顺序与类的编译顺序相同。
classref_t *classlist =
_getObjc2NonlazyClassList(mhdr, &count);
for (i = 0; i < count; i++) {
//定制/规划类的加载
schedule_class_load(remapClass(classlist[i]));
}
先是拿到classlist，然后递归调用schedule_class_load，看看这个方法里都做了啥事儿：
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()，对当前类（也就是函数传入的参数）的父类进行处理。
经过这样的整理之后，最终整理过的装载类对象相关信息的数组中，父类应该排在子类前面。而不同的类对象之间在数组中的位置，就可以参考它们.m的编译顺序来看了。
每个类对象在被加入数组的时候，会通过 cls->setInfo(RW_LOADED); 设置标签标记一下，这样，如果该类下次被作为父类进行递归调用的时候，就不会重复加入到列表中，保证一个类在数组中只出现一次。
最后再看一下add_class_to_loadable_list(cls);里面的逻辑：
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++;
}
method = cls->getLoadMethod();获取load方法的imp，从哪里获取呢？从data()->ro里遍历方法列表获取:
IMP
objc_class::getLoadMethod()
{
runtimeLock.assertLocked();
const method_list_t *mlist;
assert(isRealized());
assert(ISA()->isRealized());
assert(!isMetaClass());
assert(ISA()->isMetaClass());
mlist = ISA()->data()->ro->baseMethods();
if (mlist) {
for (const auto& meth : *mlist) {
const char *name = sel_cname(meth.name);
if (0 == strcmp(name, "load")) {
return meth.imp;
}
}
}
return nil;
}
再返回来看看add_class_to_loadable_list下面，把一个cls(类对象) 和 method(load的imp) 赋值给了loadable_classes数组，来看看loadable_classes的数据结构:
struct loadable_class {
Class cls; // may be nil 类对象
IMP method; // load的imp
};
所以类的load方法的加载就是存储在loadable_class这个结构体里边。
分类的load方法加载过程
从prepare_load_methods中拿到分类加载相关代码：
// runtime获取分类镜像列表，根据资源文件顺序加载
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());
// 分类load的加载
add_category_to_loadable_list(cat);
}
直接通过系统函数_getObjc2NonlazyCategoryList拿到分类的集合categorylist，对分类来说，不存在谁是谁的父类，大家都是平级的。
remapClass做的是哈希表重映射。
realizeClass首先做分配rw数据，然后对类的父类和类的元类更新以防重映射，最后把分类的数据粘到类里(注意并不是覆盖)，该过程可以看Category底层原理。
只需将categorylist里面的分类对象一个一个拿出来，通过add_category_to_loadable_list方法处理好，一个一个加入到我们后面调用+load方法时所用的loadable_categories数组里面。
add_category_to_loadable_list里面做的事情：
void add_category_to_loadable_list(Category cat)
{
IMP method;
loadMethodLock.assertLocked();
// 拿到load的imp
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++;
}
该方法和类的加载过程add_class_to_loadable_list是一样的逻辑，只是把分类的load方法添加到loadable_categories。
而loadable_categories的数据结构也是一样的：
struct loadable_category {
Category cat; // may be nil 分类
IMP method; // load的imp
};
所以分类的load方法的加载就是存储在loadable_category这个结构体里边。
load的调用过程
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();
}
load方法加载完成后，就是调用过程了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;
}
先创建了自动释放池，在末尾销毁池。中间穿插一大一小的do...while循环。
先是call_class_loads执行完后，然后才是call_category_loads。
这就是类的load方法调用和分类的load方法调用。
类的load方法调用过程
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(classes);
}
我们知道在上面全部类的load方法加载到loadable_classes数组里，现在就会从这里取出来，拿到cls和method；通过直接调用的方式:(*load_method)(cls, SEL_load); 执行了load方法；最后把数组释放掉。
注意一：调用load方法不是用消息发送机制！！
注意二：类的load方法装是父类优先，调用也是父类优先!
分类的load方法调用过程
static bool call_category_loads(void)
{
int i, shift;
bool new_categories_added = NO;
// Detach current loadable list.
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;
// Call all +loads for the detached list.
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()) {
if (PrintLoading) {
_objc_inform("LOAD: +[%s(%s) load]\n",
cls->nameForLogging(),
_category_getName(cat));
}
(*load_method)(cls, SEL_load);
cats[i].cat = nil;
}
}
// Compact detached list (order-preserving)
shift = 0;
for (i = 0; i < used; i++) {
if (cats[i].cat) {
cats[i-shift] = cats[i];
} else {
shift++;
}
}
used -= shift;
// Copy any new +load candidates from the new list to the detached list.
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];
}
// Destroy the new list.
if (loadable_categories) free(loadable_categories);
// Reattach the (now augmented) detached list.
// But if there's nothing left to load, destroy the list.
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;
}
if (PrintLoading) {
if (loadable_categories_used != 0) {
_objc_inform("LOAD: %d categories still waiting for +load\n",
loadable_categories_used);
}
}
return new_categories_added;
}
1.Detach current loadable list.分离可加载category列表，也就是把可加载列表的信息保存到本函数的局部变量cats数组上；
2.Call all +loads for the detached list.消费cats里面的所有+load方法（也就是调用它们）；
3.Compact detached list (order-preserving) 清理cats里面已经被消费过的成员，并且更新used计数值；
4.Copy any new +load candidates from the new list to the detached list.如果又出现了新的可加载的分类，将其相关内容复制到cats列表上。
5.Destroy the new list.销毁列表（这里指的是外部的loadable_categories变量）
6.Reattach the (now augmented) detached list. But if there's nothing left to load, destroy the list.更新几个记录了category +load 信息的几个全局变量。
总结
程序启动之后，
Runtime会在镜像加载阶段进行处理，先调用所有类对象的+load方法，然后在调用所有分类的+load方法，类对象与分类之间参与编译顺序。
Runtime对于+load方法的调用，不是走的我们熟悉的“消息发送”路线，而是直接拿到+load方法的IMP，直接调用。
因此不存在所谓 “类的方法被category的方法覆盖” 的问题。
调用一个
类对象的+load方法之前，会先调用其父类的+load方法（如果存在的话），类与类之间，会按照编译的顺序，先后调用其+load方法。一个类对象的+load方法不会被重复调用，只可能被调用一次。
分类的
+load方法，会按照分类参与编译的顺序，先编译，后执行。
所以我们的类/分类越多，我们的app启动就会越慢！
关于app启动可以看我分享这篇iOS启动优化
。