iOS认识load方法

意识到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;
}