第三部分：iOS開發(fā)底層原理

1、Objective-C對象模型

1.1 isa指針

NSObject.h部分代碼：

NS_ROOT_CLASS
@interface NSObject <NSObject> {
    Class isa;
}

objc.h部分代碼：

typedef struct objc_class *Class;
typedet struct objc_object {
    Class isa;
} *id;

每個對象都有一個名為isa的指針跪妥，指向該對象的類

isa指針指向流程圖如下：

001isa指針指向流程圖.png

如果把類看成一個C語言的結(jié)構(gòu)體(struct)侦香，isa指針就是這個結(jié)構(gòu)體的第一個成員變量罐韩，類的其他成員變量依次排列在結(jié)構(gòu)體中

排列順序：

一個簡單的繼承的實例代碼：

@interface Father : NSObject {
    int _father;
}

@end

@implementation Father
@end

@interface Child : Father {
    int _child;
}

@end

@implementation Child
@end

在Xcode中，我們看到如下截圖蟆肆，這個結(jié)構(gòu)與上面說的一致

002Xcode截圖.png

因為對象在內(nèi)存中的排布可以看成一個結(jié)構(gòu)體，該結(jié)構(gòu)體的大小并不能動態(tài)變化，所以無法在運行時動態(tài)地給對象增加成員變量赁温。

對象的方法定義都保存在類的可變區(qū)域中。
在下面的 Objective-C 1.0 中，我們可以看到方法的定義列表是一個名為 methodLists 的指針
通過修改指針指向的指針的值，就可以動態(tài)的為某一個類增加成員方法，這也是 Category 實現(xiàn)的原理

Objective-C 1.0 objc_class代碼

struct objc_class {
    Class isa OBJC_ISA_AVAILABILITY;
#if !__OBJC2__
    Class super _class
    const char *name
    long version
    long info
    long instance_size
    struct objc_ivar_list *ivars
    struvt objc_method_list **methodLists
    struct objc_cache *cache
    struct objc_protocol_list *protocols
#endIf
} OBJC2_UNAVAILABLE

1.2 動態(tài)創(chuàng)建對象

#import <objc/runtime.h>

...

- (void)dynamicCreateClass {
    // 創(chuàng)建一個名為CustomView的類，它是UIView的子類
    Class newClass = objc_allocateClassPair([UIView class], "CustomView", 0);
    // 為這個類增加一個report的方法
    class_addMethod(newClass, @selector(report), (IMP)ReportFunction, "v@:");
    // 注冊該類
    objc_registerClassPair(newClass);
    
    // 創(chuàng)建一個newClass的實例對象
    id instanceOfNewClass = [[newClass alloc] init];
    // 調(diào)用report方法
    [instanceOfNewClass performSelector:@selector(report)];
}

void ReportFunction(id self, SEL _cmd) {
    NSLog(@"This object is %p", self);
    NSLog(@"Class is %@, and super is %@", [self class], [self superclass]);
    Class currentClass = [self class];
    for (int i = 1; i < 5; i++) {
        NSLog(@"Following the isa pointer %d times gives %@ = %p", i, currentClass, currentClass);
        // 獲取對象的isa指針所指向的對象
        currentClass = object_getClass(currentClass);
    }
    NSLog(@"NSObject class is %@ = %p", [NSObject class], [NSObject class]);
    NSLog(@"NSObject meta class is %@ = %p", object_getClass([NSObject class]), object_getClass([NSObject class]));
}

代碼關(guān)鍵點：

1. import runtime 相關(guān)的頭文件：objc/runtime.h妙真。
2. 使用 objc_allocateClassPair 方法創(chuàng)建新的類。
3. 使用 class_addMethod 方法來給類增加新的方法。
4. 使用 objc_registerClassPair 方法來注冊新的類泵琳。
5. 使用 objc_getClass 方法來獲取對象的isa指針指向的對象琳钉。

1.3 方法交換（Method Swizzling）API說明

Objective-C提供了以下API來動態(tài)替換類方法或?qū)嵗椒ǖ膶崿F(xiàn)：

• class_replaceMethod 替換類方法的定義

class_replaceMethod(Class  _Nullable __unsafe_unretained cls, SEL  _Nonnull name, IMP  _Nonnull imp, const char * _Nullable types)

• method_exchangeImplementations 交換兩個方法的實現(xiàn)

method_exchangeImplementations(Method  _Nonnull m1, Method  _Nonnull m2)

• method_setImplementation 設(shè)置一個方法的實現(xiàn)

method_setImplementation(Method  _Nonnull m, IMP  _Nonnull imp)

