您的位置: 首页  >  文章  >  iOS中 性能优化之浅谈load与initialize

iOS中 性能优化之浅谈load与initialize

分类: 文章 • 2024-10-15 08:41:10

一. +load

源码分析

[objc] view plain copy
  1. extern bool hasLoadMethods(const headerType *mhdr);  
  2. extern void prepare_load_methods(const headerType *mhdr);  
  3.   
  4. void  
  5. load_images(const charchar *path __unused, const struct mach_header *mh)  
  6. {  
  7.     // Return without taking locks if there are no +load methods here.  
  8.     if (!hasLoadMethods((const headerType *)mh)) return;  
  9.   
  10.     recursive_mutex_locker_t lock(loadMethodLock);  
  11.   
  12.     // Discover load methods  
  13.     {  
  14.         rwlock_writer_t lock2(runtimeLock);  
  15.         prepare_load_methods((const headerType *)mh);  
  16.     }  
  17.   
  18.     // Call +load methods (without runtimeLock - re-entrant)  
  19.     call_load_methods();  
  20. }  

在runtime源码中，我们可以看到，+load方法是在load_images中通过call_load_methods调用的。
更具体的来说是在运行时加载镜像时，通过prepare_load_methods方法将+load方法准备就绪，而后执行call_load_methods,调用+load方法。

1. prepare_load_methods

[objc] view plain copy
  1. void prepare_load_methods(const headerType *mhdr)  
  2. {  
  3.     size_t count, i;  
  4.     runtimeLock.assertWriting();  
  5.     classref_t *classlist =   
  6.         _getObjc2NonlazyClassList(mhdr, &count);//获取所有类列表  
  7.     for (i = 0; i < count; i++) {  
  8.         schedule_class_load(remapClass(classlist[i]));  
  9.     }  
  10.     category_t **categorylist = _getObjc2NonlazyCategoryList(mhdr, &count);  
  11.     for (i = 0; i < count; i++) {  
  12.         category_t *cat = categorylist[i];  
  13.         Class cls = remapClass(cat->cls);  
  14.         if (!cls) continue;  // category for ignored weak-linked class  
  15.         realizeClass(cls);  
  16.         assert(cls->ISA()->isRealized());  
  17.         add_category_to_loadable_list(cat);  
  18.     }  
  19. }  

在prepare_load_methods方法中，分为两个步骤:
一是，获取了所有类后,遍历列表，将其中有+load方法的类加入loadable_class；
二是，获取所有的类别，遍历列表，将其中有+load方法的类加入loadable_categories.

另外值得注意的一点是schedule_class_load方法的实现：

[objc] view plain copy
  1. static void schedule_class_load(Class cls)  
  2. {  
  3.     if (!cls) return;  
  4.     assert(cls->isRealized());  // _read_images should realize  
  5.     if (cls->data()->flags & RW_LOADED) return;  
  6.   
  7.     // Ensure superclass-first ordering  
  8.     schedule_class_load(cls->superclass);  
  9.   
  10.     add_class_to_loadable_list(cls);  
  11.     cls->setInfo(RW_LOADED);   
  12. }  

在该方法中会首先通过schedule_class_load(cls->superclass)确保父类中的 +load方法被加入loadable_class（如果父类有+load方法的话），从而保证父类的+load方法总是在子类之前调用。
也因此，在覆写+load方法时，不需要调用super方法。

2. call_load_methods

[objc] view plain copy
  1. void call_load_methods(void)  
  2. {  
  3.     static bool loading = NO;  
  4.     bool more_categories;  
  5.   
  6.     loadMethodLock.assertLocked();  
  7.   
  8.     // Re-entrant calls do nothing; the outermost call will finish the job.  
  9.     if (loading) return;  
  10.     loading = YES;  
  11.   
  12.     voidvoid *pool = objc_autoreleasePoolPush();  
  13.   
  14.     do {  
  15.         // 1. Repeatedly call class +loads until there aren't any more  
  16.         while (loadable_classes_used > 0) {  
  17.             call_class_loads();  
  18.         }  
  19.   
  20.         // 2. Call category +loads ONCE  
  21.         more_categories = call_category_loads();  
  22.   
  23.         // 3. Run more +loads if there are classes OR more untried categories  
  24.     } while (loadable_classes_used > 0  ||  more_categories);  
  25.   
  26.     objc_autoreleasePoolPop(pool);  
  27.   
  28.     loading = NO;  
  29. }  

call_load_methods方法注释写得非常明了，首先调用类的load方法，在call_class_loads方法中通过在第一步读取prepare_load_methods步骤里的loadable_classes,遍历列表并调用+load方法，然后类似的调用类别的+load方法，第三步算是处女座的处理，处理异常。

3. call_class_loads

