意识到load方法是因为最近学习Method Swilzzing时发现与其它的系统方法不同。 当时创建了一个UIViewController的catagory并重写了load方法。
在这篇文章中指出:
+ load 作为 Objective-C 中的一个方法,与其它方法有很大的不同。只是一个在整个文件被加载到运行时,在 main 函数调用之前被 ObjC 运行时调用的钩子方法。其中关键字有这么几个:
- 文件刚加载
- main 函数之前
- 钩子方法
针对提问进行整理学习
Q1:load 方法是如何被调用的?
A1:当 Objective-C 运行时初始化的时候,会通过 dyld_register_image_state_change_handler 在每次有新的镜像加入运行时的时候,进行回调。执行 load_images 将所有包含 load 方法的文件加入列表 loadable_classes ,然后从这个列表中找到对应的 load 方法的实现,调用 load 方法。
Q2:load 方法会有为我们所知的这种调用顺序?
规则一:父类先于子类调用
规则二:类先于分类调用
A2:分析 schedule_class_load 和 call_load_methods 可得。
// 在系统内核做好程序准备工作之后,交由 dyld(是the dynamic link editor 的缩写,它是苹果的动态链接器) 负责余下的工作。
// 1、首先在整个运行时初始化时 _objc_init 注册的回调
dyld_register_image_state_change_handler(dyld_image_state_dependents_initialized, 0/*not batch*/, &load_images);
// 2、每当有新的镜像加载到 runtime 时,都会执行 load_images 方法进行回调,并传入最新镜像的信息列表 infoList
const char * load_images(enum dyld_image_states state, uint32_t infoCount, const struct dyld_image_info infoList[]) {
bool found;
found = false;
for (uint32_t i = 0; i < infoCount; i++) {
if (hasLoadMethods((const headerType *)infoList[i].imageLoadAddress)) {
// 3、如果在扫描镜像的过程中发现了 + load 符号
found = true;
break;
}
}
if (!found) return nil;
recursive_mutex_locker_t lock(loadMethodLock);
{
rwlock_writer_t lock2(runtimeLock);
// 4、会进入 load_images_nolock 来查找 load 方法
found = load_images_nolock(state, infoCount, infoList);
}
if (found) {
// 7、在将镜像加载到运行时、对 load 方法的准备就绪之后,执行 call_load_methods 开始调用 load 方法
call_load_methods();
}
return nil;
}
// 4、调用 load_image_nolock
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;
// 5、调用 prepare_load_methods 对 load 方法的调用进行准备
prepare_load_methods(mhdr);
found = YES;
}
return found;
}
// 5、调用 prepare_load_methods(将需要调用 load 方法的类添加到一个列表中)
void prepare_load_methods(const headerType *mhdr) {
size_t count, i;
runtimeLock.assertWriting();
/* 通过 _getObjc2NonlazyClassList 获取所有的类的列表 */
classref_t *classlist = _getObjc2NonlazyClassList(mhdr, &count);
for (i = 0; i < count; i++) {
// 6、调用 schedule_class_load 递归地安排当前类和没有调用 load 的父类进入列表
/* 通过 remapClass 获取类对应的指针 */
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);
}
}
// 6、调用 schedule_class_load (红色代码保证了父类在子类前面调用 load 方法)
static void schedule_class_load(Class cls) {
if (!cls) return;
assert(cls->isRealized());
if (cls->data()->flags & RW_LOADED) return;
/* 先把父类加入待加载的列表 */
schedule_class_load(cls->superclass);
/* 再执行 add_class_to_loadabel_list 将当前类也加入进去 */
add_class_to_loadable_list(cls); ---------------------------------------》得出规则一
cls->setInfo(RW_LOADED);
}
// 其中 add_class_to_loadable_list 添加到待加载的类的列表
void add_class_to_loadable_list(Class cls) {
IMP method;
loadMethodLock.assertLocked();
method = cls->getLoadMethod();
if (!method) return;
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++;
}
// 其中 add_category_to_loadable_list 添加到待加载的分类的列表
void add_category_to_loadable_list(Category cat) {
IMP method;
loadMethodLock.assertLocked();
method = _category_getLoadMethod(cat);
if (!method) return;
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++;
}
// 7、调用 call_load_methods
void call_load_methods(void) {
...
do {
while (loadable_classes_used > 0) {
call_class_loads();
}
more_categories = call_category_loads(); --------------------------------》得出规则二
} while (loadable_classes_used > 0 || more_categories);
...
}
// 其中call_class_loads 会从一个待加载的类列表 loadable_classes 中寻找对应的类,然后找到 @selector(load) 的实现并执行。
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);
}
补充:
1)什么是镜像?
2)由上得出
load_images -> load_images_nolock -> prepare_load_methods -> schedule_class_load -> add_class_to_loadable_list
的调用过程。ObjC 对于加载的管理主要使用了两个列表,分别是 loadable_classes 和 loadable_categories。其中的add_class_to_loadable_list就是将未加载的类添加到 loadable_classes 数组中,add_category_to_loadable_list实现几乎相同
3)相比于类 load 方法的调用,分类中 load 方法的调用就有些复杂了
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_method)(cls, SEL_load);
cats[i].cat = nil;
}
}
// 3. 将所有加载过的分类移除 `loadable_categories` 列表
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;
}