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

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

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指標指向流程圖如下：

如果把類看成一個C語言的結構體(struct)，isa指標就是這個結構體的第一個成員變數，類的其他成員變數依次排列在結構體中

排列順序：

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

@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 是最簡單的用法，當僅僅需要為一個方法設定其實作方式時使用，

2、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位含義如下圖:

extra_rc 的19位 bit 用來保存物件的參考計數，這樣對參考計數的操作只需要修改這個職責即可，

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

1. 檢查 isa 指標上面的標記位，看參考計數是否保存在 isa 變數中，如果不是，則使用以前的步驟，否則執行第2步，
2. 檢查當前物件是否正在釋放，如果是，則不做任何事情，
3. 增加該物件的參考計數，但是并不馬上寫回到 isa 變數中，
4. 檢查增加后的參考計數的值是否能夠被19位表示，如果不是，則切換為以前的辦法，否則執行第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 的資料結構定義，如下圖：

對應的結構體定義如下：

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 = https://www.cnblogs.com/gfxxbk/p/{ 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 = https://www.cnblogs.com/gfxxbk/p/{ 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 = https://www.cnblogs.com/gfxxbk/p/{ 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 的進行替代，

標籤：iOS

上一篇：蘋果審核ipv6海外解決思路-About APP Store

下一篇：imageRectForContentRect,titleRectForContentRect,contentRectForBounds,imageRectForContentRect什么時候呼叫