比較：

• class_replaceMethod 當類中沒有找到要替換的原方法時啦桌，該方法會調(diào)用 class_addMethod 來為類增加一個新的方法且改，也正因為這樣慨蓝，class_replaceMethod 在調(diào)用時需要傳入 type 參數(shù)弧满，而 method_exchangeImplementations 和 method_setImplementation 都不需要
• method_exchangeImplementations 內(nèi)部實現(xiàn)是獲取到兩個方法的實現(xiàn)犀忱，然后進行互換

文檔如下圖：

003method_exchangeImplementations文檔截圖.png

使用場景：

• class_replaceMethod 當需要替換的方法有可能不存在時数冬，可以考慮使用該方法地来。
• method_exchangeImplementations 當需要交換兩個方法的實現(xiàn)時使用。
• method_setImplementation 是最簡單的用法芽突，當僅僅需要為一個方法設(shè)置其實現(xiàn)方式時使用钠糊。

2、Tagged Pointer 對象

2.1 原有系統(tǒng)的問題

32位程序過渡到64位存在的問題：

• 問題一：內(nèi)存翻倍岗喉。
  在iOS數(shù)據(jù)類型中诞丽，很多數(shù)據(jù)類型所占內(nèi)存都是根據(jù)CPU的位數(shù)決定的金踪。那么，當程序從32位程序過渡到64位時胡岔，這些數(shù)據(jù)類型的內(nèi)存就會翻倍法希。如下圖所示：

  
  
  004內(nèi)存翻倍示意圖.png
• 問題二：效率問題。
  為了存儲和訪問一個NSNumber對象靶瘸，我們需要在堆上為其分配內(nèi)存苫亦，另外還要維護它的引用計數(shù)，管理它的生命周期怨咪。這些都給程序增加了額外的邏輯屋剑，造成運行效率上的損失，

2.2 Tagged Pointer 介紹

Tagged Pointer就是為了解決上述問題提出的诗眨。
原理：將一個對象指針拆分為兩部分唉匾。如下圖：

005TaggedPointer結(jié)構(gòu)示意圖.png

引入后，內(nèi)存變化如下圖：

006優(yōu)化后內(nèi)存示意圖.png

特點：

1. 專門用來存儲小的對象匠楚，例如 NSNumber 和 NSDate
2. 指針的值不再是地址了肄鸽，而是真正的值卫病。所以，實際上它不再是一個對象了典徘，它只是一個披著對象’皮‘的普通變量而已。所以益咬，它的內(nèi)存并不存儲在堆中逮诲，也不需要 malloc 和 free
3. 在內(nèi)存讀取上有著以前3倍的效率，創(chuàng)建時比之前快106倍

注：Tagged Pointer 并不是真正的對象幽告，而是一個偽對象梅鹦，沒有 isa 指針

2.2 64位下 isa 指針優(yōu)化

32位環(huán)境：

對象的引用計數(shù)都保存在一個外部表中。

Retain 操作包含如下的5個步驟：

1. 獲取全局的記錄引用計數(shù)的 hash 表冗锁。
2. 為了線程安全齐唆，給該 hash 表加鎖。
3. 查找到目標對象的引用計數(shù)值冻河。
4. 將該引用計數(shù)值加1箍邮，寫回 hash 表。
5. 給該 hash 表解鎖叨叙。

為了線程安全锭弊，需要對 hash 表進行加鎖，從性能上看是非常差的擂错。

64位環(huán)境：

isa指針是64位味滞。每個bit位含義如下圖:

extra_rc 的19位 bit 用來保存對象的引用計數(shù)田度，這樣對引用計數(shù)的操作只需要修改這個職責即可。

Retain 操作包含如下的5個步驟：

1. 檢查 isa 指針上面的標記位解愤，看引用計數(shù)是否保存在 isa 變量中镇饺，如果不是，則使用以前的步驟送讲，否則執(zhí)行第2步奸笤。
2. 檢查當前對象是否正在釋放惋啃，如果是，則不做任何事情监右。
3. 增加該對象的引用計數(shù)边灭，但是并不馬上寫回到 isa 變量中。
4. 檢查增加后的引用計數(shù)的值是否能夠被19位表示健盒，如果不是绒瘦，則切換為以前的辦法，否則執(zhí)行第5步扣癣。
5. 進行一個原子的寫操作惰帽，將 isa 的值寫回。

3父虑、block 對象模型

3.1 定義：

