雷纯锋的技术博客
Objective-C +load vs +initialize

+load和 +initialize都是用于类的初始化，但是这两个看是简单又相似的类方法，在许多方面让人感到困惑，比如:

• 子类、父类、分类中相应方法什么时候会被调用
• 子类中需要显示的调用父类的实现吗？
• 每个方法只调用一次，还是多次？

一. 实例验证:

举个🌰 ：

+load方法：

在 main 函数中打印当前 函数名称:

#import <UIKit/UIKit.h>
#import "AppDelegate.h"

int main(int argc, char * argv[]) {
    NSLog(@"%s",__func__);
    @autoreleasepool {
        return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class]));
    }
}

同时定义Person类和Son类(Son类继承Person类):

Person类:

#import <Foundation/Foundation.h>

@interface Person : NSObject

@end


#import "Person.h"

@implementation Person
+ (void)load{
    NSLog(@"%s",__func__);
}

+ (void)initialize{
    [super initialize];
    NSLog(@"%s %@",__func__,[self class]);
}

- (instancetype)init{
    if (self = [super init]) {
        NSLog(@"%s",__func__);
    }
      return self;
}

@end

Son类:

#import "Person.h"

@interface Son : Person

@end



#import "Son.h"

@implementation Son
+ (void)load{
    NSLog(@"%s",__func__);
}

+ (void)initialize{
    [super initialize];
    NSLog(@"%s %@",__func__,[self class]);
}

- (instancetype)init{
    if (self = [super init]) {
        NSLog(@"%s",__func__);
    }
    return self;
}
@end

运行输出:

FJTestProject[29237:1018755] +[Person load]

FJTestProject[29237:1018755] +[Son load]

FJTestProject[29237:1018755] main

从输出结果可以看出，在没有对类进行任何操作的情况下，+load方法会被默认执行，并且是在main函数之前执行。

+initialize方法：

同时我们查看下+initialize方法:

#import "Son.h"
#import "Person.h"
#import "ViewController.h"


@interface ViewController ()
@end

@implementation ViewController

#pragma mark --- init method

#pragma mark --- life circle

- (void)viewDidLoad {
    [super viewDidLoad];

    Person *aPerson = [Person new];

    Son  *bSon = [Son new];
}

@end

输出日志:

FJTestProject[29627:1058200] +[Person load]
FJTestProject[29627:1058200] +[Son load]
FJTestProject[29627:1058200] main
FJTestProject[29627:1058200] +[Person initialize] Person
FJTestProject[29627:1058200] -[Person init]
FJTestProject[29627:1058200] +[Person initialize] Son
FJTestProject[29627:1058200] +[Son initialize] Son
FJTestProject[29627:1058200] -[Person init]
FJTestProject[29627:1058200] -[Son init]

从输出内容可以看出:

• +initialize 是通过类似懒加载调用的，如果没有使用这个类，系统默认不会去掉用这个方法，且默认只加载一次

• +initialize的调用发生在+init方法之前，创建子类的时候会去调用父类的+ initialize方法。

category 调用顺序：

首先为Person类添加类别:

#import "Person+Extention.h"

@implementation Person (Extention)
+ (void)load{
    NSLog(@"%s",__func__);
}

+ (void)initialize{
    [super initialize];
    NSLog(@"%s %@",__func__,[self class]);
}
@end

运行程序，日志如下:

FJTestProject[29751:1066412] +[Person load]
FJTestProject[29751:1066412] +[Son load]
FJTestProject[29751:1066412] +[Person(Extention) load]
FJTestProject[29751:1066412] main
FJTestProject[29751:1066412] +[Person(Extention) initialize] Person
FJTestProject[29751:1066412] -[Person init]
FJTestProject[29751:1066412] +[Person(Extention) initialize] Son
FJTestProject[29751:1066412] +[Son initialize] Son
FJTestProject[29751:1066412] -[Person init]
FJTestProject[29751:1066412] -[Son init]

从日志我们可以看出:
对于+load方法:

