理解 OBJECTIVE-C RUNTIME

發表於2014-12-26

當人們初學 Cocoa/Objective-C 時，Objective-C Runtime 是被忽略的特性之一。原因是 Objective-C（這門語言）很容易在幾小時內就熟悉，新學 Cocoa 的人花費他們大部分的時間學習 Cocoa 框架和適應它是如何工作的。然而每個人至少應該知道一些 runtime 的工作細節，需要比知道編譯器會把 [target doMethodWith:var1]; 轉換為 objc_msgSend(target,@selector(doMethodWith:),var1); 更深入一些。知道 Objective-C 正在做的會讓你更深入的理解 Objective-C 和你正在執行的 app。我認為 Mac/iPhone 的開發者不管你現在是什麼水平，都會有收穫的。

Objective-C Runtime 是開源的

Objective-C 是開源的，任何時候你都能從 http://opensource.apple.com. 獲取。事實上檢視 Objective-C 原始碼是我理解它是如何工作的第一種方式，在這個問題上要比讀蘋果的文件要好。你可以下載適合 Mac OS X 10.6.2 的 objc4-437.1.tar.gz。（譯註：最新objc4-551.1.tar.gz）

動態 vs 靜態語言

Objective-C 是面相執行時的語言（runtime oriented language），就是說它會盡可能的把編譯和連結時要執行的邏輯延遲到執行時。這就給了你很大的靈活性，你可以按需要把訊息重定向給合適的物件，你甚至可以交換方法的實現，等等（譯註：在 Objective-C 中呼叫一個物件的方法可以看成向一個物件傳送訊息, Method Swizzling 具體實現可以參看 jrswizzle ）。這就需要使用 runtime，runtime 可以做物件自省檢視他們正在做的和不能做的（don’t respond to）並且合適的分發訊息（譯註：感興趣的同學可以檢視 NSObject 類的 – forwardingTargetForSelector: 和 – forwardInvocation: 方法。P.S. 不是 NSObject 協議！）。如果我們和 C 這樣的語言對比。在 C 裡，你從 main() 方法開始寫然後就是從上到下的寫邏輯了並按你寫程式碼的順序執行程式。一個 C 的結構體不能轉發函式執行請求到其他的目標上（other targets）。很可能你的程式是這樣的：

#include < stdio.h >
int main(int argc, const char **argv[])
{        
    printf("Hello World!");
    return 0;
}

#include < stdio.h >

int main(int argc, const char **argv[])

{

printf("Hello World!");

return 0;

}

編譯器解析，優化然後把優化後的程式碼轉成彙編：

.text
 .align 4,0x90
 .globl _main
_main:
Leh_func_begin1:
 pushq %rbp
Llabel1:
 movq %rsp, %rbp
Llabel2:
 subq $16, %rsp
Llabel3:
 movq %rsi, %rax
 movl %edi, %ecx 
 movl %ecx, -8(%rbp)
 movq %rax, -16(%rbp) 
 xorb %al, %al 
 leaq LC(%rip), %rcx 
 movq %rcx, %rdi 
 call _printf 
 movl $0, -4(%rbp) 
 movl -4(%rbp), %eax 
 addq $16, %rsp 
 popq %rbp 
 ret
Leh_func_end1: 
 .cstring
LC: 
 .asciz &quot;Hello World!&quot;

.text

.align 4,0x90

.globl _main

_main:

Leh_func_begin1:

pushq %rbp

Llabel1:

movq %rsp, %rbp

Llabel2:

subq $16, %rsp

Llabel3:

movq %rsi, %rax

movl %edi, %ecx

movl %ecx, -8(%rbp)

movq %rax, -16(%rbp)

xorb %al, %al

leaq LC(%rip), %rcx

movq %rcx, %rdi

call _printf

movl $0, -4(%rbp)

movl -4(%rbp), %eax

addq $16, %rsp

popq %rbp

ret

Leh_func_end1:

.cstring

LC:

.asciz "Hello World!"

然後連結庫並生成可執行程式（譯註：如果你對 C 的編譯連結過程還不熟悉可以參看 Deep C and C++）。要和 Objective-C 對比的話，處理過程很相似，生成的程式碼依賴於是否有 Objective-C Runtime 庫。當剛學 Objective-C 時，我們最先了解的(最簡單的那種)是 Objective-C 中用括號包起來的程式碼像這樣…

[self doSomethingWithVar:var1];

1	[self doSomethingWithVar:var1];

被轉換為…

objc_msgSend(self,@selector(doSomethingWithVar:),var1);

1	objc_msgSend(self,@selector(doSomethingWithVar:),var1);

但除了這些，我們就不知道之後在執行時做了什麼了。

Objective-C Runtime 是什麼？

Objective-C 的 Runtime 是一個執行時庫（Runtime Library），它是一個主要使用 C 和彙編寫的庫，為 C 新增了面相物件的能力並創造了 Objective-C。這就是說它在類資訊（Class information）中被載入，完成所有的方法分發，方法轉發，等等。Objective-C runtime 建立了所有需要的結構體，讓 Objective-C 的面相物件程式設計變為可能。