[objc] view plain copy
  1. static void call_class_loads(void)  
  2. {  
  3.     int i;  
  4.   
  5.     //1.获取列表  
  6.     struct loadable_class *classes = loadable_classes;  
  7.     int used = loadable_classes_used;  
  8.     loadable_classes = nil;  
  9.     loadable_classes_allocated = 0;  
  10.     loadable_classes_used = 0;  
  11.   
  12.     //2.循环调用load方法  
  13.     for (i = 0; i < used; i++) {  
  14.         Class cls = classes[i].cls;  
  15.         load_method_t load_method = (load_method_t)classes[i].method;  
  16.         if (!cls) continue;   
  17.   
  18.         (*load_method)(cls, SEL_load);  
  19.     }  
  20.   
  21.     // 3. 释放列表  
  22.     if (classes) free(classes);  
  23. }  

这里我们需要特别注意的是第二部分中:

[objc] view plain copy
  1. (*load_method)(cls, SEL_load);  

这段代码也就是说+load方法的调用是通过直接使用函数内存地址的方式实现的,而不是更常见的objc_msgSend来发送消息.

也正是这句代码造就了+load方法的最大特点:类,父类与分类之间+load方法的调用是互不影响的.也就是,子类不会主动调用父类的+load方法,如果类与分类都实现了+load',那么两个+load`方法都会被调用.

小结

iOS中 性能优化之浅谈load与initialize
+load方法的调用顺序图

总得来说：

  1. +load方法是在main函数之前调用的；
  2. 遵从先父类后子类，先本类后列类别的顺序调用；
  3. 类,父类与分类之间的调用是互不影响的.子类中不需要调用super方法，也不会调用父类的+load方法实现；
  4. 无论该类是否接收消息，都会调用+load方法；

二. initialize

源码分析

在NSObject文件中，initialize的实现如下：

[objc] view plain copy
  1. + (void)initialize {  
  2. }  

然后找到了class_initialize方法，注释表明，当调用class_initialize方法时，就会给当前未初始化的类发送一条 +initialize消息。就是它了。
通过查看caller，我们会看到熟悉的lookUpImpOrForward，也就是消息转发

[objc] view plain copy
  1. /*********************************************************************** 
  2. * class_initialize.  Send the '+initialize' message on demand to any 
  3. * uninitialized class. Force initialization of superclasses first. 
  4. **********************************************************************/  
  5. void _class_initialize(Class cls)  
  6. {  
  7.     assert(!cls->isMetaClass());  
  8.   
  9.     Class supercls;  
  10.     bool reallyInitialize = NO;  
  11.   
  12.     supercls = cls->superclass;  
  13.     if (supercls  &&  !supercls->isInitialized()) {  
  14.         _class_initialize(supercls);  
  15.     }  
  16.   
  17.     {  
  18.         monitor_locker_t lock(classInitLock);  
  19.         if (!cls->isInitialized() && !cls->isInitializing()) {  
  20.             cls->setInitializing();  
  21.             reallyInitialize = YES;  
  22.         }  
  23.     }  
  24.   
  25.     if (reallyInitialize) {          
  26.         _setThisThreadIsInitializingClass(cls);  
  27.   
  28.         @try {  
  29.             callInitialize(cls);  
  30.         }  
  31.         @catch (...) {  
  32.             if (PrintInitializing) {  
  33.                 _objc_inform("INITIALIZE: +[%s initialize] threw an exception",  
  34.                              cls->nameForLogging());  
  35.             }  
  36.             @throw;  
  37.         }  
  38.         @finally {  
  39.             if (!supercls  ||  supercls->isInitialized()) {  
  40.                 _finishInitializing(cls, supercls);  
  41.             } else {  
  42.                 _finishInitializingAfter(cls, supercls);  
  43.             }  
  44.         }  
  45.         return;  
  46.     }  
  47.     else if (cls->isInitializing()) {  
  48.         if (_thisThreadIsInitializingClass(cls)) {  
  49.             return;  
  50.         } else {  
  51.             waitForInitializeToComplete(cls);  
  52.             return;  
  53.         }  
  54.     }  
  55.     else if (cls->isInitialized()) {  
  56.   
  57.         return;  
  58.     }  
  59.     else {  
  60.         _objc_fatal("thread-safe class init in objc runtime is buggy!");  
  61.     }  
  62. }  

_class_initialize方法实现看起来比较长，但其实关键步骤也就只有两步：

  • 确保当前类的父类supercls已经初始化完成 -- 如果没有则通过_class_initialize(supercls)重新进入_class_initialize方法，初始化父类。

  • 处理当前类的初始化状态。

    第一步比较简单,不再赘述,只针对第二个步骤作分析.

    状态处理

当进入第二步,会首先根据当前类的初始化状态决定是否要发送初始化消息.

  • 未初始化
    1) 如果当前类未初始化,则会向它发送一个setInitializing消息,将该类的元类的信息更改为CLS_INITIALIZING,并通过reallyInitialize标识来与Initializing区分.
    2) 成功设置CLS_INITIALIZING后,_setThisThreadIsInitializingClass记录当前线程正在初始化当前类,当前线程可以向该类发送消息,而其他线程则需要等待.
    3) 通过callInitialize调用initialize方法:

  • [objc] view plain copy
    1. void callInitialize(Class cls)  
    2. {  
    3.  ((void(*)(Class, SEL))objc_msgSend)(cls, SEL_initialize);  
    4.  asm("");  
    5. }  

  • 也就是说与+load不同该方法是通过objc_msgSend发送消息实现的,因此也拥有objc_msgSend带来的特性,也就是说子类会继承父类的方法实现,而分类的实现也会覆盖元类.

  • 4) 完成initialize方法后,更新当前类的状态.如果父类已经完成初始化,则_finishInitializing立马更新,否则通过_finishInitializingAfter等父类完成后再更新.

