1、load

• 所有类和分类的 +load 方法都是在被加入到 runtime 的时候调用
• 父类优先于子类加载（内部通过递归的的方式实现）
• 在所有本类加载完毕之后再去加载各个分类
• 同一个类的多个分类加载顺序可查看 Target -> Build Phases -> Compile Sources

其中分类的加载顺序和Compile Sources中的位置是一样的。

load追踪

接下来，我们来追踪一下 load 方法的全部处理过程，以便于了解这个函数以及 Objective-C 强大的动态性。

load.png

这里可以看到DDAssignedOrderManager的load调用栈显示栈情况。

追其源头，从 _dyld_start 开始探究。dyld(The Dynamic Link Editor)是 Apple 的动态链接库，系统内核做好启动程序的初始准备后，将其他事务交给 dyld 负责。

什么是images？

在研究 load_images 方法之前，先来研究一下什么是 images。images表示的是二进制文件（可执行文件或者动态链接库.so文件）编译后的符号、代码等。

所以 load_images 的工作是传入处理过后的二进制文件并让 Runtime 进行处理，并且每一个文件对应一个抽象实例来负责加载，这里的实例是 ImageLoader。

ImageLoader 处理二进制文件的时机是在 main 入口函数以前，它在加载文件时主要做两个工作：

• 在程序运行时它先将动态链接的 image 递归加载 （也就是上面测试栈中一串的递归调用的时刻）
• 再从可执行文件 image 递归加载所有符号

研究load_images

接下来看下源码。

// load_images
// 执行 dyld 提供的并且已被 map_images 处理后的 image 中的 +load
// 锁定状态：runtimeLock写操作和 loadMethodLock 方法，保证线程安全
extern bool hasLoadMethods(const headerType *mhdr);
extern void prepare_load_methods(const headerType *mhdr);
void
load_images(const char *path __unused, const struct mach_header *mh) {
    // 没有查询到传入 Class 中的 load 方法，视为锁定状态
    // 则无需给其加载权限，直接返回
    if (!hasLoadMethods((const headerType *)mh)) return;
    // 定义可递归锁对象
    // 由于 load_images 方法由 dyld 进行回调，所以数据需上锁才能保证线程安全
    // 为了防止多次加锁造成的死锁情况，使用可递归锁解决
    recursive_mutex_locker_t lock(loadMethodLock);
    // 收集所有的 +load 方法
    {
        // 对 Darwin 提供的线程写锁的封装类
        rwlock_writer_t lock2(runtimeLock);
        // 提前准备好满足 +load 方法调用条件的 Class
        prepare_load_methods((const headerType *)mh);
    }
    // 调用 +load 方法 (without runtimeLock - re-entrant)
    call_load_methods();
}

这里的hasLoadMethods 是什么呢？其是为了查询 load 函数列表，会分别查询该函数在内存数据段上指定 section 区域是否有所记录。

// 快速查询是否存在 +load 函数列表
bool hasLoadMethods(const headerType *mhdr) {
    size_t count;
    if (_getObjc2NonlazyClassList(mhdr, &count)  &&  count > 0) return true;
    if (_getObjc2NonlazyCategoryList(mhdr, &count)  &&  count > 0) return true;
    return false;
}

objc-file.mm :

// 函数内容是从内存数据段的某个区下查询该位置的情况，并回传指针
#define GETSECT(name, type, sectname)                                   \
    type *name(const headerType *mhdr, size_t *outCount) {              \
        return getDataSectiontype>(mhdr, sectname, nil, outCount);     \
    }                                                                   \
    type *name(const header_info *hi, size_t *outCount) {               \
        return getDataSectiontype>(hi->mhdr(), sectname, nil, outCount); \
    }
// 根据 dyld 对 images 的解析来在特定区域查询内存
GETSECT(_getObjc2ClassList,           classref_t,      "__objc_classlist");
GETSECT(_getObjc2NonlazyCategoryList, category_t *,    "__objc_nlcatlist");

__objc_classlist 的用途，主要是用在访问 Objective-C 的类列表。
__objc_nlcatlist 用于访问 Objective-C 的 +load 函数列表，比 __mod_init_func 更早被执行。

这一块对类信息的解析是由 dyld 处理时期完成的，也就是我们上文提到的 map_images 方法的解析工作。而且从侧面可以看出，Objective-C 的强大动态性，与 dyld 前期处理密不可分。

prepare_load_methods

