美文网首页
Objective-C中+initialize方法的调用历程

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

作者: 苏沫离 | 来源:发表于2019-01-10 00:07 被阅读0次

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_classesmetaclasses数组:

  • 如果找到指定的类,则将该类移除;
  • 如果没有找到该类,则程序运行异常,终止程序;
1、 +initialize 方法

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

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

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

相关文章

网友评论

      本文标题:Objective-C中+initialize方法的调用历程

      本文链接:https://www.haomeiwen.com/subject/avkirqtx.html