在蘋果的 llvm 項目的開源代碼(https://llvm.org/svn/llvm-project/compiler-rt/tags/Apple/Libcompiler_rt-10/BlocksRuntime/Block_private.h)中该酗，我們可以看到 block 的數(shù)據(jù)結(jié)構(gòu)定義，如下圖：

007block的數(shù)據(jù)結(jié)構(gòu).png

對應(yīng)的結(jié)構(gòu)體定義如下：

struct Block_descriptor {
    unsigned long int reserved;
    unsigned long int size;
    void (*copy)(void *dst, void *src);
    void (*dispose)(void *);
};

struct Block_layout {
    void *isa;
    int flags;
    int reserved;
    void (*invoke)(void *, ...);
    struct Block_descriptor *descriptor;
    /* Imported variables */
};

組成 block 實例的6個部分：

1. isa 指針士嚎，所有對象都有該指針呜魄，用于實現(xiàn)對象的相關(guān)的功能。
2. flags 用于按 bit 位表示一些 block 的附加信息航邢，在后面介紹的 block copy 的實現(xiàn)代碼中可以看到該變量的使用耕赘。
3. reserved 保留變量。
4. invoke 函數(shù)指針膳殷，指向具體的 block 實現(xiàn)的函數(shù)調(diào)用地址操骡。
5. descriptor 表示該 block 的附加描述信息，主要是 size 的大小赚窃，以及 copy 和 dispose 函數(shù)的指針册招。
6. variable capture 過來的變量，block 能夠訪問它外部的局部變量勒极，就是因為將這些變量（或變量的地址）復(fù)制到了結(jié)構(gòu)體中是掰。

3.2 分類：

block 的類型：

1. _NSConcreteGlobalBlock 全局的靜態(tài) block，不會訪問任何外部變量辱匿。
2. _NSConcreteStackBlock 保存在棧中的 block键痛，當函數(shù)返回時會被銷毀。
3. _NSConcreteMallocBlock 保存在堆中的 block匾七，當引用計數(shù)為 0 時會被銷毀絮短。

注：用 clang 分析 block 實現(xiàn)

clang 提供了一個命令，可以將 Objective-C 的源碼改寫成C語言昨忆。
命令是：clang -rewrite-objc block.c

3.2.1 NSConcreteGlobalBlock 類型的 block 的實現(xiàn)

創(chuàng)建一個名字為 block1.c 的源文件丁频，文件實現(xiàn)：

#include <stdio.h>

int main(int argc, char const *argv[]) {
    ^{ printf("Hello, World!\n"); } ();
    return 0;
}

在命令行中輸入 clang -rewrite-objc block1.c，即可在目錄中看到 clang 輸出了一個名為 ”block1.cpp” 的文件，這個文件就是 block 在C語言中的實現(xiàn)席里。
關(guān)鍵代碼引用如下：

...
struct __block_impl {
  void *isa;
  int Flags;
  int Reserved;
  void *FuncPtr;
};
...
struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
 printf("Hello, World!\n"); }

static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};
int main(int argc, char const *argv[])
{
    ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA)) ();
    return 0;
}

代碼中叔磷，__main_block_impl_0 就是該 block 的實現(xiàn)，從中我們可以看出：

1. 一個 block 實際是一個對象奖磁，它主要由一個 isa改基、一個 impl 和一個 descriptor 組成。
2. 由于這里沒有開啟 ARC署穗，所以我們看到 isa 的指向還是 _NSConcreteStackBlock寥裂。但在開啟 ARC 時，block 應(yīng)該是 _NSConcreteGlobalBlock 類案疲。
3. impl 是實際函數(shù)指針，本例中麻养，它指向 __main_block_func_0褐啡。這里的 impl 相當于之前提到的 invoke 變量，只是 clang 編譯器對變量的命名不一樣而已鳖昌。
4. descriptor 是用于描述當前這個 block 的附加信息的备畦，包括結(jié)構(gòu)體的大小，需要 capture 和 dispose 的變量列表等许昨。
   結(jié)構(gòu)體大小需要保存到原因是懂盐，每個 block 會 capture 一些變量，這里變量會加到 __main_block_impl_0 這個結(jié)構(gòu)體中糕档，使其體積變大莉恼。

具體文件見：https://github.com/AlonerOwl/OC_Block/tree/master/NSConcreteGlobalBlock

3.2.2 NSConcreteStackBlock 類型的 block 的實現(xiàn)

創(chuàng)建一個名字為 block1.c 的源文件，文件實現(xiàn)：

#include <stdio.h>

int main(int argc, char const *argv[]) {
    int a = 100;
    void (^block2)(void) = ^{ // block 實現(xiàn)
        printf("%d\n", a);
    };
    block2();
    
    return 0;
}