void prepare_load_methods(header_info *hi) 函数，在该函数中准备好 类和分类执行 +load 方法的必要条件，以供接下来的调用:

void prepare_load_methods(const headerType *mhdr) {
    size_t count, i;
    runtimeLock.assertWriting();
    // 收集 Class 中的 +load 方法
    // 获取所有的类的列表
    classref_t *classlist = 
        _getObjc2NonlazyClassList(mhdr, &count);
    for (i = 0; i  count; i++) {
        // 通过 remapClass 获取类指针
        // schedul_class_load 递归到父类逐层载入
        schedule_class_load(remapClass(classlist[i]));
    }
    // 收集 Category 中的 +load 方法
    category_t **categorylist = _getObjc2NonlazyCategoryList(mhdr, &count);
    for (i = 0; i  count; i++) {
        category_t *cat = categorylist[i];
        // 通过 remapClass 获取 Category 对象存有的 Class 对象
        Class cls = remapClass(cat->cls);
        if (!cls) continue; 
        // 对类进行第一次初始化，主要用来分配可读写数据空间并返回真正的类结构
        realizeClass(cls);
        assert(cls->ISA()->isRealized());
        // 将需要执行 load 的 Category 添加到一个全局列表中
        add_category_to_loadable_list(cat);
    }
}

从代码中可以看出 Class 的 load 方法是优先于 Category。其中在收集 Class 的 load 方法中，因为需要对 Class 关系树的根节点逐层遍历运行，在 schedule_class_load 方法中使用深层递归的方式递归到根节点，优先进行收集。

// 用来规划执行 Class 的 load 方法，包括父类。
// 递归调用 +load 方法。
// 通过 cls 指针以及要求是 cls 指针的 Class 必须已经进行链接操作
static void schedule_class_load(Class cls) {
    if (!cls) return;
    // 查看 RW_REALIZED 是否被标记
    assert(cls->isRealized());
    // 查看 RW_LOADED 是否被标记
    if (cls->data()->flags & RW_LOADED) return;
    // 递归到深层（超类）运行
    schedule_class_load(cls->superclass);
    // 将需要执行 load 的 Class 添加到一个全局列表中
    add_class_to_loadable_list(cls);
    // 标记 RW_LOADED 符号
    cls->setInfo(RW_LOADED); 
}

在 schedule_class_load 中，Class 的读取方式是用 cls 指针方式，其中有很多内存符号位用来记录状态。isRealized() 查看的就是 RW_REALIZED 位，该位记录的是当前 Class 是否初始化一个类的指标。而之后查看的 RW_LOADED 是记录当前类的 +load 方法是否被被调用。

在存储静态表的方法中，方法对象会以指针的方式作为参数传递，然后用名为 loadable_classes 的静态类数组对即将运行的 load 方法进行存储，其下标索引 loadable_classes_used 为（从零开始的）全局量，并在每次录入方法后做自加操作实现索引的偏移。

由此可以看到，在 prepare_load_methods 方法中，Runtime 方法进行了 Class 和 Category 的筛选过滤工作，并且将即将执行的 load 方法以指针的形式组织成了一个线性表结构，为之后执行操作中打下基础。

通过函数指针让 load 方法跑起来

经过加载镜像、缓存类列表后，开始执行 call_load_methods 方法。

void call_load_methods(void) {
    // 是否已经录入
    static bool loading = NO;
    // 是否有关联的 Category
    bool more_categories;
    loadMethodLock.assertLocked();
    // 由于 loading 是全局静态布尔量，如果已经录入方法则直接退出
    if (loading) return;
    loading = YES;
    // 声明一个 autoreleasePool 对象
    // 使用 push 操作其目的是为了创建一个新的 autoreleasePool 对象
    void *pool = objc_autoreleasePoolPush();
    do {
        // 重复调用 load 方法，直到没有
        while (loadable_classes_used > 0) {
            call_class_loads();
        }
        // 调用 Category 中的 load 方法
        more_categories = call_category_loads();
        // 继续调用，直到所有 Class 全部完成
    } while (loadable_classes_used > 0  ||  more_categories);
    // 将创建的 autoreleasePool 对象释放
    objc_autoreleasePoolPop(pool);
    // 更改全局标记，表示已经录入
    loading = NO;
}

call_load_methods仅仅是运行 load 方法的入口。其中最重要的方法 call_class_loads 会从一个待加载的类列表 loadable_classes 中寻找对应的类，并使用 selector(load) 的实现并执行。