Objective-C Runtime 術語

更深入之前，我們們先了解點術語。Mac 和 iPhone 開發者關心的有兩個 runtime：Modern Runtime（現代的 Runtime）和 Legacy Runtime（過時的 Runtime）。Modern Runtime：覆蓋所有 64 位的 Mac OS X 應用和所有 iPhone OS 的應用。 Legacy Runtime: 覆蓋其他的所有應用（所有 32 位的 Mac OS X 應用） Method 有 2 種基本型別的方法。Instance Method（例項方法）：以 ‘-’ 開始，比如 -(void)doFoo; 在物件例項上操作。Class Method（類方法）：以 ‘+’ 開始，比如 +(id)alloc。方法（Methods）和 C 的函式很像，是一組程式碼，執行一個小的任務，如：

- (NSString *)movieTitle
{
    return @&quot;Futurama: Into the Wild Green Yonder&quot;;
}

- (NSString *)movieTitle

{

return @"Futurama: Into the Wild Green Yonder";

}

Selector 在 Objective-C 中 selector 只是一個 C 的資料結構，用於表示一個你想在一個物件上執行的 Objective-C 方法。在 runtime 中的定義像這樣…

typedef struct objc_selector  *SEL;

1	typedef struct objc_selector *SEL;

像這樣使用…

&lt;code&gt;SEL aSel = @selector(movieTitle); &lt;/code&gt;

1	<code>SEL aSel = @selector(movieTitle); </code>

Message（訊息）

&lt;code&gt;[target getMovieTitleForObject:obj];&lt;/code&gt;

1	<code>[target getMovieTitleForObject:obj];</code>

訊息是方括號 ‘[]’ 中的那部分，由你要向其傳送訊息的物件（target），你想要在上面執行的方法（method）還有你傳送的引數（arguments）組成。Objective-C 的訊息和 C 函式呼叫是不同的。事實上，你向一個物件傳送訊息並不意味著它會執行它。Object（物件）會檢查訊息的傳送者，基於這點再決定是執行一個不同的方法還是轉發訊息到另一個目標物件上。Class 如果你檢視一個類的runtime資訊，你會看到這個…

&lt;code&gt;typedef struct objc_class *Class;
typedef struct objc_object {
    Class isa;
} *id; &lt;/code&gt;

<code>typedef struct objc_class *Class;

typedef struct objc_object {

Class isa;

} *id; </code>

這裡有幾個事情。我們有一個 Objective-C 類的結構體和一個物件的結構體。objc_object 只有一個指向類的 isa 指標，就是我們說的術語 “isa pointer”（isa 指標）。這個 isa 指標是當你向物件傳送訊息時，Objective-C Runtime 檢查一個物件並且檢視它的類是什麼然後開始檢視它是否響應這些 selectors 所需要的一切。最後我麼看到了 id 指標。預設情況下 id 指標除了告訴我們它們是 Objective-C 物件外沒有其他用了。當你有一個 id 指標，然後你就可以問這個物件是什麼類的，看看它是否響應一個方法，等等，然後你就可以在知道這個指標指向的是什麼物件後執行更多的操作了。你可以在 LLVM/Clang 的文件中的 Block 中看到

struct Block_literal_1 {
    void *isa; // initialized to &_NSConcreteStackBlock or &_NSConcreteGlobalBlock    
    int flags;    
    int reserved;     
    void (*invoke)(void *, ...); 
    struct Block_descriptor_1 { 
        unsigned long int reserved; // NULL     
        unsigned long int size;  // sizeof(struct Block_literal_1)
        // optional helper functions     
        void (*copy_helper)(void *dst, void *src);
        void (*dispose_helper)(void *src);     
    } *descriptor;    
    // imported variables
};

struct Block_literal_1 {

void *isa; // initialized to &_NSConcreteStackBlock or &_NSConcreteGlobalBlock

int flags;

int reserved;

void (*invoke)(void *, ...);

struct Block_descriptor_1 {

unsigned long int reserved; // NULL

unsigned long int size; // sizeof(struct Block_literal_1)

// optional helper functions

void (*copy_helper)(void *dst, void *src);

void (*dispose_helper)(void *src);

} *descriptor;

// imported variables

};

Blocks 被設計為相容 Objective-C 的 runtime，所以他們被作為物件對待，因此他們可以響應訊息，比如 -retain，-release，-copy ，等等。IMP（方法實現 MethodImplementations）

typedef id (*IMP)(id self,SEL _cmd,...);

1	typedef id (*IMP)(id self,SEL _cmd,...);

IMP 是指向方法實現的函式指標，由編譯器為你生成。如果你新接觸 Objective-C 你現在不需要直接接觸這些，但是我們將會看到，Objective-C runtime 將如何呼叫你的方法的。Objective-C Classes（Objective-C 類）那麼什麼是 Objective-C 類？在 Objective-C 中的一個類實現看起來像這樣：

