NSObject的load和initialize方法（轉）

　　全文轉載自：http://www.cocoachina.com/ios/20150104/10826.html

 

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

 

一、概述

　　Objective-C做爲一門面向對象語言，有類和對象的概念。編譯後，類相關的數據結構會保留在目標文件中，在運行時獲得解析和使用。

　　在應用程序運行起來的時候，類的信息會有加載和初始化過程。其實在Java語言中也有相似的過程，JVM的ClassLoader也對類進行了加載、鏈接、初始化。

　　就像Application有生命週期回調方法同樣，在Objective-C的類被加載和初始化的時候，也能夠收到方法回調，能夠在適當的狀況下作一些定製處理。而這正是load和initialize方法能夠幫咱們作到的。

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

 

　  能夠看到這兩個方法都是以「+」開頭的類方法，返回爲空。一般狀況下，咱們在開發過程當中可能沒必要關注這兩個方法。若是有須要定製，咱們能夠在自定義的NSObject子類中給出這兩個方法的實現，這樣在類的加載和初始化過程當中，自定義的方法能夠獲得調用。

 

　　從如上聲明上來看，也許這兩個方法和其它的類方法相比沒什麼特別。可是，這兩個方法具備必定的「特殊性」，這也是這兩個方法常常會被放在一塊兒特殊提到的緣由。詳細請看以下幾小節的整理。

　　

　　

　　load和initialize的共同特色

　　　　load和initialize有不少共同特色，下面簡單列一下：

• • • 在不考慮開發者主動使用的狀況下，系統最多會調用一次

    • 若是父類和子類都被調用，父類的調用必定在子類以前

    • 都是爲了應用運行提早建立合適的運行環境

    • 在使用時都不要太重地依賴於這兩個方法，除非真正必要
      
      

　　

load方法相關要點　

• • • 調用時機比較早，運行環境有不肯定因素。具體說來，在iOS上一般就是App啓動時進行加載，但當load調用的時候，並不能保證全部類都加載完成且可用，必要時還要本身負責作auto release處理。

    • 補充上面一點，對於有依賴關係的兩個庫中，被依賴的類的load會優先調用。但在一個庫以內，調用順序是不肯定的。

    • 對於一個類而言，沒有load方法實現就不會調用，不會考慮對NSObject的繼承。

    • 一個類的load方法不用寫明[super load]，父類就會收到調用，而且在子類以前。

    • Category的load也會收到調用，但順序上在主類的load調用以後。

    • 不會直接觸發initialize的調用。

　　

initialize方法相關要點

• • • initialize的天然調用是在第一次主動使用當前類的時候（lazy，這一點和Java類的「clinit」的很像）。

    • 在initialize方法收到調用時，運行環境基本健全。

    • initialize的運行過程當中是能保證線程安全的。

    • 和load不一樣，即便子類不實現initialize方法，會把父類的實現繼承過來調用一遍。注意的是在此以前，父類的方法已經被執行過一次了，一樣不須要super調用。

　　因爲initialize的這些特色，使得其應用比load要略微普遍一些。可用來作一些初始化工做，或者單例模式的一種實現方案。

 

　　

原理

「源碼面前沒有祕密」。最後，咱們來看看蘋果開放出來的部分源碼。從中咱們也許能明白爲何load和initialize及調用會有如上的一些特色。

其中load是在objc庫中一個load_images函數中調用的，先把二進制映像文件中的頭信息取出，再解析和讀出各個模塊中的類定義信息，把實現了load方法的類和Category記錄下來，最後統一執行調用。

//其中的prepare_load_methods函數實現以下：

void prepare_load_methods(header_info *hi)
{
    Module mods;
    unsigned int midx;
    if (_objcHeaderIsReplacement(hi)) {
        return;
    }
  
    mods = hi->mod_ptr;
    for (midx = 0; midx < hi->mod_count; midx += 1)
    {
        unsigned int index;
  
        if (mods[midx].symtab == nil)
            continue;
  
        for (index = 0; index < mods[midx].symtab->cls_def_cnt; index += 1)
        {
            Class cls = (Class)mods[midx].symtab->defs[index];
            if (cls->info & CLS_CONNECTED) {
                schedule_class_load(cls);
            }
        }
    }
    mods = hi->mod_ptr;
  
    midx = (unsigned int)hi->mod_count;
    while (midx-- > 0) {
        unsigned int index;
        unsigned int total;
        Symtab symtab = mods[midx].symtab;
  
        if (mods[midx].symtab == nil)
            continue;
        total = mods[midx].symtab->cls_def_cnt +
            mods[midx].symtab->cat_def_cnt;
  
        index = total;
        while (index-- > mods[midx].symtab->cls_def_cnt) {
            old_category *cat = (old_category *)symtab->defs[index];
            add_category_to_loadable_list((Category)cat);
        }
    }
}

 　　　　這大概就是主類中的load方法先於category的緣由。再看下面這段：

static void schedule_class_load(Class cls)
{
    if (cls->info & CLS_LOADED) return;
    if (cls->superclass) schedule_class_load(cls->superclass);
    add_class_to_loadable_list(cls);
    cls->info |= CLS_LOADED;
}

 　　　　

這正是父類load方法優先於子類調用的緣由。

再來看下initialize調用相關的源碼。objc的庫裏有一個_class_initialize方法實現，以下：

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的調用順序和線程安全性。