static void call_class_loads(void) {
    // 声明下标偏移
    int i;
    // 分离加载的 Class 列表
    struct loadable_class *classes = loadable_classes;
    // 调用标记
    int used = loadable_classes_used;
    loadable_classes = nil;
    loadable_classes_allocated = 0;
    loadable_classes_used = 0;
    // 调用列表中的 Class 类的 load 方法
    for (i = 0; i  used; i++) {
        // 获取 Class 指针
        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);
    }
    // 释放 Class 列表
    if (classes) free(classes);
}

函数指针

#include 
#import 
void run() {
    printf("Hello World\n");
}
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        void (*dy_run)() = run;
        (*dy_run)();
    }
    return 0;
}

这里，我们通过一个 void (*fptr)() 类型的函数指针，将 run 函数获取出，并运行函数。实际上其中的工作是抓取 run 函数的地址并存储在指针变量中。我们通过指针运行对应的地址部分，其效果为执行了 run 函数。

返回方法中的 load_method_t，我们在全局位置发现了该类型的定义：

typedef void(*load_method_t)(id, SEL);

id 参数可以传递一个类信息，这里是将 cls Class 的指针和 SEL 选择子作为参数传入。这样就完成了load 方法的动态调用。

全局 Class 存储线性表数据结构

load调用过程.jpg

我们找到之前的 add_class_to_loadable_list：

void add_class_to_loadable_list(Class cls) {
    // 定义方法指针
    // 目的是构造函数指针
    IMP method;
    loadMethodLock.assertLocked();
    // 通过 cls 中的 getLoadMethod 方法，直接获得 load 方法体存储地址
    method = cls->getLoadMethod();
    // 没有 load 方法直接返回
    if (!method) return;     
    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));
    }
    // 将 Class 指针和方法指针记录
    loadable_classes[loadable_classes_used].cls = cls;
    loadable_classes[loadable_classes_used].method = method;
    // 游标自加偏移
    loadable_classes_used++;
}

在记录过程中，可以看到其 Class 指针和方法指针的记录手段是通过构造 loadable_classes 这个类型的数组进行静态线性表记录。这个类型的数组其数据结构定义如下：

typedef struct objc_class *Class;
struct loadable_class {
    Class cls;
    IMP method;
};

2、Initialize

// 当我们给某个类发送消息的时候，runtime会调用这个函数在类中查找相应方法的实现或转发
#warning 考虑以上特性，说明该类接收到第一条消息之前才会调用 +initialize 方法
IMP lookUpImpOrForward(Class cls, SEL sel, id inst,
                       bool initialize, bool cache, bool resolver)
{
    ...
        rwlock_unlock_write(&runtimeLock);
    }
    # warning 注：当类没有初始化时， runtime 会调用 void _class_initialize(Class cls) 函数对该类进行初始化
    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
    }
 
    // The lock is held to make method-lookup + cache-fill atomic 
    // with respect to method addition. Otherwise, a category could 
    ...
}

接下来看看具体的初始化代码

void _class_initialize(Class cls)
{
    ...
    Class supercls;
    BOOL reallyInitialize = NO;
#warning 同样使用递归的思想实现了先调用父类再调用子类的顺序
    // Make sure super is done initializing BEFORE beginning to initialize cls.
    // See note about deadlock above.
    supercls = cls->superclass;
    if (supercls  &&  !supercls->isInitialized()) {
        _class_initialize(supercls);
    }
 
    // Try to atomically set CLS_INITIALIZING.
    monitor_enter(&classInitLock);
    if (!cls->isInitialized() && !cls->isInitializing()) {
        cls->setInitializing();
        reallyInitialize = YES;
    }
    monitor_exit(&classInitLock);
 
    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());
        }
#warning 注意这里使用了 objc_msgSend，就意味着该方法就和其他普通方法一样，子类要沿用父类的方法，分类会会覆盖本类中的方法。
#warning 同时，如果子类没有实现但父类实现了该方法，那么父类的该方法就要被实现多次
        ((void(*)(Class, SEL))objc_msgSend)(cls, SEL_initialize);
 
        if (PrintInitializing) {
            _objc_inform("INITIALIZE: finished +[%s initialize]",
    ...
}

Category 中 Initialize 方法会覆盖其本类中的方法(和其他普通方法效果一样)
在 Initialize 方法内部可以进行一些不方便在编译期进行初始化的静态变量的赋值

参考。