@interface MyClass : NSObject {
    // vars
    NSInteger counter;
}
// methods
-(void)doFoo;
@end

但是 runtime 不只要追蹤這些

#if !__OBJC2__   
    Class super_class                        OBJC2_UNAVAILABLE;
    const char *name                         OBJC2_UNAVAILABLE;
    long version                             OBJC2_UNAVAILABLE;
    long info                                OBJC2_UNAVAILABLE;
    long instance_size                       OBJC2_UNAVAILABLE;    
    struct objc_ivar_list *ivars             OBJC2_UNAVAILABLE;    
    struct objc_method_list **methodLists    OBJC2_UNAVAILABLE;    
    struct objc_cache *cache                 OBJC2_UNAVAILABLE;    
    struct objc_protocol_*protocols          OBJC2_UNAVAILABLE;
#endif

@interface MyClass : NSObject {

// vars

NSInteger counter;

}

// methods

-(void)doFoo;

@end

但是 runtime 不只要追蹤這些

#if !__OBJC2__

Class super_class OBJC2_UNAVAILABLE;

const char *name OBJC2_UNAVAILABLE;

long version OBJC2_UNAVAILABLE;

long info OBJC2_UNAVAILABLE;

long instance_size OBJC2_UNAVAILABLE;

struct objc_ivar_list *ivars OBJC2_UNAVAILABLE;

struct objc_method_list **methodLists OBJC2_UNAVAILABLE;

struct objc_cache *cache OBJC2_UNAVAILABLE;

struct objc_protocol_*protocols OBJC2_UNAVAILABLE;

#endif

我們可以看到，一個類有其父類的引用，它的名字，例項變數，方法，快取還有它遵循的協議。runtime 在響應類或例項的方法時需要這些資訊。

那麼 Class 定義的是物件還是物件本身？它是如何實現的（譯註：讀者需要區分 Class 和 class 是不同的，正如 Nil 和 nil 的用途是不同的）

是的，之前我說過 Objective-C 類也是物件，runtime 通過建立 Meta Classes 來處理這些。當你傳送一個訊息像這樣 [NSObject alloc] 你正在向類物件傳送一個訊息，這個類物件需要是 MetaClass 的例項，MetaClass 也是 root meta class 的例項。當你說繼承自 NSObject 時，你的類指向 NSObject 作為自己的 superclass。然而，所有的 meta class 指向 root metaclass 作為自己的 superclass。所有的 meta class 只是簡單的有一個自己響應的方法列表。所以當你向一個類物件傳送訊息如 [NSObject alloc]，然後實際上 objc_msgSend() 會檢查 meta class 看看它是否響應這個方法，如果他找到了一個方法，就在這個 Class 物件上執行（譯註：class 是一個例項物件的型別，Class 是一個類（class）的型別。對於完全的 OO 來說，類也是個物件，類是類型別(MetaClass)的例項，所以類的型別描述就是 meta class）。

為什麼我們繼承自蘋果的類

從你開始 Cocoa 開發時，那些教程就說如繼承自 NSObject 然後開始寫一些程式碼，你享受了很多繼承自蘋果的類所帶來的便利。有一件事你從未意識到的是你的物件被設定為使用 Objective-C 的 runtime。當我們為我們的類的一個例項分配了記憶體，像這樣…

MyObject *object = [[MyObject alloc] init];

1	MyObject *object = [[MyObject alloc] init];

最先執行的訊息是 +alloc。如果你檢視下文件，它說“新的例項物件的 isa 例項變數被初始化為指向一個資料結構，那個資料結構描述了這個類；其他的例項變數被初始化為 0。”所以繼承自蘋果的類不僅僅是繼承了一些重要的屬性，也繼承了能在記憶體中輕鬆分配記憶體的能力和在記憶體中建立滿足 runtime 期望的物件結構（設定 isa 指標指向我們的類）。

那麼 Class Cache 是什麼？（objc_cache *cache）

當 Objective-C runtime 沿著一個物件的 isa 指標檢查時，它會發現一個物件實現了許多的方法。然而你可能只呼叫其中一小部分的方法，也沒有意義每次檢查時搜尋這個類的分發表（dispatch table）中的所有 selector。所以這個類實現了一個快取，當你搜尋一個類的分發表，並找到合適的 selector 後，就會把它放進快取中。所以當 objc_msgSend() 在一個類中查詢 selector 時會先查詢類快取。有個理論是，當你在一個類上呼叫了一個訊息，你很可能之後還會呼叫它。所以如果我們考慮到這點，就意味著當我們有個子類繼承自 NSObject 叫做 MyObject 並且執行了以下的程式碼

MyObject *obj = [[MyObject alloc] init]; 

