您现在的位置: IOS教程網 >> IOS系統 >  >> iOS 訊息 >> iOS 相關資訊

NSObject 的 load 與 initialize 方法詳解

編輯:iOS 相關資訊

在 Objective-C 中,NSObject 是所有類的根。打開 NSObject.h,前兩個聲明的方法就是 load 與 initialize 這兩個類方法。它們經常被一起提及,但行為差異不小,本文做一個系統梳理。

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

一、背景:類的加載與初始化

Objective-C 作為面向對象語言,編譯後類相關的數據結構會保留在目標文件中,並在運行時被解析和使用。應用啟動時,類的信息會經歷「加載」與「初始化」兩個階段。

這並不是 iOS 獨有的概念 —— Java 的 ClassLoader 同樣要完成加載、連接、初始化三步。就像 Application 有生命週期回調一樣,Objective-C 的類在加載和初始化時也會觸發方法回調,這正是 load 與 initialize 能幫我們做的事情。

它們都是「+」開頭的類方法,無返回值。日常開發中我們通常不必關注,但在需要定製類的啟動行為時,可以在自定義子類中實現它們。

二、兩者的共同點

  • 在沒有開發者主動調用的情況下,系統最多只會自動調用一次。

  • 若父類與子類都會被調用,父類一定先於子類。

  • 目的都是為應用運行提前準備合適的環境。

  • 都不宜承擔過重的邏輯,除非確有必要。

三、load 方法要點

  • 調用時機非常早。iOS 上通常在 App 啟動、鏡像加載階段執行。此時運行環境並不完整,不能保證所有類都已加載可用,必要時還需要自己負責 autorelease 處理。

  • 跨庫有序,庫內無序。存在依賴關係的兩個庫,被依賴方的 load 會先執行;但同一個庫(同一個 image)內部,各類 load 的調用順序是不確定的。這意味著 load 中不能依賴同庫其他類的 load 結果。

  • 沒有實現就不會被調用。不會因為繼承自 NSObject 而自動獲得一次調用機會。

  • 不需要寫 [super load]。父類的 load 會被單獨調用,且發生在子類之前。

  • Category 的 load 也會被調用,但順序在主類的 load 之後。

  • 不會直接觸發 initialize。

四、initialize 方法要點

  • 懶加載觸發。在第一次主動使用當前類時被調用(例如創建實例、訪問類方法),這一點與 Java 的 <clinit> 很像。

  • 運行環境基本健全。此時可以安全地使用大部分系統類。

  • 線程安全。運行時保證同一個類的 initialize 只會被執行一次,多線程競爭由 runtime 處理。

  • 會被繼承。與 load 不同,即使子類沒有實現 initialize,父類的實現也會被繼承並再執行一遍(父類自身的 initialize 此前已執行過一次)。同樣不需要寫 super 調用。

最後這一點是實際開發中最大的陷阱。如果你的基類寫了:

+ (void)initialize {
    if (self == [MyBaseClass class]) {   // 必須加這個判斷
        // 只在基類自身被初始化時執行一次
    }
}

缺少 if (self == [XXX class]) 判斷,每個子類第一次被使用時都會重跑一遍父類的初始化邏輯,可能造成嚴重的重複註冊或性能問題。

由於 initialize 時機更晚、環境更完整、且保證線程安全,它的適用面比 load 更廣 —— 常見用途包括注册 class 級別的配置,以及作為單例的一種實現方案。

五、原理:從源碼看行為

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

注意這段代碼的結構:第一個循環處理類,第二個循環處理 Category。這正是「主類的 load 先於 Category 的 load」的源碼依據。

再看下面這段:

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

遞歸調用自己處理父類,且先 add 父類再 add 自己 —— 這就是「父類 load 優先於子類」的原因。

initialize 的調用邏輯在 _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);
        ((void(*)(Class, SEL))objc_msgSend)(cls, SEL_initialize);

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

這段代碼清楚展現了兩件事:

線程安全如何保證。用 classInitLock 這個互斥量配合 isInitializing / isInitialized 兩個狀態位。第一個進入的線程執行真正的初始化,其他線程在 monitor_wait 上等待;同時通過 _thisThreadIsInitializingClass 判斷如果是本線程的遞歸調用就直接返回,避免自死鎖 —— 這正是 initialize 中調用會間接觸發自身的類方法時不會卡住的原因。

父類為何先執行。函數開頭就遞歸調用 _class_initialize(supercls),與 load 的機制如出一轍。

(本文作者:三石)

  1. 上一篇文章:
  2. 下一篇文章:
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © IOS教程網 All Rights Reserved