在Objective-C中，NSObject是根類，而NSObject.h的頭文件中前兩個方法就是load和initialize兩個類方法，本篇文章就對這兩個方法做下說明和整理。

0. 概述

Objective-C作為一門面向?qū)ο笳Z言，有類和對象的概念。編譯后，類相關(guān)的數(shù)據(jù)結(jié)構(gòu)會保留在目標文件中，在運行時得到解析和使用。在應用程序運行起來的時候，類的信息會有加載和初始化過程。

其實在Java語言中也有類似的過程，JVM的ClassLoader也對類進行了加載、連接、初始化。

就像Application有生命周期回調(diào)方法一樣，在Objective-C的類被加載和初始化的時候，也可以收到方法回調(diào)，可以在適當?shù)那闆r下做一些定制處理。而這正是load和initialize方法可以幫我們做到的。

+ (void)load;
+ (void)initialize;

可以看到這兩個方法都是以“+”開頭的類方法，返回為空。通常情況下，我們在開發(fā)過程中可能不必關(guān)注這兩個方法。如果有需要定制，我們可以在自定義的NSObject子類中給出這兩個方法的實現(xiàn)，這樣在類的加載和初始化過程中，自定義的方法可以得到調(diào)用。

從如上聲明上來看，也許這兩個方法和其它的類方法相比沒什么特別。但是，這兩個方法具有一定的“特殊性”，這也是這兩個方法經(jīng)常會被放在一起特殊提到的原因。詳細請看如下幾小節(jié)的整理。

1. load和initialize的共同特點

load和initialize有很多共同特點，下面簡單列一下：
1）、在不考慮開發(fā)者主動使用的情況下，系統(tǒng)最多會調(diào)用一次
2）、如果父類和子類都被調(diào)用，父類的調(diào)用一定在子類之前
3）、都是為了應用運行提前創(chuàng)建合適的運行環(huán)境
4）、在使用時都不要過重地依賴于這兩個方法，除非真正必要

2. load方法相關(guān)要點

廢話不多說，直接上要點列表：
1）、調(diào)用時機比較早，運行環(huán)境有不確定因素。具體說來，在iOS上通常就是App啟動時進行加載，但當load調(diào)用的時候，并不能保證所有類都加載完成且可用，必要時還要自己負責做auto release處理。
2）、補充上面一點，對于有依賴關(guān)系的兩個庫中，被依賴的類的load會優(yōu)先調(diào)用。但在一個庫之內(nèi)，調(diào)用順序是不確定的。
對于一個類而言，沒有l(wèi)oad方法實現(xiàn)就不會調(diào)用，不會考慮對NSObject的繼承。
3）、一個類的load方法不用寫明[super load]，父類就會收到調(diào)用，并且在子類之前。
4）、Category的load也會收到調(diào)用，但順序上在主類的load調(diào)用之后。
5）、不會直接觸發(fā)initialize的調(diào)用。

3. initialize方法相關(guān)要點

同樣，直接整理要點：
1）、initialize的自然調(diào)用是在第一次主動使用當前類的時候（lazy，這一點和Java類的“clinit”的很像）。
2）、在initialize方法收到調(diào)用時，運行環(huán)境基本健全。
3）、initialize的運行過程中是能保證線程安全的。
4）、和load不同，即使子類不實現(xiàn)initialize方法，會把父類的實現(xiàn)繼承過來調(diào)用一遍。注意的是在此之前，父類的方法已經(jīng)被執(zhí)行過一次了，同樣不需要super調(diào)用。

由于initialize的這些特點，使得其應用比load要略微廣泛一些。可用來做一些初始化工作，或者單例模式的一種實現(xiàn)方案。

4. 原理

通過蘋果開放出來的部分源碼，從中我們或許能明白為什么load和initialize及調(diào)用會有如上的一些特點。

其中l(wèi)oad是在objc庫中一個load_images函數(shù)中調(diào)用的，先把二進制映像文件中的頭信息取出，再解析和讀出各個模塊中的類定義信息，把實現(xiàn)了load方法的類和Category記錄下來，最后統(tǒng)一執(zhí)行調(diào)用。

其中的prepare_load_methods函數(shù)實現(xiàn)如下：

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方法先于category的原因。再看下面這段：

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

這正是父類load方法優(yōu)先于子類調(diào)用的原因。

再來看下initialize調(diào)用相關(guān)的源碼。objc的庫里有一個_class_initialize方法實現(xiàn)，如下：

void _class_initialize(Class cls)
{
    assert(!cls->isMetaClass());
 
    Class supercls;
    BOOL reallyInitialize = NO;
 
    supercls = cls->superclass;
    if (supercls  &&  !supercls->isInitialized()) {
        _class_initialize(supercls);
    }
 
    monitor_enter(&classInitLock);
    if (!cls->isInitialized() && !cls->isInitializing()) {
        cls->setInitializing();
        reallyInitialize = YES;
    }
    monitor_exit(&classInitLock);
 
    if (reallyInitialize) {
        _setThisThreadIsInitializingClass(cls);
 
        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());
        }
 
        monitor_enter(&classInitLock);
        if (!supercls  ||  supercls->isInitialized()) {
            _finishInitializing(cls, supercls);
        } else {
            _finishInitializingAfter(cls, supercls);
        }
        monitor_exit(&classInitLock);
        return;
    }
 
    else if (cls->isInitializing()) {
        if (_thisThreadIsInitializingClass(cls)) {
            return;
        } else {
            monitor_enter(&classInitLock);
            while (!cls->isInitialized()) {
                monitor_wait(&classInitLock);
            }
            monitor_exit(&classInitLock);
            return;
        }
    }
 
    else if (cls->isInitialized()) {
        return;
    }
 
    else {
        _objc_fatal("thread-safe class init in objc runtime is buggy!");
    }
}

在這段代碼里，我們能看到initialize的調(diào)用順序和線程安全性。