@implementation MyObject
- (id)init {
    if(self = [super init]) {
        [self setVarA:@”blah”];    
    }
    return self;
}
@end

MyObject *obj = [[MyObject alloc] init];

@implementation MyObject

- (id)init {

if(self = [super init]) {

[self setVarA:@”blah”];

}

return self;

}

@end

發生了以下的事：

(1) [MyObject alloc] 首先被執行。MyObject 沒有實現 alloc 方法，所以我們不能在這個類中找到 +alloc 方法，然後沿著 superclass 指標會指向 NSObject。

(2) 我們詢問 NSObject 是否響應 +alloc 方法，它可以。+alloc 檢查訊息的接收者類，是 MyObject，然後分配一塊和我們的類同樣大小的記憶體空間，並初始化它的 isa 指標指向 MyObject 類，我們現在有了一個例項物件，最終把類物件的 +alloc 方法加入 NSObject 的類快取（class cache）中（lastly we put +alloc in NSObject’s class cache for the class object ）。

(3) 到現在為止，我們傳送了一個類訊息，但是現在我們傳送一個例項訊息，只是簡單的呼叫 -init 或者我們設計的初始化方法。當然，我們的類會響應這個方法，所以 -(id)init 加入到快取中。（譯註：要是 MyObject 實現了 init 方法，就會把 init 方法加入到 MyObject 的 class cache 中，要是沒有實現，只是因為繼承才有了這個方法，init 方法還是會加入到 NSObject 的 class cache 中）。

(4) 然後 self = [super init] 被呼叫。super 是個 magic keyword，指向物件的父類，所以我們得到了 NSObject 並呼叫它的的 init 方法。這樣可以確保 OOP（面相物件程式設計）的繼承功能正常，這個方法可以正確的初始化父類的變數，之後你（在子類中）可以初始化自己的變數，如果需要可以覆蓋父類的方法。在 NSObject 的例子中，沒什麼重要的要做，但並不總是這樣。有時要做些重要的初始化。比如…

#import <Foundation/Foundation.h> 

@interface MyObject : NSObject {
    NSString *aString;
} 
    @property(retain) NSString *aString; 

@end 

@implementation MyObject

-(id)init 
{ 
    if (self = [super init]) {
        [self setAString:nil];
    }
    return self;
}

@synthesize aString;

@end

int main (int argc, const char * argv[]) 
{
    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];

    id obj1 = [NSMutableArray alloc]; 
    id obj2 = [[NSMutableArray alloc] init];   
    id obj3 = [NSArray alloc]; 
    id obj4 = [[NSArray alloc] initWithObjects:@"Hello",nil];

    NSLog(@"obj1 class is %@",NSStringFromClass([obj1 class]));
    NSLog(@"obj2 class is %@",NSStringFromClass([obj2 class]));
    NSLog(@"obj3 class is %@",NSStringFromClass([obj3 class]));
    NSLog(@"obj4 class is %@",NSStringFromClass([obj4 class]));

    id obj5 = [MyObject alloc]; 
    id obj6 = [[MyObject alloc] init];   

    NSLog(@"obj5 class is %@",NSStringFromClass([obj5 class]));    
    NSLog(@"obj6 class is %@",NSStringFromClass([obj6 class]));   

    [pool drain];
    return 0;
}

#import <Foundation/Foundation.h>

@interface MyObject : NSObject {

NSString *aString;

}

@property(retain) NSString *aString;

@end

@implementation MyObject

-(id)init

{

if (self = [super init]) {

[self setAString:nil];

}

return self;

}

@synthesize aString;

@end

int main (int argc, const char * argv[])

{

NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];

id obj1 = [NSMutableArray alloc];

id obj2 = [[NSMutableArray alloc] init];

id obj3 = [NSArray alloc];

id obj4 = [[NSArray alloc] initWithObjects:@"Hello",nil];

NSLog(@"obj1 class is %@",NSStringFromClass([obj1 class]));

NSLog(@"obj2 class is %@",NSStringFromClass([obj2 class]));

NSLog(@"obj3 class is %@",NSStringFromClass([obj3 class]));

NSLog(@"obj4 class is %@",NSStringFromClass([obj4 class]));

id obj5 = [MyObject alloc];

id obj6 = [[MyObject alloc] init];

NSLog(@"obj5 class is %@",NSStringFromClass([obj5 class]));

NSLog(@"obj6 class is %@",NSStringFromClass([obj6 class]));

[pool drain];

return 0;

}

現在如果你新接觸 Cocoa ，我讓你猜會會輸出什麼，你可能會說

NSMutableArray
NSMutableArray 
NSArray
NSArray
MyObject
MyObject

NSMutableArray

NSArray

MyObject

但是，實際上是

obj1 class is __NSPlaceholderArray
obj2 class is NSCFArray
obj3 class is __NSPlaceholderArray
obj4 class is NSCFArray
obj5 class is MyObject
obj6 class is MyObject

obj1 class is __NSPlaceholderArray

