【原】iOS開發進階(唐巧)讀書筆記(二)

第三部分：iOS開發底層原理

一、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指針指向流程圖以下：

若是把類當作一個C語言的結構體(struct)，isa指針就是這個結構體的第一個成員變量，類的其餘成員變量依次排列在結構體中

排列順序：
| 1 | isa指針 |
| --- | --- |
| 2 | NSObject的成員變量 |
| 3 | NSObject子類的成員變量 |
| 4 | NSObject子類的子類的成員變量 |
| ... | ... |
| n-1 | 父類的成員變量 |
| n | 類自己的成員變量 |

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

@interface Father : NSObject {
    int _father;
}

@end

@implementation Father
@end

@interface Child : Father {
    int _child;
}

@end

@implementation Child
@end

在Xcode中，咱們看到以下截圖，這個結構與上面說的一致

由於對象在內存中的排布能夠當作一個結構體，該結構體的大小並不能動態變化，因此沒法在運行時動態地給對象增長成員變量。

對象的方法定義都保存在類的可變區域中。
在下面的 Objective-C 1.0 中，咱們能夠看到方法的定義列表是一個名爲 methodLists 的指針
經過修改指針指向的指針的值，就能夠動態的爲某一個類增長成員方法，這也是 Category 實現的原理

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 動態建立對象

#import <objc/runtime.h>

...

- (void)dynamicCreateClass {
    // 建立一個名爲CustomView的類，它是UIView的子類
    Class newClass = objc_allocateClassPair([UIView class], "CustomView", 0);
    // 爲這個類增長一個report的方法
    class_addMethod(newClass, @selector(report), (IMP)ReportFunction, "v@:");
    // 註冊該類
    objc_registerClassPair(newClass);
    
    // 建立一個newClass的實例對象
    id instanceOfNewClass = [[newClass alloc] init];
    // 調用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]));
}

代碼關鍵點：

1. import runtime 相關的頭文件：objc/runtime.h。
2. 使用 objc_allocateClassPair 方法建立新的類。
3. 使用 class_addMethod 方法來給類增長新的方法。
4. 使用 objc_registerClassPair 方法來註冊新的類。
5. 使用 objc_getClass 方法來獲取對象的isa指針指向的對象。

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

Objective-C提供瞭如下API來動態替換類方法或實例方法的實現：

• class_replaceMethod 替換類方法的定義

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

• method_exchangeImplementations 交換兩個方法的實現

method_exchangeImplementations(Method  _Nonnull m1, Method  _Nonnull m2)

• method_setImplementation 設置一個方法的實現

method_setImplementation(Method  _Nonnull m, IMP  _Nonnull imp)

比較：

• class_replaceMethod 當類中沒有找到要替換的原方法時，該方法會調用 class_addMethod 來爲類增長一個新的方法，也正由於這樣，class_replaceMethod 在調用時須要傳入 type 參數，而 method_exchangeImplementations 和 method_setImplementation 都不須要
• method_exchangeImplementations 內部實現是獲取到兩個方法的實現，而後進行互換

文檔以下圖：

使用場景：

• class_replaceMethod 當須要替換的方法有可能不存在時，能夠考慮使用該方法。
• method_exchangeImplementations 當須要交換兩個方法的實現時使用。
• method_setImplementation 是最簡單的用法，當僅僅須要爲一個方法設置其實現方式時使用。

二、Tagged Pointer 對象

2.1 原有系統的問題

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

• 問題一：內存翻倍。
  在iOS數據類型中，不少數據類型所佔內存都是根據CPU的位數決定的。那麼，當程序從32位程序過渡到64位時，這些數據類型的內存就會翻倍。以下圖所示：
  
• 問題二：效率問題。
  爲了存儲和訪問一個NSNumber對象，咱們須要在堆上爲其分配內存，另外還要維護它的引用計數，管理它的生命週期。這些都給程序增長了額外的邏輯，形成運行效率上的損失，

2.2 Tagged Pointer 介紹

Tagged Pointer就是爲了解決上述問題提出的。
原理：將一個對象指針拆分爲兩部分。以下圖：

引入後，內存變化以下圖：

特色：

1. 專門用來存儲小的對象，例如 NSNumber 和 NSDate
2. 指針的值再也不是地址了，而是真正的值。因此，實際上它再也不是一個對象了，它只是一個披着對象’皮‘的普通變量而已。因此，它的內存並不存儲在堆中，也不須要 malloc 和 free
3. 在內存讀取上有着之前3倍的效率，建立時比以前快106倍

注：Tagged Pointer 並非真正的對象，而是一個僞對象，沒有 isa 指針

2.2 64位下 isa 指針優化

32位環境：

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

Retain 操做包含以下的5個步驟：

1. 獲取全局的記錄引用計數的 hash 表。
2. 爲了線程安全，給該 hash 表加鎖。
3. 查找到目標對象的引用計數值。
4. 將該引用計數值加1，寫回 hash 表。
5. 給該 hash 表解鎖。

爲了線程安全，須要對 hash 表進行加鎖，從性能上看是很是差的。

64位環境：

isa指針是64位。每一個bit位含義以下圖:

