Objective-C中+initialize方法的调用历程

1、分析`objc-initialize.mm`文件

关于+initialize方法的大部分操作，Runtime 封装在文件objc-initialize.mm中。想要了解+initialize方法的调用流程，首先需要了解一下关于+initialize方法的功能函数！！

1.1、结构变量 `_objc_initializing_classes`

1.1.1、题外话：线程存储

我们知道：一个进程中线程除了线程自己的栈和寄存器之外，其他几乎都是共享的；如果线程想维护一个只属于线程自己的全局变量怎么办？线程的私有存储解决了这个问题！！

线程存储: 用于线程维护只属于它自己的全局变量！

在 Runimt 中，线程存储的数据被封装在结构体_objc_pthread_data：

typedef struct {
    struct _objc_initializing_classes *initializingClasses; // for +initialize
    struct SyncCache *syncCache; 
    struct alt_handler_list *handlerList;  
    char *printableNames[4];  
} _objc_pthread_data;

在本篇中，我们主要用到了结构成员 initializingClasses：用于存储正在初始化的 Class

1.1.2、结构变量 `_objc_initializing_classes`

typedef struct _objc_initializing_classes {
    int classesAllocated; //数组 metaclasses 的元素数量
    Class *metaclasses;// 元类数组：分配的内存大小为 (classesAllocated * sizeof(Class)) 字节
} _objc_initializing_classes;

专门用于线程存储的数据 _objc_pthread_data 的一个结构成员；在每个线程都会有该线程自己的特定数据 _objc_initializing_classes；
结构体实例 _objc_initializing_classes 在创建的时候，metaclasses的内存空间同时初始化；因此不必担心 metaclasses 上存在垃圾数据；
在一个线程上初始化一个类，即 class_rw_t -> flags = RW_INITIALIZING 时： Runtime 会将该类的元类存储至元类数组 metaclasses 中的空闲内存上；
如果 metaclasses 已经存储满，则将数组元素数量 classesAllocated 变大一倍，然后扩容 metaclasses 并初始化未使用的内存；
在一个线程上一个类完成初始化，即 class_rw_t -> flags = ISINITIALIZED 时： Runtime 会立即将该类的元类从 metaclasses 上移除；

1.1.3、获取该线程存储的`_objc_initializing_classes`

static _objc_initializing_classes *_fetchInitializingClassList(bool create){
    _objc_pthread_data *data;//线程存储的数据
    _objc_initializing_classes *list;
    Class *classes;
    
    data = _objc_fetch_pthread_data(create);//获取线程存储数据
    if (data == nil) return nil;
    
    list = data->initializingClasses;
    if (list == nil) {
        if (!create) {
            return nil;
        } else {
            list = (_objc_initializing_classes *)calloc(1, sizeof(_objc_initializing_classes));
            data->initializingClasses = list;
        }
    }
    
    classes = list->metaclasses;
    if (classes == nil) {//如果元类数组不存在，分配元类数组
        list->classesAllocated = 4;// 在 realloc() 之前，在此线程上允许4个类同时inits。
        classes = (Class *)calloc(list->classesAllocated, sizeof(Class));
        list->metaclasses = classes;
    }
    return list;
}

该函数的主要功能就是获取该线程存储的_objc_initializing_classes，可能存在一些特殊情况：

1、有可能在调用该函数时，线程存储的数据并没有创建；这时使用入参create判断是否需要创建 _objc_pthread_data；
2、获取_objc_pthread_data的结构成员 initializingClasses，如果为空，根据create判断是否需要创建；
3、如果_objc_initializing_classes的结构成员 metaclasses还没有分配内存，则首次分配 4 个元素的内存，并初始化该内存为 NULL；

1.1.4、释放该线程存储的`_objc_initializing_classes`

void _destroyInitializingClassList(struct _objc_initializing_classes *list){
    if (list != nil) {
        if (list->metaclasses != nil) {
            free(list->metaclasses);
        }
        free(list);
    }
}

该函数主要用来释放该线程存储的_objc_initializing_classes，也就是说，只有在调用 _objc_pthread_destroyspecific() 函数释放 _objc_pthread_data时，才会调用 _destroyInitializingClassList() 函数。

1.1.5、判断当前线程是否正在初始化指定的类

bool _thisThreadIsInitializingClass(Class cls){
    int i;
    _objc_initializing_classes *list = _fetchInitializingClassList(NO);
    //遍历正在初始化的类列表，匹配指定的类
    if (list) {
        cls = cls->getMeta();
        for (i = 0; i < list->classesAllocated; i++) {
            if (cls == list->metaclasses[i]) return YES;
        }
    }
    return NO;
}

该函数的主要功能是：遍历该线程存储的_objc_initializing_classes的结构成员 metaclasses ，判断指定的类是否正在初始化！！

1.1.6、向`_objc_initializing_classes`添加一个正在初始化的类

static void _setThisThreadIsInitializingClass(Class cls){
    int i;
    _objc_initializing_classes *list = _fetchInitializingClassList(YES);
    cls = cls->getMeta();    
    for (i = 0; i < list->classesAllocated; i++) {
        if (cls == list->metaclasses[i]) {
            _objc_fatal("thread is already initializing this class!");
            return; // 已经初始化
        }
    }    
    for (i = 0; i < list->classesAllocated; i++) {
        if (! list->metaclasses[i]) {
            list->metaclasses[i] = cls;
            return;
        }
    }
    
    list->classesAllocated = list->classesAllocated * 2 + 1;
    list->metaclasses = (Class *)realloc(list->metaclasses, list->classesAllocated * sizeof(Class));
    list->metaclasses[i++] = cls;
    for ( ; i < list->classesAllocated; i++) {
        list->metaclasses[i] = nil;//初始化新开辟的空闲内存
    }
}

该函数的主要功能就是将一个要初始化的类加入_objc_initializing_classes：

1、如果_objc_initializing_classes存在该类，则程序执行异常，此时终止程序；
2、如果结构成员 metaclasses有空闲内存，则将指定的类存入空闲内存；否则接着向下执行；
3、由于metaclasses内存大小被限制，如果它的内存已满，需要重新分配内存，并初始化新开辟的内存空间；将该类存储在新分配的内存上；

1.1.7、从`_objc_initializing_classes`移除指定的类

static void _setThisThreadIsNotInitializingClass(Class cls){
    int i;
    _objc_initializing_classes *list = _fetchInitializingClassList(NO);
    if (list) {
        cls = cls->getMeta();
        for (i = 0; i < list->classesAllocated; i++) {
            if (cls == list->metaclasses[i]) {
                list->metaclasses[i] = nil;
                return;
            }
        }
    }
    _objc_fatal("thread is not initializing this class!");
}

该函数的主要功能是遍历_objc_initializing_classes的 metaclasses数组：

如果找到指定的类，则将该类移除；
如果没有找到该类，则程序运行异常，终止程序；

1、 `+initialize` 方法

类方法 +initialize在加载该类之后初次使用该类之前调用，用于初始化该类；没有使用该类就不会被调用。

+initialize具有线程安全性，而且在被发送给一个类之前，总是会被发送给该类的所有父类！为了避免该方法被两次调用，应验证调用者：

+ (void)initialize{
   if (self == PeopleModel.class) {
       //此处初始化
   }
}