obj2 class is NSCFArray

obj3 class is __NSPlaceholderArray

obj4 class is NSCFArray

obj5 class is MyObject

obj6 class is MyObject

這是因為在 Objective-C 中 +alloc 方法可能會返回某個類的物件，然後在 -init 中返回另一個類的物件。
（譯註：感興趣的同學可以看下這兩篇文章：Class Clusters, Make Your Own Abstract Factory Class Cluster in Objective-C, 第二篇文章需要自備小梯子。)

那麼在 objc_msgSend 中發生了什麼？

事實上在 objc_msgSend() 中發生了許多事兒。假設我們有這樣的程式碼…

[self printMessageWithString:@"Hello World!"];

1	[self printMessageWithString:@"Hello World!"];

它實際上會被編譯器翻譯為…

objc_msgSend(self,@selector(printMessageWithString:),@"Hello World!");

1	objc_msgSend(self,@selector(printMessageWithString:),@"Hello World!");

我們沿著目標物件的 isa 指標查詢，看看是否這個物件響應 @selector(printMessageWithString:) selector。假設我們在類的分發表或者快取中找到了這個 selector，我們沿著函式指標並且執行它。這樣 objcmsgSend() 就永遠不會返回，它開始執行，然後沿著指向方法的指標，然後你的方法返回，這樣看起來 objcmsgSend() 方法返回了。Bill Bumgarner 比我講了更多 objc_msgSend() 的細節（部分1，部分2 和部分3）。

概括下他說的，並且你已經看過了 Objective-C 的 runtime 程式碼…

檢查忽略的 Selector 和短路（Short Circut）—— 顯然，如果我們執行在垃圾回收機制下，我們可以忽略呼叫 -retain, -release, 等等。
檢查 nil 物件（target）。和其他的語言不一樣的是，在 Objective-C 中向 nil 傳送訊息是完全合法的，並且有些原因下你會願意這麼做的。假設我們有個非 nil 的物件，然後我們繼續…
然後我們需要在這個類上找到 IMP，所以我們先從 class cache 中找起，如果找到了就沿著指標跳到這個函式。
如果沒有在快取中找到 IMP，然後去查詢類的分發表，如果找到了，就沿著指標跳到這個函式。
如果 IMP 沒有在快取和類的分發表中找到，然後我們跳到轉發機制。這意味著最終你的程式碼被編譯器轉換為 C 函式。你寫的方法會像這樣…

  -(int)doComputeWithNum:(int)aNum

1	-(int)doComputeWithNum:(int)aNum

會被翻譯為…

int aClass_doComputeWithNum(aClass *self,SEL _cmd,int aNum)

1	int aClass_doComputeWithNum(aClass *self,SEL _cmd,int aNum)

Objective-C Runtime 通過呼叫（invoking）指向這些方法的函式指標呼叫你的方法（call your methods）。現在，我要說的是，你不能直接呼叫這些被翻譯的方法，但是 Cocoa 框架提供了獲得函式指標的方法…

//declare C function pointer
int (computeNum *)(id,SEL,int);

//methodForSelector is COCOA & not ObjC Runtime
//gets the same function pointer objc_msgSend gets
computeNum = (int (*)(id,SEL,int))[target methodForSelector:@selector(    doComputeWithNum:)]; 

//execute the C function pointer returned by the runtime
computeNum(obj,@selector(doComputeWithNum:),aNum);

//declare C function pointer

int (computeNum *)(id,SEL,int);

//methodForSelector is COCOA & not ObjC Runtime

//gets the same function pointer objc_msgSend gets

computeNum = (int (*)(id,SEL,int))[target methodForSelector:@selector( doComputeWithNum:)];

//execute the C function pointer returned by the runtime

computeNum(obj,@selector(doComputeWithNum:),aNum);

通過這種方法，你可以直接訪問這個函式，並且可以在執行時直接呼叫，甚至可以使用這個避開 runtime 的動態特性，如果你絕對需要確保一個方法被執行。Objective-C 就是用這種途徑去呼叫你的方法的，但是使用的是 objc_msgSend()。

Objective-C 訊息轉發

在 Objective-C 中向一個不知道如何響應這個方法的物件傳送訊息是完全合法的（甚至可能是一種潛在的設計決定）。蘋果的文件中給出的一個原因是模擬多繼承，Objective-C 不是原生支援的，或者你可能只是想抽象你的設計並且隱藏幕後處理這些訊息的其他物件/類。這一點是 runtime 非常需要的。它是這樣做的 1. Runtime 檢查了你的類和所有父類的 class cache 和分發表，但是沒找到指定的方法。2. Objective_C 的 Runtime 會在你的類上呼叫 + (BOOL) resolveInstanceMethod:(SEL)aSEL。這就給了你一個機會去提供一個方法實現並且告訴 runtime 你已經解析了這個方法，如果它開始查詢，這回就會找到這個方法。你可以像這樣實現…定義一個函式…

