iOS | Runtime原理及應用

Runtime介紹

高級編程語言想要成爲可執行文件需先編譯爲彙編語言再彙編爲機器語言，機器語言也是計算機能夠識別的唯一語言，但是OC並不能直接編譯爲彙編語言，而是要先轉寫爲純c語言再進行編譯和彙編操作，從OC到C語言的過渡就是runtime來實現的。然而我們使用OC進行面向對象開發，而C語言更多的是面向過程開發，這就需要將面向對象的類轉變爲面向過程的結構體。

Runtime消息傳遞

一個對象的方法像這樣[obj foo]，編譯器轉成消息發送objc_msgSend(obj, foo), Runtime時執行的流程是這樣的。

首先，通過obj的isa指針找到它的class;
在class的method List找foo；
如果class中沒有foo，就繼續前往它的superclass中去查找;
一旦找到foo這個函數，就去執行它的實現IMP。

但是這種實現有個問題，效率低。一個Class 往往只有20%的函數會被經常調用，可能佔總調用次數的80%。每次消息都需要遍歷一次objc_method_list 並不合理。如果把經常被調用的函數緩存下來，那可以大大提高函數查詢的效率。這就是objc_class中另一個重要成員objc_cache做的事情，再找到foo之後，把foo的methed_name作爲key，method_imp作爲value緩存起來。當再次收到foo消息的時候，可以直接在cache裏找到，避免去遍歷objc_method_list。

objc_msgSend的方法定義如下：

OBJC_EXPORT id objc_msgSend(id self, SEL op, ...)

那消息傳遞是怎麼實現的呢？我們看看對象(object)，類(class)，方法(method)這幾個的結構體：

//對象
struct objc_object {
    Class isa  OBJC_ISA_AVAILABILITY;
};
//類
struct objc_class {
    Class isa  OBJC_ISA_AVAILABILITY;
#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_list *protocols                     OBJC2_UNAVAILABLE;
#endif
} OBJC2_UNAVAILABLE;
//方法列表
struct objc_method_list {
    struct objc_method_list *obsolete                        OBJC2_UNAVAILABLE;
    int method_count                                         OBJC2_UNAVAILABLE;
#ifdef __LP64__
    int space                                                OBJC2_UNAVAILABLE;
#endif
    /* variable length structure */
    struct objc_method method_list[1]                        OBJC2_UNAVAILABLE;
}                                                            OBJC2_UNAVAILABLE;
//方法
struct objc_method {
    SEL method_name                                          OBJC2_UNAVAILABLE;
    char *method_types                                       OBJC2_UNAVAILABLE;
    IMP method_imp                                           OBJC2_UNAVAILABLE;
}

系統首先找到消息的接受對象，然後通過對象的isa找到它的類。
在它的類中查找method_list，是否有selector方法。
沒有則查找父類的method_list
找到對應的method，執行它的IMP
轉發IMP的return值。

消息傳遞中的概念：

類對象(objc_class)

oc類是由Class類型表示的，它實際上一個指向objc_class結構體的指針。

typedef struct objc_class *Class;

查看objc/runtime.h中objc_class結構體的定義如下：

struct objc_class {
    Class _Nonnull isa  OBJC_ISA_AVAILABILITY;

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

} OBJC2_UNAVAILABLE;

可以看出類對象就是一個結構體struct objc_class，這個結構體存放的數據稱爲元數據(metadata)，該結構體的第一個成員變量也是isa指針，這就說明了Class本身也是一個對象，我們稱之爲類對象，類對象在編譯期產生用於創建實例對象，是單例。

實例(objc_object)

/// Represents an instance of a class.
struct objc_object {
    Class isa  OBJC_ISA_AVAILABILITY;
};

/// A pointer to an instance of a class.
typedef struct objc_object *id;

類對象中的元數據存儲的都是如何創建一個實例的相關信息，那麼類對象和類方法應該從哪裏創建呢？

就是從isa指針指向的結構體創建，類對象的isa指針指向的我們稱之爲元類(metaclass)。

元類中保存了創建類對象以及類方法所需要的所有信息。

元類(Meta Class)

整個系統形成了一個自閉環，struct objc_object 結構體實例的isa指針指向類對象。

類對象的 isa 指針指向元類，super_class 指針指向父類的類對象。

元類的 super_class 指針指向父類的元類，而元類的isa指針又指向了自己。