clang 后：

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  int a;
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _a, int flags=0) : a(_a) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  int a = __cself->a; // bound by copy

        printf("%d\n", a);
    }

static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};
int main(int argc, char const *argv[]) {
    int a = 100;
    void (*block2)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, a));
    ((void (*)(__block_impl *))((__block_impl *)block2)->FuncPtr)((__block_impl *)block2);

    return 0;
}

在本例中速那，我們可以看到：

1. 本例中俐银，isa 指向 _NSConcreteStackBlock，說明這是一個分配在棧上的實例端仰。
2. __main_block_impl_0 中增加一個變量 a捶惜，在 block 中引用的變量 a，實際是在聲明 block 時荔烧，被復(fù)制到 __main_block_impl_0 結(jié)構(gòu)體中的那個變量 a吱七。
3. __main_block_impl_0 中由于增加一個變量 a，所以結(jié)構(gòu)體變大了鹤竭，該結(jié)構(gòu)體大小被寫在了 __main_block_desc_0 中踊餐。

我們修改上面的源碼，在變量前面增加 __block 關(guān)鍵字：

#include <stdio.h>

int main(int argc, char const *argv[]) {
    __block int i = 1024;
    void (^block2)(void) = ^{ // block 實現(xiàn)
        printf("%d\n", i);
        i = 1023;
    };
    block2();
    
    return 0;
}

clang 后诺擅，與之前差異相當大：

struct __Block_byref_i_0 {
  void *__isa;
__Block_byref_i_0 *__forwarding;
 int __flags;
 int __size;
 int I;
};

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __Block_byref_i_0 *i; // by ref
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_i_0 *_i, int flags=0) : i(_i->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  __Block_byref_i_0 *i = __cself->i; // bound by ref

        printf("%d\n", (i->__forwarding->i));
        (i->__forwarding->i) = 1023;
    }
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->i, (void*)src->i, 8/*BLOCK_FIELD_IS_BYREF*/);}

static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->i, 8/*BLOCK_FIELD_IS_BYREF*/);}

static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
  void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*);
  void (*dispose)(struct __main_block_impl_0*);
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0), __main_block_copy_0, __main_block_dispose_0};

int main(int argc, char const *argv[]) {
    __attribute__((__blocks__(byref))) __Block_byref_i_0 i = {(void*)0,(__Block_byref_i_0 *)&i, 0, sizeof(__Block_byref_i_0), 1024};
    void (*block2)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_i_0 *)&i, 570425344));
    ((void (*)(__block_impl *))((__block_impl *)block2)->FuncPtr)((__block_impl *)block2);

    return 0;
}

從代碼中我們可以看到：

1. 源碼中增加了一個名為 __Block_byref_i_0 的結(jié)構(gòu)體市袖，用于保存我們要 capture 并且修改的變量 i。
2. __main_block_impl_0 中引用的是 __Block_byref_i_0 的結(jié)構(gòu)體指針，這樣就可以起到修改外部變量的作用苍碟。
3. __Block_byref_i_0 的結(jié)構(gòu)體帶有 isa酒觅，說明它也是一個對象。
4. 我們需要負責 __Block_byref_i_0 結(jié)構(gòu)體相關(guān)的內(nèi)存管理微峰，所有 __main_block_desc_0 中增加了 copy 和 dispose 函數(shù)指針舷丹，用于在調(diào)用前后修改相應(yīng)變量的引用計數(shù)。

具體文件見：https://github.com/AlonerOwl/OC_Block/tree/master/NSConcreteStackBlock

總結(jié)：
block 對于外部變量的使用蜓肆，非 __block 修飾的變量颜凯，直接將其復(fù)制到 block 數(shù)據(jù)結(jié)構(gòu)中來實現(xiàn)訪問；__block 修飾的變量仗扬，復(fù)制這個變量的引用地址來實現(xiàn)訪問的症概。

3.2.3 NSConcreteMallocBlock 類型的 block 的實現(xiàn)

NSConcreteMallocBlock 類型的 block 通常不會在源碼中直接出現(xiàn)，只有當一個 block 被調(diào)用其 copy 方法的時候早芭，系統(tǒng)才會將這個 block 復(fù)制到堆中彼城，從而產(chǎn)生 NSConcreteMallocBlock 類型的 block。

注：在 ARC 開啟的情況下退个，將只會存在 NSConcreteGlobalBlock 和 NSConcreteMallocBlock 類型的 block募壕。原來的 NSConcreteStackBlock 會被 NSConcreteMallocBlock 的進行替代。