我们知道，iOS App的 main() 函数位于 main.m 中，这是我们熟知的程序入口，但是在这之前， 还要先进行加载 framework 、初始化 runtime 等操作, framework 的加载是由 dylb 调用的，关于 dylb ，这里不作探讨，感兴趣的同学可以看看这篇文章(dyld: Dynamic Linking On OS X )。本文结合 runtime 源码，对类的加载和初始化中涉及到的两个方法 +load和+initialize 进行探讨，了解他们的调用时机和调用方式，
所用到的runtime源码为objc4-680.tar.gz 。
load
runtime 的初始化函数在 objc-os.mm 中的 _objc_init 中, 这个方法在 old-ABI 中是由 dylb 在初始化动态链接库的时候调用的，现在是由 libSystem 在动态链接库初始化之前调用的：
/***********************************************************************
* _objc_init
* Bootstrap initialization. Registers our image notifier with dyld.
* Old ABI: called by dyld as a library initializer
* New ABI: called by libSystem BEFORE library initialization time
**********************************************************************/
void _objc_init(void)
{
......
// Register for unmap first, in case some +load unmaps something
_dyld_register_func_for_remove_image(&unmap_image);
dyld_register_image_state_change_handler(dyld_image_state_bound,
1/*batch*/, &map_2_images);
dyld_register_image_state_change_handler(dyld_image_state_dependents_initialized, 0/*not batch*/, &load_images);
}
在这里， runtime 先会调用 map_2_images 方法, 加载 images 到内存中， category 中扩展的属性和方法就是在这个时候附加到类上的，这将在后续的文章中进行探讨。然后会调用 load_images 这个方法：
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;
......
// Discover load methods
{
rwlock_writer_t lock2(runtimeLock);
//先load images
found = load_images_nolock(state, infoCount, infoList);
}
// Call +load methods (without runtimeLock - re-entrant)
if (found) {
//然后调用类的+load方法
call_load_methods();
}
return nil;
}
load_images 在这个方法里先是调用 load_images_nolock 方法, 在这个方法里会调用 prepare_load_methods 方法去准备好要被调用的 +load 方法，我们先来看下 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);
}
}
在这里，先是 schedule_class_load(Class cls) 方法去准备好所有满足 ＋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);
}
当 prepare_load_methods 函数执行完之后，所有满足 +load 方法调用条件的类和分类就被分别保存在全局变量 loadable_classes 和 loadable_categories 中了。
准备好类和分类之后，接下来就是对他们的 ＋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;
}
在这个方法里，会以类优先于分类的顺序调用 +load 方法
这里有两个关键的函数 call_class_loads() 和 call_category_loads
这两个函数会遍历上一步中准备好的 loadable_classes 和 loadable_categories 的 ＋load 方法，需要注意的是他们都是以函数内存地址的方式 ((*load_method)(cls, SEL_load)) 对 ＋load 方法进行调用的，而不是使用发送消息 objc_msgSend 的方式.
这样的调用方式就使得
+load方法拥有了一个特性，那就是子类、父类和分类中的+load方法的实现是被区别对待的。也就是说如果子类没有实现 +load 方法，那么当它被加载时runtime是不会去调用父类的+load方法的。同理，当一个类和它的分类都实现了+load方法时，两个方法都会被调用，多个分类实现了+load方法时，每个分类的＋load方法都会被调用。
initialize
+initialize 方法是在类或类的子类收到第一条消息之前被调用的，这里所指的消息包括实例方法和类方法的调用。
也就是说 ＋initialize 方法是以懒加载的方式被调用的，如果一直没有给一个类或他的子类发送消息，那么这个类的 ＋initialize 方法是永远不会调用的。
当我们向某个类发送消息时，runtime 会调用 IMP lookUpImpOrForward(...) 这个函数在类中查找相应方法的实现或进行消息转发，打开 objc-runtime-new.h 找到这个函数：
IMP lookUpImpOrForward(Class cls, SEL sel, id inst,
bool initialize, bool cache, bool resolver)
{
Class curClass;
IMP imp = nil;
...
if (initialize && !cls->isInitialized()) {
// 类没有初始化时，对类进行初始化
_class_initialize (_class_getNonMetaClass(cls, inst));
// If sel == initialize, _class_initialize will send +initialize and
// then the messenger will send +initialize again after this
// procedure finishes. Of course, if this is not being called
// from the messenger then it won't happen. 2778172
}
...
}
从中可以看到当类没有初始化时，会调用 _class_initialize(Class cls) 对类进行初始化：
void _class_initialize(Class cls)
{
assert(!cls->isMetaClass());
Class supercls;
BOOL reallyInitialize = NO;
// Make sure super is done initializing BEFORE beginning to initialize cls.
// See note about deadlock above.
supercls = cls->superclass;
// 递归调用，对父类进行_class_initialize调用，确保父类的initialize方法比子类先调用
if (supercls && !supercls->isInitialized()) {
_class_initialize(supercls);
}
......
if (reallyInitialize) {
// We successfully set the CLS_INITIALIZING bit. Initialize the class.
// Record that we're initializing this class so we can message it.
_setThisThreadIsInitializingClass(cls);
// Send the +initialize message.
// Note that +initialize is sent to the superclass (again) if
// this class doesn't implement +initialize. 2157218
if (PrintInitializing) {
_objc_inform("INITIALIZE: calling +[%s initialize]",
cls->nameForLogging());
}
// 发送调用类方法initialize的消息
((void(*)(Class, SEL))objc_msgSend)(cls, SEL_initialize);
......
}
在这里，先是对入参的父类进行递归调用，以确保父类优先于子类初始化
还有一个关键的地方： runtime 使用了发送消息 objc_msgSend 的方式对 ＋initialize 方法进行调用，这样， ＋initialize 方法的调用就与普通方法的调用是一致的，都是走的发送消息的流程，所以，如果子类没有实现 ＋initialize 方法，将会沿着继承链去调用父类的 ＋initialize 方法，同理，分类中的 ＋initialize 方法会覆盖原本类的方法。
虽然对每个类只会调用一次 _class_initialize(Class cls) 方法，但是由于 +initialize 方法的调用走的是消息发送的流程，当某个类有多个子类时，这个类的 ＋initialize 方法有可能会被多次调用，这时，可能需要在 ＋initialize 方法中判断是否是由子类调用的:
+ (void)initialize{
if (self == [ClassName class]) {
......
}
}
总结：
+load方法在类加载时被调用，+initialize方法在类收到第一条消息时调用,可能永远不会调用两个方法的调用顺序都是先父类后子类，
+load方法在runtime中是直接以函数地址的方式进行调用，如果有多个分类，所有分类的＋load方法也会被调用，并且在类的＋load方法之后被调用，多个分类的＋load方法调用顺序取决于编译的顺序＋initialize方法在runtime中是以发送消息的方式调用的，所以子类会覆盖父类的实现，分类会覆盖类的实现，多个分类只会调用一个分类的+initialize方法。
参考链接
本文出自 kingizz's blog － Objective-C Runtime(三)类的加载与初始化 转载请注明出处。
