iOS-关联对象

initialize方法什么时候调用？

首先我们创建一个TPerson类：

@interface TPerson : NSObject
@property (nonatomic, copy) NSString *name;

@end

#import "TPerson.h"

@implementation TPerson

+ (void)initialize {
    NSLog(@"类-initialize");
}

@end

然后我们在main函数中调用以下方法：

#import <Foundation/Foundation.h>
#import <objc/runtime.h>
#import "TPerson.h"

int main(int argc, const char * argv[]) {
    @autoreleasepool{
        Class cls = [TPerson class];
        NSLog(@"---class----");
        TPerson *per = [TPerson alloc];
        NSLog(@"---alloc----");
    }
    return 0;
}

运行代码，我们在main函数打一个断点，可以看到在进入main函数之前控制台并没有输出，说明initialize是在运行时调用。跳过断点，控制台输出：

2020-02-18 18:08:23.696091+0800 objc-debug[31356:847168] 类-initialize
2020-02-18 18:08:23.696411+0800 objc-debug[31356:847168] ---class----
2020-02-18 18:08:23.696592+0800 objc-debug[31356:847168] ---alloc----

从结果，我们可以猜测，initialize的调用和class方法、或者alloc并没有直接关系。然而，当我们调用TPerson的某一个方法的时候，就会触发initialize的调用，联想到方法的调用本质就是发送消息，我们可以在lookUpImpOrForward查探一下究竟。

IMP lookUpImpOrForward(Class cls, SEL sel, id inst, 
                       bool initialize, bool cache, bool resolver)
{
    if (initialize && !cls->isInitialized()) {
    cls = initializeAndLeaveLocked(cls, inst, runtimeLock);
    // runtimeLock may have been dropped but is now locked again

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

根据代码我们可以判断，此处大概和initialize相关，设置一个断点，在调用[TPerson class]这个方法之后果然来了这里，跟踪代码：

static Class initializeAndLeaveLocked(Class cls, id obj, mutex_t& lock)
{
    return initializeAndMaybeRelock(cls, obj, lock, true);
}

static Class initializeAndMaybeRelock(Class cls, id inst,
                                      mutex_t& lock, bool leaveLocked)
{
    lock.assertLocked();
    assert(cls->isRealized());

    if (cls->isInitialized()) {
        if (!leaveLocked) lock.unlock();
        return cls;
    }

    。。。。。。
    
    initializeNonMetaClass(nonmeta);
    return cls;
}

void initializeNonMetaClass(Class cls)
{
    assert(!cls->isMetaClass());

    Class supercls;
    bool reallyInitialize = NO;
    
    .......

    // 确保在initialize类的时候，其父类已经在initializing了 
    supercls = cls->superclass;
    if (supercls  &&  !supercls->isInitialized()) {
        initializeNonMetaClass(supercls);
    }
    
    // 试着将类的初始化状态自动设置为 CLS_INITIALIZING.
    {
        if (!cls->isInitialized() && !cls->isInitializing()) {
            cls->setInitializing();
            reallyInitialize = YES;
        }
    }
    
    if (reallyInitialize) {
        callInitialize(cls);
    }
    ......
}

void setInitializing() {
    ISA()->setInfo(RW_INITIALIZING);
}
    
void callInitialize(Class cls)
{
    ((void(*)(Class, SEL))objc_msgSend)(cls, SEL_initialize);
}

顺着代码，我们发现，如果类没有initialize，就会以IMP的方式调用。

然后我们保留class方法，注释掉alloc方法

Class cls = [TPerson class];
NSLog(@"---class----");
// TPerson *per = [TPerson alloc];
// NSLog(@"---alloc----");

// 控制台输出
2020-02-18 19:04:41.693528+0800 objc-debug[31838:896818] 类-initialize
2020-02-18 19:04:41.693962+0800 objc-debug[31838:896818] ---class----

然后我们注释class方法，保留alloc方法：

// Class cls = [TPerson class];
// NSLog(@"---class----");
TPerson *per = [TPerson alloc];
NSLog(@"---alloc----");

// 控制台输出
2020-02-18 19:05:06.043299+0800 objc-debug[31855:897517] 类-initialize
2020-02-18 19:05:06.043415+0800 objc-debug[31855:897517] ---alloc----

这也验证了我们的推测，initialize的调用确实和哪一个方法没有关系，只要是类第一次调用方法就会调用。

分类的initialize方法

那么分类如果也实现了initialize方法，什么时候调用呢？

并且为其创建一个分类：

#import "TPerson.h"

@interface TPerson (addition)

@end

@implementation TPerson (addition)

+ (void)initialize {
    NSLog(@"分类-initialize");
}

@end

运行程序，只看到控制台输出：

2020-02-18 19:33:43.443330+0800 objc-debug[31951:908425] 分类-initialize

这是因为分类方法都是通过attachList方法加入到类的ro或者rw中，而attachList方法是先将原来的列表进行扩容，然后将旧数据移动到列表的尾部位置，再把新的数据copy到列表头部位置。所以分类的方法在前面，主类方法在后面，方法查找的时候找到前面的方法就直接返回了，并不会再去调用主类的方法。

总结

initialize只会调用一次，在对类第一次发送消息的时候调用。
主类和分类都有initialize方法，只会调用分类的方法。