bit位	變量名	意義
1 bit	indexed	0 表示普通的isa，1 表示 Tagged Pointer
1 bit	has_assoc	表示對象是否有過 associated 對象，若是沒有，在析構釋放內存時能夠更快
1 bit	has_cxx_dtor	表示該對象是否有 C++ 或 ARC 的析構函數，若是沒有，在析構釋放內存時能夠更快
30 bit	shiftcls	類的指針
9 bit	magic	其值固定爲 0xd2，用於在調試時分辨對象是否未完成初始化
1 bit	weakly_referenced	表示該對象是否有過 weak 對象，若是沒有，在析構釋放內存時能夠更快
1 bit	deallocating	表示該對象是否正在析構
1 bit	has_sidetable_rc	表示該對象的引用計數值是否大到沒法直接在 isa 中保存
19 bit	extra_rc	表示該對象超過 1 的引用計數值，例如，若是該對象的引用計數是6，則 extra_rc 的值爲5

extra_rc 的19位 bit 用來保存對象的引用計數，這樣對引用計數的操做只須要修改這個職責便可。

Retain 操做包含以下的5個步驟：

1. 檢查 isa 指針上面的標記位，看引用計數是否保存在 isa 變量中，若是不是，則使用之前的步驟，不然執行第2步。
2. 檢查當前對象是否正在釋放，若是是，則不作任何事情。
3. 增長該對象的引用計數，可是並不立刻寫回到 isa 變量中。
4. 檢查增長後的引用計數的值是否可以被19位表示，若是不是，則切換爲之前的辦法，不然執行第5步。
5. 進行一個原子的寫操做，將 isa 的值寫回。

三、block 對象模型

3.1 定義：

在蘋果的 llvm 項目的開源代碼(https://llvm.org/svn/llvm-project/compiler-rt/tags/Apple/Libcompiler_rt-10/BlocksRuntime/Block_private.h)中，咱們能夠看到 block 的數據結構定義，以下圖：

對應的結構體定義以下：

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 指針，全部對象都有該指針，用於實現對象的相關的功能。
2. flags 用於按 bit 位表示一些 block 的附加信息，在後面介紹的 block copy 的實現代碼中能夠看到該變量的使用。
3. reserved 保留變量。
4. invoke 函數指針，指向具體的 block 實現的函數調用地址。
5. descriptor 表示該 block 的附加描述信息，主要是 size 的大小，以及 copy 和 dispose 函數的指針。
6. variable capture 過來的變量，block 可以訪問它外部的局部變量，就是由於將這些變量（或變量的地址）複製到告終構體中。

3.2 分類：

block 的類型：

1. _NSConcreteGlobalBlock 全局的靜態 block，不會訪問任何外部變量。
2. _NSConcreteStackBlock 保存在棧中的 block，當函數返回時會被銷燬。
3. _NSConcreteMallocBlock 保存在堆中的 block，當引用計數爲 0 時會被銷燬。

注：用 clang 分析 block 實現

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

3.2.1 NSConcreteGlobalBlock 類型的 block 的實現

建立一個名字爲 block1.c 的源文件，文件實現：

#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語言中的實現。
關鍵代碼引用以下：

...
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 的實現，從中咱們能夠看出：

1. 一個 block 實際是一個對象，它主要由一個 isa、一個 impl 和一個 descriptor 組成。
2. 因爲這裏沒有開啓 ARC，因此咱們看到 isa 的指向仍是 _NSConcreteStackBlock。但在開啓 ARC 時，block 應該是 _NSConcreteGlobalBlock 類。
3. impl 是實際函數指針，本例中，它指向 __main_block_func_0。這裏的 impl 至關於以前提到的 invoke 變量，只是 clang 編譯器對變量的命名不同而已。
4. descriptor 是用於描述當前這個 block 的附加信息的，包括結構體的大小，須要 capture 和 dispose 的變量列表等。
   結構體大小須要保存到緣由是，每一個 block 會 capture 一些變量，這裏變量會加到 __main_block_impl_0 這個結構體中，使其體積變大。

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

3.2.2 NSConcreteStackBlock 類型的 block 的實現

建立一個名字爲 block1.c 的源文件，文件實現：

#include <stdio.h>

int main(int argc, char const *argv[]) {
    int a = 100;
    void (^block2)(void) = ^{ // block 實現
        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 時，被複制到 __main_block_impl_0 結構體中的那個變量 a。
3. __main_block_impl_0 中因爲增長一個變量 a，因此結構體變大了，該結構體大小被寫在了 __main_block_desc_0 中。

咱們修改上面的源碼，在變量前面增長 __block 關鍵字：

#include <stdio.h>

int main(int argc, char const *argv[]) {
    __block int i = 1024;
    void (^block2)(void) = ^{ // block 實現
        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 的結構體，用於保存咱們要 capture 而且修改的變量 i。
2. __main_block_impl_0 中引用的是 __Block_byref_i_0 的結構體指針，這樣就能夠起到修改外部變量的做用。
3. __Block_byref_i_0 的結構體帶有 isa，說明它也是一個對象。
4. 咱們須要負責 __Block_byref_i_0 結構體相關的內存管理，全部 __main_block_desc_0 中增長了 copy 和 dispose 函數指針，用於在調用先後修改相應變量的引用計數。

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

總結：
block 對於外部變量的使用，非 __block 修飾的變量，直接將其複製到 block 數據結構中來實現訪問；__block 修飾的變量，複製這個變量的引用地址來實現訪問的。

3.2.3 NSConcreteMallocBlock 類型的 block 的實現

NSConcreteMallocBlock 類型的 block 一般不會在源碼中直接出現，只有當一個 block 被調用其 copy 方法的時候，系統纔會將這個 block 複製到堆中，從而產生 NSConcreteMallocBlock 類型的 block。

注：在 ARC 開啓的狀況下，將只會存在 NSConcreteGlobalBlock 和 NSConcreteMallocBlock 類型的 block。原來的 NSConcreteStackBlock 會被 NSConcreteMallocBlock 的進行替代。