• 会先执行父类中的load方法，再执行子类中的load方法，最后在执行类别的load方法。

对于+ initialize方法:

• 类别会覆盖类中的方法，只执行分类的实现。

二. 分析

+ load

• +load方法是当类或分类被添加到Objective-C runtime时被调用，实现这个方法可以让我们在类加载的时候执行一些类相关的行为。

• 子类的+load方法会在它的所有父类的+load方法之后执行，

• 分类的+load方法会在它的主类的+load方法之后执行。

• 但是不同类之间的+load方法的调用顺序是不确定的。

接着我们打开runtime工程，在objc-runtime-new.mm中我们来看与+load方法相关的关键函数。

首先, void prepare_load_methods(header_info *hi)函数：

void prepare_load_methods(header_info *hi)
{
    size_t count, i;

    rwlock_assert_writing(&runtimeLock);

    classref_t *classlist =
    _getObjc2NonlazyClassList(hi, &count);
    for (i = 0; i < count; i++) {
        schedule_class_load(remapClass(classlist[i]));
    }

    category_t **categorylist = _getObjc2NonlazyCategoryList(hi, &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);
    }
}

这个函数的作用就是提前准备好满足+load方法调用条件的类和分类，以供接下来调用。其中，在处理类时，调用了同文件中的另一个函数static void schedule_class_load(Class cls)来执行具体的操作。

static void schedule_class_load(Class cls)
{
    if (!cls) return;
    assert(cls->isRealized());  // _read_images should realize

    if (cls->data()->flags & RW_LOADED) return;

    // Ensure superclass-first ordering
    schedule_class_load(cls->superclass);

    add_class_to_loadable_list(cls);
    cls->setInfo(RW_LOADED);
}

该函数中的schedule_class_load(cls->superclass);，对入参的父类进行了递归调用，以确保父类优先的顺序。

当void prepare_load_methods(header_info *hi)函数执行完后，当前所有满足+load方法调用条件的类和分类就被分别存放在全局变量loadable_classes和loadable_categories中了。

准备好类和分类后，接下来就是对它们的+load方法进行调用。打开文件objc-loadmethod.m,找到void call_load_methods(void)函数。

void call_load_methods(void)
{
    static BOOL loading = NO;
    BOOL more_categories;

    recursive_mutex_assert_locked(&loadMethodLock);

    // Re-entrant calls do nothing; the outermost call will finish the job.
    if (loading) return;
    loading = YES;

    void *pool = objc_autoreleasePoolPush();

    do {
        // 1. Repeatedly call class +loads until there aren't any more
        while (loadable_classes_used > 0) {
            call_class_loads();
        }

        // 2. Call category +loads ONCE
        more_categories = call_category_loads();

        // 3. Run more +loads if there are classes OR more untried categories
    } while (loadable_classes_used > 0  ||  more_categories);

    objc_autoreleasePoolPop(pool);

    loading = NO;
}

这个函数的作用就是调用上一步准备好的类和分类中的+load方法，并且确保类优先于分类的顺序。我们继续查看在这个函数中调用另外两个关键函数static void call_class_loads(void)和 static BOOL call_category_loads(void) 。由于这两个函数的作用大同小异，下面以static void call_class_loads(void)函数为例进行探讨。

static void call_class_loads(void)
{
    int i;

    // Detach current loadable list.
    struct loadable_class *classes = loadable_classes;
    int used = loadable_classes_used;
    loadable_classes = nil;
    loadable_classes_allocated = 0;
    loadable_classes_used = 0;

    // Call all +loads for the detached list.
    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;

        if (PrintLoading) {
            _objc_inform("LOAD: +[%s load]\n", cls->nameForLogging());
        }
        (*load_method)(cls, SEL_load);
    }

    // Destroy the detached list.
    if (classes) _free_internal(classes);
 }

这个函数的作用就是真正负责调用类的+load方法，它从全局变量loadable_classes中取出所有可供调用的类，并进行清零操作。