首先来看父类没有完成初始化时的处理 - _finishInitializingAfter :

[objc] view plain copy
  1. static void _finishInitializingAfter(Class cls, Class supercls)  
  2. {  
  3.     PendingInitialize *pending;  
  4.   
  5.     classInitLock.assertLocked();  
  6.   
  7.     if (PrintInitializing) {  
  8.         _objc_inform("INITIALIZE: %s waiting for superclass +[%s initialize]",  
  9.                      cls->nameForLogging(), supercls->nameForLogging());  
  10.     }  
  11.   
  12.     if (!pendingInitializeMap) {  
  13.         pendingInitializeMap =   
  14.             NXCreateMapTable(NXPtrValueMapPrototype, 10);  
  15.         // fixme pre-size this table for CF/NSObject +initialize  
  16.     }  
  17.   
  18.     pending = (PendingInitialize *)malloc(sizeof(*pending));  
  19.     pending->subclass = cls;  
  20.     pending->next = (PendingInitialize *)  
  21.         NXMapGet(pendingInitializeMap, supercls);  
  22.     NXMapInsert(pendingInitializeMap, supercls, pending);  
  23. }  

在该方法中,通过声明一个PendingInitialize类型的结构体pending来存储当前类与父类信息,并以父类supercls为key值,以pending为value存储在pendingInitializeMap链表中.

而如果父类完成了初始化则进入_finishInitializing处理:

[objc] view plain copy
  1. static void _finishInitializing(Class cls, Class supercls)  
  2. {  
  3.     PendingInitialize *pending;  
  4.     classInitLock.assertLocked();  
  5.     assert(!supercls  ||  supercls->isInitialized());  
  6.   
  7.     if (PrintInitializing) {  
  8.         _objc_inform("INITIALIZE: %s is fully +initialized",  
  9.                      cls->nameForLogging());  
  10.     }  
  11.   
  12.     // mark this class as fully +initialized  
  13.     cls->setInitialized();  
  14.     classInitLock.notifyAll();  
  15.     _setThisThreadIsNotInitializingClass(cls);  
  16.   
  17.     // mark any subclasses that were merely waiting for this class  
  18.     if (!pendingInitializeMap) return;  
  19.     pending = (PendingInitialize *)NXMapGet(pendingInitializeMap, cls);  
  20.     if (!pending) return;  
  21.   
  22.     NXMapRemove(pendingInitializeMap, cls);  
  23.   
  24.     // Destroy the pending table if it's now empty, to save memory.  
  25.     if (NXCountMapTable(pendingInitializeMap) == 0) {  
  26.         NXFreeMapTable(pendingInitializeMap);  
  27.         pendingInitializeMap = nil;  
  28.     }  
  29.   
  30.     while (pending) {  
  31.         PendingInitialize *next = pending->next;  
  32.         if (pending->subclass) _finishInitializing(pending->subclass, cls);  
  33.         free(pending);  
  34.         pending = next;  
  35.     }  
  36. }  

在该方法中会首先将当前类标记为已完成初始化状态Initialized,然后去读取pendingInitializeMap,如果查找到该类对应的待处理子类,则将对应的消息移除并通过递归的方法将因当前类而被阻塞的子类标记为已完成初始化.

  • 正在初始化
    如果是当前线程在进行初始化,则不做处理.
    如果是其他线程在进行初始化,则等其他线程完成后再返回,以保证线程安全.

  • 已完成初始化
    如果已经完成初始化,则不做处理.

init

提到初始化方法,不可避免的会想到-init方法.

[objc] view plain copy
  1. - (id)init {  
  2.     return _objc_rootInit(self);  
  3. }  
  4.   
  5. id  
  6. _objc_rootInit(id obj)  
  7. {  
  8.     return obj;  
  9. }  

由源码可以看到,-init方法并没有次数的限制,这也符合我们之前的认知.

那么+ initialize与-init两者的调用顺序又是怎样的呢?
按上文的分析,我推测,由于首先向类发送了alloc消息,此时会触发+ initialize,然后才发送init消息,所以应该是先执行的+ initialize.
通过demo也证实了这一想法.

小结

iOS中 性能优化之浅谈load与initialize
+initialize流程图

总得来说：
1.+initialize方法是在main函数之后调用的；
2.+initialize方法遵从懒加载方式,只有在类或它的子类收到第一条消息之前被调用的;
3.子类中不需要调用super方法，会自动调用父类的方法实现；
4.+initialize只调用一次,init可多次调用.

三. + load与+ initialize的异同

iOS中 性能优化之浅谈load与initialize

相关推荐