void fooMethod(id obj, SEL _cmd)
{ 
    NSLog(@"Doing Foo");
}

void fooMethod(id obj, SEL _cmd)

{

NSLog(@"Doing Foo");

}

然後你可以像這樣使用 class_addMethod() 解析它…

+(BOOL)resolveInstanceMethod:(SEL)aSEL
{
    if(aSEL == @selector(doFoo:))
    {
            class_addMethod([self class],aSEL,(IMP)fooMethod,"v@:");
            return YES;
    }
    return [super resolveInstanceMethod];
}

+(BOOL)resolveInstanceMethod:(SEL)aSEL

{

if(aSEL == @selector(doFoo:))

{

class_addMethod([self class],aSEL,(IMP)fooMethod,"v@:");

return YES;

}

return [super resolveInstanceMethod];

}

在 class_addMethod() 最後一部分的 “v@:” 是方法的返回和引數型別。你可以在 Runtime Guide 的 Type Encoding 章節看到完整介紹。 3. Runtime 然後呼叫 – (id)forwardingTargetForSelector:(SEL)aSelector。這樣做是為了給你一次機會（因為我們不能解析這個方法（參見上面的 #2））引導 Objective-C runtime 到另一個可以響應這個訊息的物件上，在花費昂貴的處理過程呼叫 – (void)forwardInvocation:(NSInvocation *)anInvocation 之前呼叫這個方法也是更好的。你可以像這樣實現

- (id)forwardingTargetForSelector:(SEL)aSelector
{
    if(aSelector == @selector(mysteriousMethod:))
    {        
        return alternateObject;
    }
    return [super forwardingTargetForSelector:aSelector];
}

- (id)forwardingTargetForSelector:(SEL)aSelector

{

if(aSelector == @selector(mysteriousMethod:))

{

return alternateObject;

}

return [super forwardingTargetForSelector:aSelector];

}

顯然你不想從這個方法直接返回 self，否則可能會產生一個死迴圈。 4. Runtime 最後一次會嘗試在目標物件上呼叫 – (void)forwardInvocation:(NSInvocation *)anInvocation。如果你從沒看過 NSInvocation，它是 Objective-C 訊息的物件形式。一旦你有了一個 NSInvocation 你可以改變這個訊息的一切，包括目標物件，selector 和引數。所以你可以這樣做…

-(void)forwardInvocation:(NSInvocation *)invocation
{  
    SEL invSEL = invocation.selector;    
    if([altObject respondsToSelector:invSEL]) {        
        [invocation invokeWithTarget:altObject];    
    } else {        
        [self doesNotRecognizeSelector:invSEL];    
    }
}

-(void)forwardInvocation:(NSInvocation *)invocation

