+load +initialize

+load方法

在app启动的时候各个类的+load方法都会被调用，+load方法不是通过消息机制调用的，它是直接调用的，因此无论是在子类或者category中复写此方法，复写的+load方法都会被调用，查看runtime的代码可知调用的顺序为

父类->子类->分类。（原因是runtime会把所有类的+load方法放到一个列表中，然后按顺序调用，所有category的+load方法放到一个列表中，然后也按顺序调用，所以当所有类的+load方法都执行完成后才开始去执行分类的+load方法）。所有类的+load方法在调用列表中的顺序由两个因素决定，一个是此类文件的编译顺序，一个是递归调用的顺序，即从父类到子类。所有分类的+load方法在调用列表中的顺序只由编译顺序决定。

schedule_class_load

call_class_load

runtime代码如下：

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);

}

prepare_load_methods

call_load_methods

void call_load_methods(void)

{

static bool loading = NO;

bool more_categories;

loadMethodLock.assertLocked();

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

}

+initialize

与+load方法不同，+initialize方法是通过消息的方式发送的（msgSend），所以+initialize方法可以被子类或者分类覆盖，每个类第一次被用到的时候，runtime都会调用 _class_initialize(Class cls)方法，_class_initialize(Class cls)也是一个递归调用的方法，当发现cls的父类没有调用此方法时，会递归调用_class_initialize(cls->supercls)，调用时会向该类发送initialize消息，此方法被调用完成后cls->isInitialized()这个属性会变成true。

注意这里存在一个类的initialize方法被调用多次的可能。当子类没有实现initialize方法时，父类的initialize方法可能被调用多次。

举个例子：

有两个类：Person，Girl，Girl继承Person

如果只有Person实现了initialize方法，那么当这Girl类被用到时，Person的这个initialize方法会被调用两次，一次是父类调用_class_initialize（Person）时发送的，另一次是调用_class_initialize（Girl）时发送的，因为给Girl发送initialize的时候发现Girl并没有实现此方法，所以此方法被转发到了Girl的父类，即Person的类对象。

可以这么理解，每个类对应的_class_initialize(Class cls)这个方法只会被调用一次，调用的顺序为从父类到子类，在_class_initialize(Class cls)这个方法中会向当前的类对象发送initialize方法。如果当前类没有实现initialize方法则依次去父类找。

_class_initialize(Class cls)

void _class_initialize(Class cls)

{

assert(!cls->isMetaClass());

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_locker_t lock(classInitLock);

if (!cls->isInitialized() && !cls->isInitializing()) {

cls->setInitializing();

reallyInitialize = YES;

}

}

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]",

cls->nameForLogging());

}

// Done initializing.

// If the superclass is also done initializing, then update

//   the info bits and notify waiting threads.

// If not, update them later. (This can happen if this +initialize

//   was itself triggered from inside a superclass +initialize.)

monitor_locker_t lock(classInitLock);

if (!supercls  ||  supercls->isInitialized()) {

_finishInitializing(cls, supercls);

} else {

_finishInitializingAfter(cls, supercls);

}

return;

}

else if (cls->isInitializing()) {

// We couldn't set INITIALIZING because INITIALIZING was already set.

// If this thread set it earlier, continue normally.

// If some other thread set it, block until initialize is done.

// It's ok if INITIALIZING changes to INITIALIZED while we're here,

//   because we safely check for INITIALIZED inside the lock

//   before blocking.

if (_thisThreadIsInitializingClass(cls)) {

return;

} else {

monitor_locker_t lock(classInitLock);

while (!cls->isInitialized()) {

classInitLock.wait();

}

return;

}

}

else if (cls->isInitialized()) {

// Set CLS_INITIALIZING failed because someone else already

//   initialized the class. Continue normally.

// NOTE this check must come AFTER the ISINITIALIZING case.

// Otherwise: Another thread is initializing this class. ISINITIALIZED

//   is false. Skip this clause. Then the other thread finishes

//   initialization and sets INITIALIZING=no and INITIALIZED=yes.

//   Skip the ISINITIALIZING clause. Die horribly.

return;

}

else {

// We shouldn't be here.

_objc_fatal("thread-safe class init in objc runtime is buggy!");

}

}