loadable_classes = nil;
loadable_classes_allocated = 0;
loadable_classes_used = 0;

• loadable_classes指向用于保存类信息的内存首地址
• loadable_classes_allocated标识已分配的内存空间大小
• loadable_classes_used则标识已使用的内存空间大小。

然后，循环调用所有类的+load方法。注意，这里是(调用分类的+load方法也是如此)直接使用函数内存地址的方式(*load_method)(cls, SEL_load);对+load方法进行调用的，而不是使用发送消息objc_msgSend的方式。

这样的调用方式就使得+load方法拥有了一个非常有趣的特性，那就是子类、父类和分类中的+load方法的实现是被区别对待的。也就是说如果子类没有实现+load方法，那么当它被加载时runtime是不会去调用父类的+load方法的。同理，当一个类和它的分类都实现+load方法时，两个方法都会被调用。因此，我们常常可以利用这个特性做一些"邪恶"的事情比如说方法混淆(Method Swizzling)

+initialize

• +iniitialize方法是在类或它的子类收到第一条消息之前被调用的，这里所指的消息包括实例方法和类方法的调用。也就是说+initialize方法是以懒加载的方式被调用，如果程序一直没有给某个类或它的子类发送消息，那么这个类的 +initialize方法是永远不会被调用的。这样有利于节省系统资源，避免浪费。

同样，我们看下runtime的源码来理解+initialize方法的理解。打开文件objc-runtime-new.mm，找到lookUpImpOrForward函数：

IMP lookUpImpOrForward(Class cls, SEL sel, id inst,
                   bool initialize, bool cache, bool resolver)
{
    ...
        rwlock_unlock_write(&runtimeLock);
    }

    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 
    ...
}  

当我们给某个类发送消息时，runtime会调用这个函数在类中查找相应方法的实现或进行消息转发。从 if (initialize && !cls->isInitialized())判断我们可以看出，当类没有初始化时runtime会调用void _class_initialize(Class cls)函数对该类进行初始化。

void _class_initialize(Class cls)
{
    ...
    Class supercls;
    BOOL reallyInitialize = NO;

    // 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());
        }

        ((void(*)(Class, SEL))objc_msgSend)(cls, SEL_initialize);

        if (PrintInitializing) {
            _objc_inform("INITIALIZE: finished +[%s initialize]",
    ...
}

• 其中，

  supercls = cls->superclass;
  if (supercls  &&  !supercls->isInitialized()) {
       _class_initialize(supercls);
  }
  

对入参的父类进行了递归调用，以保证父类优先于子类初始化。

• 另外，最关键的是((void(*)(Class, SEL))objc_msgSend)(cls, SEL_initialize);这行代码暴露了+initialize方法的本质，也就是说runtime使用了发送消息objc_msgSend的方式对+initialize方法进行调用。也就是说+initialize方法的调用与普通方法的调用是一致的，走得都是发送消息的流程。

• 换言之，如果子类没有实现+initialize方法，那么继承自父类的实现会被调用，如果一个分类实现了+initialize方法，那么就会对这个类中的实现造成覆盖。

因此，如果一个子类没有实现+initialize方法，那么父类的实现会被执行多次，有时候，这可能不是你想要的；但是如果我们想确保每个类的+initialize方法只执行一次，避免多次执行可能带来的副作用时，我们可以使用如下代码:

+ (void)initialize {
  if (self == [ClassName self]) {
    // ... do the initialization ...
  }
}

三.总结

通过阅读runtime 的源码，我们知道了+load和 +initialize方法实现的细节，明白了它们的调用机制和各自的特点。下面进行各方面对比:

+load VS +initialize

调用时机: 被添加到 runtime 时 VS 收到第一条消息前，可能永远不调用

调用顺序: 父类->子类->分类 VS 父类->子类

调用次数: 1次 VS 多次

是否需要显式调用父类实现: 否 VS 否

是否沿用父类的实现: 否 VS 是

分类中的实现: 类和分类都执行 VS 覆盖类中的方法,只执行分类的实现