{

SEL invSEL = invocation.selector;

if([altObject respondsToSelector:invSEL]) {

[invocation invokeWithTarget:altObject];

} else {

[self doesNotRecognizeSelector:invSEL];

}

如果你繼承自 NSObject，預設它的 – (void)forwardInvocation:(NSInvocation *)anInvocation 實現只是簡單的呼叫 -doesNotRecognizeSelector:，你可以在最後一次機會裡覆蓋這個方法去做一些事情。（譯註：對這塊內容有興趣的同學可以參見：http://www.cnblogs.com/biosli/p/NSObjectinherit2.html）

Non Fragile ivars（Modern Runtime）（非脆弱的 ivar）

我們最近在 Modern Runtime 裡得到的是 Non Fragile ivars 的概念。當編譯你的類時，編譯器生成了一個 ivar 佈局，顯示了在你的類中從哪可以訪問你的 ivars，獲取指向你的物件的指標，檢視 ivar 與物件起始位元組的偏移關係，和獲取讀入的變數型別的總共位元組大小等一些底層的細節。所以你的 ivar 佈局可能看起來像這樣，左側的數字是位元組偏移量。

我們有了 NSObject 的 ivar 佈局，然後我們繼承自 NSObject 去擴充套件它並且新增了我們自己的 ivars。在蘋果釋出更新前這都工作的很好，但是 Mac OS X 10.6 釋出後，就成了這樣

你的自定義物件被剔除了因為我們有了一個重疊的父類。唯一可以防止這個的辦法是如果蘋果堅持之前的佈局，如果他們這麼做了，那麼他們的框架就不能改進，因為他們的 ivar 佈局被凍住了。在 fragile ivar 下你不得不重新編譯你繼承自蘋果類的類來恢復相容性。所以在非 fragile ivar 時，會發生生麼？

使用非 fragile ivars 時，編譯器生成和 fragile ivars 相同的 ivar 佈局。然而當 runtime 檢測到一個重疊的超類時，它調整你在這個類中新增的 ivar 的偏移量，這樣在子類中新增加的那部分就顯示出來了。

Objective-C 關聯物件

最近在 Mac OS X 10.6 雪豹中新引入了關聯引用。Objective-C 不能動態的新增一些屬性到物件上，和其他的一些原生支援這點的語言不一樣。所以之前你都不得不努力為未來要增加的變數預留好空間。在 Mac OS X 10.6 中，Objective-C 的 Runtime 已經原生的支援這個功能了。如果我們想向一個已有的類新增變數，看起來像這樣…

#import <Cocoa/Cocoa.h> //Cocoa
#include <objc/runtime.h> //objc runtime api’s 

@interface NSView (CustomAdditions)
@property(retain) NSImage *customImage;
@end 

@implementation NSView (CustomAdditions) 

static char img_key; //has a unique address (identifier)

- (NSImage *)customImage
{    
    return objc_getAssociatedObject(self,&img_key);
}

- (void)setCustomImage:(NSImage *)image
{    
    objc_setAssociatedObject(self, &img_key,image, OBJC_ASSOCIATION_RETAIN);
} 

@end

objc_setAssociatedObject() 的選項，你可以在 runtime.h 檔案中找到。

/* Associated Object support. */ 

/* objc_setAssociatedObject() options */
enum {    
    OBJC_ASSOCIATION_ASSIGN = 0,    
    OBJC_ASSOCIATION_RETAIN_NONATOMIC = 1,    
    OBJC_ASSOCIATION_COPY_NONATOMIC = 3,    
    OBJC_ASSOCIATION_RETAIN = 01401,    
    OBJC_ASSOCIATION_COPY = 01403
};

#import <Cocoa/Cocoa.h> //Cocoa

#include <objc/runtime.h> //objc runtime api’s

@interface NSView (CustomAdditions)

@property(retain) NSImage *customImage;

@end

@implementation NSView (CustomAdditions)

static char img_key; //has a unique address (identifier)

- (NSImage *)customImage

{

return objc_getAssociatedObject(self,&img_key);

}

- (void)setCustomImage:(NSImage *)image

{

objc_setAssociatedObject(self, &img_key,image, OBJC_ASSOCIATION_RETAIN);

}

@end

objc_setAssociatedObject() 的選項，你可以在 runtime.h 檔案中找到。

/* Associated Object support. */

/* objc_setAssociatedObject() options */

enum {

OBJC_ASSOCIATION_ASSIGN = 0,

OBJC_ASSOCIATION_RETAIN_NONATOMIC = 1,

OBJC_ASSOCIATION_COPY_NONATOMIC = 3,

OBJC_ASSOCIATION_RETAIN = 01401,

OBJC_ASSOCIATION_COPY = 01403

};

這些和 @property 語法中的選項意思一樣。

混和的 vTable Dispatch

如果你看過 modern runtime 的程式碼，你會發現這個（在 objc-runtime-new.m 中）

/***********************************************************************
* vtable dispatch
* 
* Every class gets a vtable pointer. The vtable is an array of IMPs.
* The selectors represented in the vtable are the same for all classes
*   (i.e. no class has a bigger or smaller vtable).
* Each vtable index has an associated trampoline which dispatches to 
*   the IMP at that index for the receiver class's vtable (after 
*   checking for NULL). Dispatch fixup uses these trampolines instead 
*   of objc_msgSend.
* Fragility: The vtable size and list of selectors is chosen at launch 
*   time. No compiler-generated code depends on any particular vtable 
*   configuration, or even the use of vtable dispatch at all.
* Memory size: If a class's vtable is identical to its superclass's 
*   (i.e. the class overrides none of the vtable selectors), then 
*   the class points directly to its superclass's vtable. This means 
*   selectors to be included in the vtable should be chosen so they are 
*   (1) frequently called, but (2) not too frequently overridden. In 
*   particular, -dealloc is a bad choice.
* Forwarding: If a class doesn't implement some vtable selector, that 
*   selector's IMP is set to objc_msgSend in that class's vtable.
* +initialize: Each class keeps the default vtable (which always 
*   redirects to objc_msgSend) until its +initialize is completed.
*   Otherwise, the first message to a class could be a vtable dispatch, 
*   and the vtable trampoline doesn't include +initialize checking.
* Changes: Categories, addMethod, and setImplementation all force vtable 
*   reconstruction for the class and all of its subclasses, if the 
*   vtable selectors are affected.
**********************************************************************/

/***********************************************************************

* vtable dispatch

* Every class gets a vtable pointer. The vtable is an array of IMPs.

* The selectors represented in the vtable are the same for all classes

* (i.e. no class has a bigger or smaller vtable).

* Each vtable index has an associated trampoline which dispatches to

* the IMP at that index for the receiver class's vtable (after

* checking for NULL). Dispatch fixup uses these trampolines instead

* of objc_msgSend.

* Fragility: The vtable size and list of selectors is chosen at launch

* time. No compiler-generated code depends on any particular vtable

* configuration, or even the use of vtable dispatch at all.

* Memory size: If a class's vtable is identical to its superclass's

* (i.e. the class overrides none of the vtable selectors), then

* the class points directly to its superclass's vtable. This means

* selectors to be included in the vtable should be chosen so they are

* (1) frequently called, but (2) not too frequently overridden. In

* particular, -dealloc is a bad choice.

* Forwarding: If a class doesn't implement some vtable selector, that

* selector's IMP is set to objc_msgSend in that class's vtable.

* +initialize: Each class keeps the default vtable (which always

* redirects to objc_msgSend) until its +initialize is completed.

* Otherwise, the first message to a class could be a vtable dispatch,

* and the vtable trampoline doesn't include +initialize checking.

* Changes: Categories, addMethod, and setImplementation all force vtable

* reconstruction for the class and all of its subclasses, if the

* vtable selectors are affected.

**********************************************************************/

背後的思想是，runtime 嘗試在這個 vtable 中儲存最近被呼叫的 selectors，這樣就可以提升你的應用的速度，因為它使用了比 objc_msgSend 更少的指令（fewer instructions）。vtable 中儲存 16 個全域性最經常呼叫的 selectors，事實上順著程式碼往下看你可以發現垃圾回收和非垃圾回收型別程式的預設 selectors …

深入理解Objective-C Runtime
2014-11-05
Object
深入理解 Objective-C Runtime 機制
2017-04-20
Object
Objective-C Runtime
2021-01-16
Object
Runtime理解
2019-02-15
Objective-C Runtime （一）：類與物件
2018-05-24
Object物件
詳解 Objective-C 中的 Runtime
2016-04-19
Object
iOS Runtime的理解
2018-02-27
iOS
Objective-C Runtime（四）isa swizzling
2018-03-27
Object
Objective-C Runtime 1小時入門教程
2016-03-01
Object
Objective-C Runtime （二）：方法與訊息轉發
2018-05-28
Object
Objective-C 的底層實現（Runtime）（轉載）
2016-05-04
Object
Objective-C runtime 拾遺（二）——Log message send
2015-12-25
Object
Objective-C Runtime 執行時之六：拾遺
2014-11-11
Object
死磕Objective-C runtime執行時之一
2016-06-03
Object
Objective-C Runtime 之動態方法解析實踐
2016-04-06
Object
神經病院 Objective-C Runtime 出院第三天——如何正確使用 Runtime
2019-03-04
Object
神經病院Objective-C Runtime出院第三天——如何正確使用Runtime
2016-10-05
Object
Objective-C Runtime 執行時之一：類與物件
2014-11-11
Object物件
深入理解Objective-C：Category
2016-03-25
ObjectGo
iOS －－runtime理解與應用
2017-12-13
iOS
Objective-C Runtime （三）：Method Swizzling（方法替換）
2018-06-06
Object
Objective-C Runtime 執行時之三：方法與訊息
2014-11-11
Object
[譯]理解 Objective-C 執行時
2018-02-27
Object
Go GPM的理解與 runtime包
2022-05-07
Go
Objective-C Runtime 執行時之四：Method Swizzling
2014-11-10
Object
Objective-C Runtime 執行時之五：協議與分類
2014-11-11
Object協議
Objective-C中的self和super理解
2019-01-21
Object
對於Objective-C新建類的理解
2015-09-20
Object
深入理解 Objective-C：方法快取
2015-08-15
Object快取
深入理解Objective-C-Runtime-isa
2019-02-23
Object
深入理解-dl_runtime_resolve
2021-08-20
通過Runtime原始碼瞭解Objective-C中的方法儲存
2019-03-22
原始碼Object
理解 Objective-C 中的指定構造方法
2016-08-08
Object構造方法
iOS開發Runtime的理解與應用
2018-04-09
iOS
【OC刨根問底】-Runtime簡單粗暴理解
2016-06-22
神經病院Objective-C Runtime入院第一天—isa和Class
2019-03-04
Object
Objective-C Runtime 執行時之二：成員變數與屬性
2014-11-11
Object變數
Objective-C runtime 拾遺（四）—— 不常用的程式/執行緒通訊方法
2016-09-17
Object執行緒

理解 OBJECTIVE-C RUNTIME

Objective-C Runtime 是開源的

動態 vs 靜態語言

Objective-C Runtime 是什麼？

Objective-C Runtime 術語

那麼 Class 定義的是物件還是物件本身？它是如何實現的 （譯註：讀者需要區分 Class 和 class 是不同的，正如 Nil 和 nil 的用途是不同的）

為什麼我們繼承自蘋果的類

那麼 Class Cache 是什麼？（objc_cache *cache）

那麼在 objc_msgSend 中發生了什麼？

Objective-C 訊息轉發

Non Fragile ivars（Modern Runtime）（非脆弱的 ivar）

Objective-C 關聯物件

混和的 vTable Dispatch

相關文章

那麼 Class 定義的是物件還是物件本身？它是如何實現的（譯註：讀者需要區分 Class 和 class 是不同的，正如 Nil 和 nil 的用途是不同的）