元類(Meta Class)是一個類對象的類。而所有的類自身也是一個對象，我們可以向這個對象發送消息(即調用類方法)。

爲了調用類方法，這個類的isa指針必須指向一個包含這些類方法的一個objc_class 結構體。這就引出了 meta-class 的概念，元類中保存了創建類對象以及類方法所需要的所有信息。

任何NSObject 繼承體系下的 meta-class 都使用 NSObject 的meta-class 作爲自己的所屬類，而基類的 meta-class 的 isa 指針是指向它自己。

Method(objc_method)

定義：

/// An opaque type that represents a method in a class definition.代表類定義中一個方法的不透明類型
typedef struct objc_method *Method;
struct objc_method {
    SEL method_name        OBJC2_UNAVAILABLE;
    char *method_types     OBJC2_UNAVAILABLE;
    IMP method_imp         OBJC2_UNAVAILABLE;
}

結構體中的內容：

SEL method_name 方法名
char *method_types 方法類型
IMP method_imp 方法實現

SEL(objc_selector)

objc.h
/// An opaque type that represents a method selector.代表一個方法的不透明類型
typedef struct objc_selector *SEL;

Objc_msgSend函數的第二個參數爲SEL，它是selector在oc中表示類型。selector 是方法選擇器，可以理解爲區分方法的ID，而這個ID的數據結構爲SEL。

其實selector 就是映射到方法的 c 字符串，可以用 Objective-C 編譯器命令@selector()或者 Runtime 系統的sel_registerName函數來獲得一個 SEL 類型的方法選擇器。

selector是一個string，是類似className+method的組合，命名規則有兩條：

同一個類，selector不能重複
不同的類，selector可以重複

這也帶來一個弊端，Objective-c中是沒有函數重載的(函數名相同，參數不同)，因爲selector只記錄了函數的name沒有記錄參數，所以沒辦法區分不同的 method。

比如：

- (void)caculate(NSInteger)num;
- (void)caculate(CGFloat)num;

是會報錯的。

我們只能通過命名來區別：

- (void)caculateWithInt(NSInteger)num;
- (void)caculateWithFloat(CGFloat)num;

在不同類中相同名字的方法所對應的方法選擇器是相同的，即使方法名字相同而變量類型不同也會導致它們具有相同的方法選擇器。

IMP

/// A pointer to the function of a method implementation.  指向一個方法實現的指針
typedef id (*IMP)(id, SEL, ...); 
#endif

就是指向最終實現程序的內存地址的指針。

在iOS的Runtime中，Method通過selector和IMP兩個屬性，實現了快速查詢方法及實現，相對提高了性能，又保持了靈活性。

類緩存(objc_cache)

當objective-c運行時通過跟蹤它的isa指針檢查對象時，可以找到一個實現很多方法的對象。然而，你可能只調用他們的一小部分，並且每次檢查時，搜索所有選擇器的類分派表沒有意義。所以類實現一個緩存，每當你搜索一個類分派表，並找到相應的選擇器，它把它放入它的緩存。所以當objc_msg查找一個類的選擇器，它會先搜索類緩存。這是基於這樣的理論：如果你在類上調用一個消息，你可能以後再次調用該消息。

爲了加速消息分發，系統會對方法和對應的地址進行緩存，放在objc_cache中，所以實際運行中，大部分常用的方法都會被緩存起來，Runtime 系統實際上非常快，接近直接執行內存地址的程序速度。

Category(objc_category)

Category 是表示一個指向分類的結構體指針，其定義如下：

struct category_t { 
    const char *name; 
    classref_t cls; 
    struct method_list_t *instanceMethods; 
    struct method_list_t *classMethods;
    struct protocol_list_t *protocols;
    struct property_list_t *instanceProperties;
};

name：是指 class_name 而不是 category_name。
cls：要擴展的類對象，編譯期間是不會定義的，而是在Runtime階段通過name對應到對應的類對象。
instanceMethods：category中所有給類添加的實例方法的列表。
classMethods：category中所有添加的類方法的列表。
protocols：category實現的所有協議的列表。
instanceProperties：表示Category裏所有的properties，這就是我們可以通過objc_setAssociatedObject和objc_getAssociatedObject增加實例變量的原因，不過這個和一般的實例變量是不一樣的。

