1. 程式人生 > >【原】iOS開發進階(唐巧)讀書筆記(二)

【原】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指標就是這個結構體的第一個成員變數,類的其他成員變數依次排列在結構體中

排列順序:
| 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_exchangeImplementationsmethod_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. 專門用來儲存小的物件,例如 NSNumberNSDate
  2. 指標的值不再是地址了,而是真正的值。所以,實際上它不再是一個物件了,它只是一個披著物件’皮‘的普通變數而已。所以,它的記憶體並不儲存在堆中,也不需要 mallocfree
  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 的值寫回。

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 = { 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 的附加資訊的,包括結構體的大小,需要 capturedispose 的變數列表等。
    結構體大小需要儲存到原因是,每個 blockcapture 一些變數,這裡變數會加到 __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 中增加了 copydispose 函式指標,用於在呼叫前後修改相應變數的引用計數。

具體檔案見: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 開啟的情況下,將只會存在 NSConcreteGlobalBlockNSConcreteMallocBlock 型別的 block。原來的 NSConcreteStackBlock 會被 NSConcreteMallocBlock 的進行替代