在 Objective-C 中,NSObject 是所有類的根。打開 NSObject.h,前兩個聲明的方法就是 load 與 initialize 這兩個類方法。它們經常被一起提及,但行為差異不小,本文做一個系統梳理。
+ (void)load; + (void)initialize;
Objective-C 作為面向對象語言,編譯後類相關的數據結構會保留在目標文件中,並在運行時被解析和使用。應用啟動時,類的信息會經歷「加載」與「初始化」兩個階段。
這並不是 iOS 獨有的概念 —— Java 的 ClassLoader 同樣要完成加載、連接、初始化三步。就像 Application 有生命週期回調一樣,Objective-C 的類在加載和初始化時也會觸發方法回調,這正是 load 與 initialize 能幫我們做的事情。
它們都是「+」開頭的類方法,無返回值。日常開發中我們通常不必關注,但在需要定製類的啟動行為時,可以在自定義子類中實現它們。
在沒有開發者主動調用的情況下,系統最多只會自動調用一次。
若父類與子類都會被調用,父類一定先於子類。
目的都是為應用運行提前準備合適的環境。
都不宜承擔過重的邏輯,除非確有必要。
調用時機非常早。iOS 上通常在 App 啟動、鏡像加載階段執行。此時運行環境並不完整,不能保證所有類都已加載可用,必要時還需要自己負責 autorelease 處理。
跨庫有序,庫內無序。存在依賴關係的兩個庫,被依賴方的 load 會先執行;但同一個庫(同一個 image)內部,各類 load 的調用順序是不確定的。這意味著 load 中不能依賴同庫其他類的 load 結果。
沒有實現就不會被調用。不會因為繼承自 NSObject 而自動獲得一次調用機會。
不需要寫 [super load]。父類的 load 會被單獨調用,且發生在子類之前。
Category 的 load 也會被調用,但順序在主類的 load 之後。
不會直接觸發 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 的機制如出一轍。
(本文作者:三石)