前陣子為了完成一項工作,我認真研究了 NSObject 上兩個相當特別的類別方法。特別之處在於:runtime 會在程式啟動階段主動、自動呼叫它們,而且對「繼承」與「類別(Category)」這套規則,它們各自有不一樣的處理方式。
正因為是在程式一開始就被觸發,我們可以拿來做前置作業。我當時的需求就是讓各個類別在首次被使用前,把自己的類名登記到一份 NSDictionary 裡。
The runtime sends
initializeto each class in a program exactly one time just before the class, or any class that inherits from it, is sent its first message from within the program. (Thus the method may never be invoked if the class is not used.) The runtime sends the initialize message to classes in a thread-safe manner. Superclasses receive this message before their subclasses.
The
loadmessage is sent to classes and categories that are both dynamically loaded and statically linked, but only if the newly loaded class or category implements a method that can respond. The order of initialization is as follows:
- All initializers in any framework you link to.
- All
+loadmethods in your image.- All C++ static initializers and C/C++
__attribute__(constructor)functions in your image.- All initializers in frameworks that link to you.
In addition: a class's
+loadmethod is called after all of its superclasses'+loadmethods; a category+loadmethod is called after the class's own+loadmethod.
歸納起來,兩者的核心差異是:load 只要類別所在檔案被連結進來就會被呼叫;initialize 則是在該類別(或其子類)即將收到第一個訊息之前才呼叫。因此,類別若沒被引入專案,就不會有 load;但即使檔案引入了、程式碼裡從未實際使用,initialize 也不會觸發。
相同點是:兩者對 runtime 而言都只會被執行一次。順序上,父類優先於子類,類別自身實作優先於 Category 中的實作。
文件寫得清楚,但仍有不少細節沒交代。下面用幾段實測程式碼把邊界條件釐清。
1 +(void)load 會引發 +(void)initialize
2 /******* Interface *******/
3 @interface SuperClass : NSObject
4 @end
5
6 @interface ChildClass : SuperClass
7 @end
8
9 @interface Insideinitialize : NSObject
10 - (void)objectMethod;
11 @end
12
13 /******* Implementation *******/
14 @implementation SuperClass
15
16 + (void)initialize {
17 NSLog(@"%@ %s", [self class], __FUNCTION__);
18 }
19
20 + (void)load {
21 NSLog(@"%@ %s", [self class], __FUNCTION__);
22 }
23
24 @end
25
26 @implementation ChildClass
27
28 + (void)initialize {
29 NSLog(@"%@ %s", [self class], __FUNCTION__);
30 Insideinitialize *obj = [[Insideinitialize alloc] init];
31 [obj objectMethod];
32 [obj release];
33 }
34
35 @end
36
37 @implementation Insideinitialize
38
39 - (void)objectMethod {
40 NSLog(@"%@ %s", [self class], __FUNCTION__);
41 }
42
43 + (void)initialize {
44 NSLog(@"%@ %s", [self class], __FUNCTION__);
45 }
46
47 + (void)load {
48 NSLog(@"%s", __FUNCTION__);
49 }
50
51 @end
SuperClass 實作了 load 與 initialize;ChildClass 繼承自 SuperClass,只覆寫 initialize;Insideinitialize 兩者都有,並在 ChildClass 的 initialize 中被建立。每個方法都很單純,只印出類名與方法名。
如果專案裡只 import 這些類別、完全不去使用,執行結果是:
SuperClass +[SuperClass initialize] SuperClass +[SuperClass load] Insideinitialize +[Insideinitialize load]
正如文件所述,只要有引用,runtime 就會呼叫 load。但值得注意的是:SuperClass 的 initialize 也被執行了,而且發生在 load 之前——原因是我在 load 裡呼叫了 [self class],這構成「類別的第一個訊息」,於是觸發 initialize。這同時說明 runtime 對 load 的呼叫並不算是類別收到的第一個訊息。至於 Insideinitialize 的 initialize 沒執行,是因為從來沒人給它發過訊息;ChildClass 也因為沒被使用,initialize 沒觸發,而且即使它繼承了 load,runtime 也不會替它執行父類的 load。
接著讓 ChildClass 直接呼叫 load:
[ChildClass load];
輸出變成:
SuperClass +[SuperClass initialize] SuperClass +[SuperClass load] +[Insideinitialize load] ChildClass +[ChildClass initialize] Insideinitialize +[Insideinitialize initialize] Insideinitialize -[Insideinitialize objectMethod] ChildClass +[SuperClass load]
前三行與先前相同。之後 ChildClass 的 initialize 被自動執行,並在其中安全地建立了 Insideinitialize 實例;而 Insideinitialize 因為 alloc 是它收到的第一個類別訊息,於是 initialize 也被觸發。
另一方面,ChildClass 雖然沒有自己的 load,卻繼承到了父類的 load,而且可以被當成普通類別方法呼叫。這也印證了前面那句話:「只呼叫一次」是 runtime 層級的保證(SuperClass 的 initialize 不會因為自身 load 呼叫一次、又因子類 load 再呼叫一次),你依然可以隨時手動反覆呼叫它們。
這次拿掉 SuperClass 的 load,改由 ChildClass 實作 load,並移除 ChildClass 的 initialize:
/******* Interface *******/
@interface SuperClass : NSObject
@end
@interface ChildClass : SuperClass
@end
/******* Implementation *******/
@implementation SuperClass
+ (void)initialize {
NSLog(@"%@ %s", [self class], __FUNCTION__);
}
@end
@implementation ChildClass
+ (void)load {
NSLog(@"%@ %s", [self class], __FUNCTION__);
}
@end
只 import 不使用,執行結果:
SuperClass +[SuperClass initialize] ChildClass +[SuperClass initialize] ChildClass +[ChildClass load]
「load 會引發 initialize」再次成立,子類的訊息也確實會挑起父類的 initialize。同時可以看到:ChildClass 雖然沒有定義 initialize,卻會沿用父類的實作。反觀 load,runtime 只會呼叫「新定義」的那一份,不會沿著繼承鏈往上找。
1 /******* Interface *******/
2 @interface MainClass : NSObject
3 @end
4
5 /******* Category Implementation *******/
6 @implementation MainClass (Category)
7
8 + (void)load {
9 NSLog(@"%@ %s", [self class], __FUNCTION__);
10 }
11
12 + (void)initialize {
13 NSLog(@"%@ %s", [self class], __FUNCTION__);
14 }
15
16 @end
17
18 @implementation MainClass (OtherCategory)
19
20 + (void)load {
21 NSLog(@"%@ %s", [self class], __FUNCTION__);
22 }
23
24 + (void)initialize {
25 NSLog(@"%@ %s", [self class], __FUNCTION__);
26 }
27
28 @end
29
30 /******* Implementation *******/
31 @implementation MainClass
32
33 + (void)load {
34 NSLog(@"%@ %s", [self class], __FUNCTION__);
35 }
36
37 + (void)initialize {
38 NSLog(@"%@ %s", [self class], __FUNCTION__);
39 }
40
41 @end
只 import 不使用,輸出:
MainClass +[MainClass(OtherCategory) initialize] MainClass +[MainClass load] MainClass +[MainClass(Category) load] MainClass +[MainClass(OtherCategory) load]
initialize 依然先於 load 執行。但明顯的差別是:只有其中一個 Category 的 initialize 被執行,另外兩個被覆蓋掉了(Category 之間的覆蓋順序取決於連結順序,實務上不可依賴)。而 load 則三份全部執行,順序與文件所述一致:先類別自身,再各 Category。
@interface MainClass : NSObject
@end
@implementation MainClass
+ (void)load {
NSArray *array = [NSArray array];
NSLog(@"%@ %s", array, __FUNCTION__);
}
@end
執行後 Xcode 會給出警告:
objc[84934]: Object 0x10a512930 of class __NSArrayI autoreleased with no pool in place - just leaking - break on objc_autoreleaseNoPool() to debug 2012-09-28 18:07:39.042 ClassMethod[84934:403] ( ) +[MainClass load]
原因很直接:runtime 呼叫 load 時,程式的 autorelease pool 還沒建立。所以放在 load 裡的物件應該自行 alloc/init,並避免依賴 autorelease 釋放,否則就是「假性記憶體洩漏」。
寫 init 與 dealloc 時,我們習慣用 super 串起父類的相同流程,因為 Objective-C 不像 C++、C# 會自動呼叫父類的預設建構子:
- (id)init {
if ((self = [super init])) {
// do initialization
}
return self;
}
- (void)dealloc {
// do release
[super dealloc];
}
但 load 與 initialize 不同,寫 [super initialize] 或 [super load] 是多餘的:runtime 本來就會自行呼叫父類的 load,而 initialize 則會隨子類的訊息自動向上觸發。另外要留意,即使你在其中使用 self,指的仍是類別自身,而不是父類。
| 比較項目 | +(void)load | +(void)initialize |
|---|---|---|
| 執行時機 | 程式啟動、類別被連結進來後立即執行 | 該類別(或其子類)第一次收到訊息之前 |
| 自身未定義時是否沿用父類實作 | 否,runtime 只呼叫新定義的那一份 | 是,會使用繼承而來的實作 |
| 類別(Category)中的定義 | 全部執行,但排在類別自身實作之後 | 互相覆蓋,最終只有一份生效 |
| autorelease pool | 尚未建立,需自行管理記憶體 | 已可用 |
| 是否需要呼叫 super | 不需要 | 不需要 |
實務上的建議:需要「註冊、登記、方法交換(swizzling)」這類必須在啟動階段完成的 preprocessing,放 load;只是想做一次性的狀態初始化,用 initialize 更安全,而且記得加上 if (self == [SomeClass class]) 的判斷,避免子類繼承時重複執行。