從上面的category_t的結構體中可以看出，分類中可以添加實例方法，類方法，甚至可以實現協議，添加屬性，不可以添加成員變量。

Runtime消息轉發

進行一次發送消息會在相關的類對象中搜索方法列表，如果找不到則會沿着繼承樹一直搜索直到繼承樹的根部(通常爲NSObject)，如果還是找不到並且消息轉發都失敗了就會執行doesNotRecognizeSelector:方法報 unrecongnized selector。下面說一下消息轉發：

動態方法解析
備用接收者
完整消息轉發

動態方法解析：

首先，Objective-C運行時會調用 +resolveInstanceMethod:或者 +resolveClassMethod:，讓你有機會提供一個函數實現。如果你添加了函數並返回YES，那運行時系統就會重新啓動一次消息發送的過程。

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view, typically from a nib.
    [self performSelector:@selector(foo:)];
}

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

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

2019-06-05 03:53:29.815835+0800 TestDemo[821:15514] Doing foo

可以看到雖然沒有實現foo:這個函數，但是通過class_addMethod 動態添加了fooMethod 函數，並執行fooMethod 這個函數的IMP。如果resolve 方法返回NO，運行就會移到下一步：forwardingTargetForSelector。

備用接收者

如果目標對象實現了forwardingTargetForSelector，Runtime這時就會調用這個方法，給你把這個消息轉發給其他對象的機會。所以說是備用接收者。

#import "ViewController.h"
#import "objc/runtime.h"

@interface Person : NSObject

@end

@implementation Person

- (void)foo {
    NSLog(@"Doing foo");
}

@end

@interface ViewController ()

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view, typically from a nib.
    [self performSelector:@selector(foo)];
}

- (id)forwardingTargetForSelector:(SEL)aSelector
{
    if (aSelector == @selector(foo))
    {
        return [Person new];
    }
    return [super forwardingTargetForSelector:aSelector];
}

@end

我們可以看到通過forwardingTargetForSelector把當前 ViewController 的方法轉發給了 Person 去執行，併成功執行。

完整消息轉發

如果在上一步還不能處理未知消息，則唯一能做的就是啓用完整的消息轉發機制了。首先它會發送-methodSignatureForSelector:消息獲得函數的參數和返回值類型。如果-methodSignatureForSelector:返回nil ，Runtime則會發出 -doesNotRecognizeSelector: 消息，程序這時也就掛掉了。如果返回了一個函數簽名，Runtime就會創建一個NSInvocation 對象併發送 -forwardInvocation:消息給目標對象。

#import "ViewController.h"
#import "objc/runtime.h"

@interface Person : NSObject

@end

@implementation Person

- (void)foo {
    NSLog(@"Doing foo");
}

@end

@interface ViewController ()

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view, typically from a nib.
    [self performSelector:@selector(foo)];
}

- (id)forwardingTargetForSelector:(SEL)aSelector
{
    return nil;
}

+ (BOOL)resolveInstanceMethod:(SEL)sel
{
    return NO;
}

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

