网上有很多关于 +load 和 +initialize 实现的，每次都是看过理解之后，没多久就忘记了，所以在此记录一下自己对 +load 和 +initialize 的理解
+load
- 在程序启动时 系统会调用
void _objc_init(void)函数，函数中通过_dyld_objc_notify_register(&map_images, load_images, unmap_image);注册了一个通知，在有新的镜像加入时，会进行回调。其中load_images就是执行 +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_images中 主要有两部分：prepare_load_methodscall_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
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方法中利用递归按顺序遍历父类 保证保证最顶层的类放在数组的在前面 （所以不需要手动调用父类方法 系统会自动调用 ） - 所有类、和+load 函数指针(重点 是函数指针 调用时不通过 objc_msgsend) 保存为结构体 放入 loadable_classes 数组中
- RW_LOADED 标志类有没有加入到 数组中 ，保证不会重复添加。
- 所有类别会按顺序加入 loadable_categories 数组中 同类一样 会直接使用+load 函数指针
- 函数中判断了是否存在了 +load 方法 不存在不会添加 （所以 没有实现+ load方法 就不会调用）
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();函数内部 顺序遍历loadable_classes 执行+load方法 保证了 父类先于子类调用 - 其次调用
call_category_loads()方法 顺序遍历 loadable_categories 然后通过cls->isLoadable()判断所属于的类 是否已经调用过 +load方法 1、已经调用则 调用类别+load方法 并从数组中移除 2、没有调用 则保留类别等待下次调用此函数在进行调用 此方法保证了 类别的+load一定在 所属类的 +load调用后才进行 - 以上方法保证了 +load 执行顺序 父类 -> 子类 -> 类别
- 至此 +load方法 执行完毕 通过上述分析 得出结论：
- 在镜像加载时 自动调用
- 执行顺序 父类 -> 子类 -> 类别
- 不用显示调用 并且直接通过函数指针调用 不通过 objc_msgsend，所以如果没有实现+load方法 则不会进行调用
- 通过 RW_LOADED 来控制只会调用一次
+initialize
initialize 只会在对应类的方法第一次被调用时，才会调用。
0 +[XXObject initialize]
1 _class_initialize
2 lookUpImpOrForward
3 _class_lookupMethodAndLoadCache3
4 objc_msgSend
5 main
6 start
通过函数调用栈发现 主要实现方法在 _class_initialize 中
void _class_initialize(Class cls)
{
Class supercls;
BOOL reallyInitialize = NO;
// 1. 强制父类先调用 initialize 方法
supercls = cls->superclass;
if (supercls && !supercls->isInitialized()) {
_class_initialize(supercls);
}
{
// 2. 通过加锁来设置 RW_INITIALIZING 标志位
monitor_locker_t lock(classInitLock);
if (!cls->isInitialized() && !cls->isInitializing()) {
cls->setInitializing();
reallyInitialize = YES;
}
}
if (reallyInitialize) {
// 3. 成功设置标志位，向当前类发送 +initialize 消息
_setThisThreadIsInitializingClass(cls);
((void(*)(Class, SEL))objc_msgSend)(cls, SEL_initialize);
// 4. 完成初始化，如果父类已经初始化完成，设置 RW_INITIALIZED 标志位，
// 否则，在父类初始化完成之后再设置标志位。
monitor_locker_t lock(classInitLock);
if (!supercls || supercls->isInitialized()) {
_finishInitializing(cls, supercls);
} else {
_finishInitializingAfter(cls, supercls);
}
return;
} else if (cls->isInitializing()) {
// 5. 当前线程正在初始化当前类，直接返回，否则，会等待其它线程初始化结束后，再返回
if (_thisThreadIsInitializingClass(cls)) {
return;
} else {
monitor_locker_t lock(classInitLock);
while (!cls->isInitialized()) {
classInitLock.wait();
}
return;
}
} else if (cls->isInitialized()) {
// 6. 初始化成功后，直接返回
return;
} else {
_objc_fatal("thread-safe class init in objc runtime is buggy!");
}
}
- 注释已经很详细 同样是使用递归 保证父类先于子类的顺序调用 （所以也不需要手动调用父类方法）
- RW_INITIALIZED 保证只执行一次 （只是针对这里执行一次）
void callInitialize(Class cls)
{
((void(*)(Class, SEL))objc_msgSend)(cls, SEL_initialize);
asm("");
}
- 通过上述方法发现 系统通过 objc_msgSend 来调用 initialize 方法
- 如果 运行时特性 类别方法会添加到类方法前面 且如果没有方法实现会自动查找父类实现 所以initialize 方法可能会调用多次 并且分类实现会覆盖类的实现 子类没有实现会自动调用父类实现 之前说的只调用一次 其实只是针对类本身只调用一次 但是有可能被子类触发 所以也会调用多次
至此 +initialize方法 执行完毕 通过上述分析 得出结论：
- 执行顺序 父类 -> 子类 类别会覆盖类的实现 子类没有实现会继承父类实现 导致initialize多次调用
- 不用显示调用 通过 objc_msgsend，所以如果没有实现+initialize方法 会继承父类实现
- 通过 RW_INITIALIZED 来控制 相对于本身只 初始化一次
最后 总结+load +initialize 的相同点与不同点
- 相同点
- 都是类方法
- 都不需要显示调用，系统会自动调用
- 不用显示调用父类方法
- 不同点
- 调用时机不同。 + load 是程序启动 新的镜像被加载到 runtime 时，回调 load_images 方法里面进行调用、 + initialize 只会在对应类的方法第一次被调用时，才会调用。
- 调用方式不同。 +load 是直接获取 IMP 来执行，不同通过消息查找和转发 ，+ initialize通过objc_msgsend调用 会通过runtime进行消息发送
- 调用顺序不同 +load 父类 -> 子类 -> 类别 。 + initialize 父类 -> 子类, 类别会覆盖类的实现 子类没有实现会继承父类实现
- +load 不会继承父类实现，如果没有实现就不调用 + initialize 会继承父类实现，没有实现就使用父类方法
- 调用次数不同 + load 只会调用一次 + initialize 可能会调用多次
注意 上述所说 不会继承 只是针对系统的自动调用 不会主动沿用父类实现 如果手动通过 [xxx load]、[xxx initialize] 发消息与普通消息保持一致
参考博客