-(NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector
{
    if ([NSStringFromSelector(aSelector) isEqualToString:@"foo"]) {
        return [NSMethodSignature signatureWithObjCTypes:"v@:"];
    }
    return [super methodSignatureForSelector:aSelector];
}

- (void)forwardInvocation:(NSInvocation *)anInvocation
{
    SEL sel = anInvocation.selector;
    Person *p = [Person new];
    if ([p respondsToSelector:sel]) {
        [anInvocation invokeWithTarget:p];
    }
    else {
        [self doesNotRecognizeSelector:sel];
    }
}

@end

2019-06-05 04:14:05.722619+0800 TestDemo[1195:29921] Doing foo

從打印結果看，實現了完整的轉發，通過簽名，Runtime 生成了一個對象 anInvocation，發送給了forwardInvocation，我們在forwardInvocation方法裏讓Person對象去執行了foo函數。其中籤名參數v@就是指void類型。

以上就是Runtime的三次轉發流程。

Runtime應用

Runtime簡直就是做大型框架的利器。它的應用場景很多，下面介紹一些常見的應用場景。

關聯對象(OC Associated Objects)給分類增加屬性
方法魔法(Method Swizzling)方法添加和替換和KVO實現
消息轉發(熱更新)解決Bug(JSPatch)
實現NSCoding的自動歸檔和自動解檔
實現字典和模型的自動轉換

關聯對象給分類增加屬性

關聯對象Runtime提供了下面幾個接口：

//關聯對象
void objc_setAssociatedObject(id object, const void *key, id value, objc_AssociationPolicy policy)
//獲取關聯的對象
id objc_getAssociatedObject(id object, const void *key)
//移除關聯的對象
void objc_removeAssociatedObjects(id object)

參數解釋：

id object：被關聯的對象
const void *key：關聯的key，要求唯一
id value：關聯的對象
objc_AssociationPolicy policy：內存管理的策略

內存管理的策略：

內存策略	屬性修飾	描述
OBJC_ASSOCIATION_ASSIGN	@property (assign) 或 @property (unsafe_unretained)	指定一個關聯對象的弱引用。
OBJC_ASSOCIATION_RETAIN_NONATOMIC	@property (nonatomic, strong)	@property (nonatomic, strong) 指定一個關聯對象的強引用，不能被原子化使用。
OBJC_ASSOCIATION_COPY_NONATOMIC	@property (nonatomic, copy)	指定一個關聯對象的copy引用，不能被原子化使用。
OBJC_ASSOCIATION_RETAIN	@property (atomic, strong)	指定一個關聯對象的強引用，能被原子化使用。
OBJC_ASSOCIATION_COPY	@property (atomic, copy)	指定一個關聯對象的copy引用，能被原子化使用。

#import "ViewController.h"
#import "objc/runtime.h"

@interface UIView (DefaultColor)

@property (nonatomic, strong) UIColor *defaultColor;

@end

@implementation UIView (DefaultColor)

static char kDefaultColorKey;

- (void)setDefaultColor:(UIColor *)defaultColor {
    objc_setAssociatedObject(self, &kDefaultColorKey, defaultColor, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}

- (id)defaultColor {
    return objc_getAssociatedObject(self, &kDefaultColorKey);
}

@end

@interface ViewController ()

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view, typically from a nib.
    
    UIView *test = [UIView new];
    test.defaultColor = [UIColor blackColor];
    NSLog(@"%@", test.defaultColor);
}

@end

打印結果：

2019-06-05 09:30:29.002794+0800 TestDemo[1131:26732] UIExtendedGrayColorSpace 0 1

方法魔法(Method Swizzling)方法添加和替換和KVO實現

實際上添加方法剛纔在講消息轉發的時候，動態方法解析的時候就提到了。

//class_addMethod(Class  _Nullable __unsafe_unretained cls, SEL  _Nonnull name, IMP  _Nonnull imp, const char * _Nullable types)
class_addMethod([self class], sel, (IMP)fooMethod, "v@:");

cls 被添加方法的類
name 添加的方法的名稱的SEL
imp方法的實現，該函數必須至少有兩個參數，self，_cmd
方法類型

#import "ViewController.h"
#import "objc/runtime.h"

@implementation ViewController

+ (void)load {
    
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        Class class = [self class];
        SEL originalSelector = @selector(viewDidLoad);
        SEL swizzledSelector = @selector(jkviewDidLoad);
        
        Method originalMethod = class_getInstanceMethod(class,originalSelector);
        Method swizzledMethod = class_getInstanceMethod(class,swizzledSelector);
        
        //judge the method named  swizzledMethod is already existed.
        BOOL didAddMethod = class_addMethod(class, originalSelector, method_getImplementation(swizzledMethod), method_getTypeEncoding(swizzledMethod));
        // if swizzledMethod is already existed.
        
        if (didAddMethod) {
            class_replaceMethod(class, swizzledSelector, method_getImplementation(originalMethod), method_getTypeEncoding(originalMethod));
        }
        else {
            method_exchangeImplementations(originalMethod, swizzledMethod);
        }
        
    });
}

- (void)jkviewDidLoad {
    NSLog(@"替換的方法");
    // 如果不執行下一步只會執行打印替換的方法
    [self jkviewDidLoad];
}

- (void)viewDidLoad {
    NSLog(@"自帶的方法");
    
    [super viewDidLoad];
}
@end

swizzling應該只在+load中完成。在 Objective-C 的運行時中，每個類有兩個方法都會自動調用。+load 是在一個類被初始裝載時調用，+initialize 是在應用第一次調用該類的類方法或實例方法前調用的。兩個方法都是可選的，並且只有在方法被實現的情況下才會被調用。

swizzling應該只在dispatch_once 中完成,由於swizzling 改變了全局的狀態，所以我們需要確保每個預防措施在運行時都是可用的。原子操作就是這樣一個用於確保代碼只會被執行一次的預防措施，就算是在不同的線程中也能確保代碼只執行一次。Grand Central Dispatch 的 dispatch_once滿足了所需要的需求，並且應該被當做使用swizzling 的初始化單例方法的標準。

2019-06-05 09:50:39.256374+0800 TestDemo[1359:36735] 替換的方法
2019-06-05 09:50:39.256505+0800 TestDemo[1359:36735] 自帶的方法

KVO實現

全稱是Key-value observing，翻譯成鍵值觀察。提供了一種當其它對象屬性被修改的時候能通知當前對象的機制。再MVC大行其道的Cocoa中，KVO機制很適合實現model和controller類之間的通訊。

KVO 的實現依賴於OC的Runtime，當觀察某對象A時，KVO 機制動態創建一個對象A當前類的子類，併爲這個新的子類重寫了被觀察屬性 keyPath 的 setter 方法。setter 方法隨後負責通知觀察對象屬性的改變狀況。

Apple 使用了 isa-swizzling 來實現 KVO。當觀察對象 A 時，KVO機制動態創建一個新的名爲：NSKVONofifying_A 的新類，該類繼承自對象 A 的本類，且 KVO 爲NSKVONotifying_A 重寫觀察屬性的 setter 方法，setter 方法會負責在調用原 setter 方法之前和之後，通知所有觀察對象屬性值的更改情況。

NSKVONotifying_A類剖析：

NSLog(@"self->isa:%@",self->isa);  
NSLog(@"self class:%@",[self class]);

在建立KVO監聽前，打印結果爲：

self->isa:A
self class:A

在建立KVO監聽之後，打印結果爲：

self->isa:NSKVONotifying_A
self class:A

在這個過程，被觀察對象的 isa 指針從指向原來的 A 類，被KVO 機制修改爲指向系統新創建的子類NSKVONotifying_A 類，來實現當前類屬性值改變的監聽；
所以當我們從應用層面上看來，完全沒有意識到有新的類出現，這是系統“隱瞞”了對 KVO 的底層實現過程，讓我們誤以爲還是原來的類。但是此時如果我們創建一個新的名爲“NSKVONotifying_A”的類，就會發現系統運行到註冊 KVO 的那段代碼時程序就崩潰，因爲系統在註冊監聽的時候動態創建了名爲 NSKVONotifying_A 的中間類，並指向這個中間類了。

子類setter方法剖析

KVO 的鍵值觀察通知依賴於 NSObject 的兩個方法:willChangeValueForKey:和 didChangeValueForKey: ，在存取數值的前後分別調用 2 個方法：
被觀察屬性發生改變之前，willChangeValueForKey:被調用，通知系統該 keyPath 的屬性值即將變更；
當改變發生後， didChangeValueForKey: 被調用，通知系統該keyPath 的屬性值已經變更；之後， observeValueForKey:ofObject:change:context:也會被調用。且重寫觀察屬性的setter 方法這種繼承方式的注入是在運行時而不是編譯時實現的。

KVO 爲子類的觀察者屬性重寫調用存取方法的工作原理在代碼中相當於：

- (void)setName:(NSString *)newName { 
      [self willChangeValueForKey:@"name"];    //KVO 在調用存取方法之前總調用 
      [super setValue:newName forKey:@"name"]; //調用父類的存取方法 
      [self didChangeValueForKey:@"name"];     //KVO 在調用存取方法之後總調用
}

iOS | Runtime原理及應用

Runtime介紹

Runtime消息傳遞

消息傳遞中的概念：

類對象(objc_class)

實例(objc_object)

元類(Meta Class)

Method(objc_method)

SEL(objc_selector)

IMP

類緩存(objc_cache)

Category(objc_category)

Runtime消息轉發

動態方法解析：

備用接收者

完整消息轉發

Runtime應用

關聯對象給分類增加屬性

方法魔法(Method Swizzling)方法添加和替換和KVO實現

KVO實現

iOS的MVC設計模式和MVVM的異同點以及iOS中如何實現數據綁定

iOS | 內存管理(MRC和ARC的區別以及實現)

iOS | Runtime原理及應用

內存管理 || 物理內存的管理

iOS多線程和網絡

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結