【原】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]));
}
程式碼關鍵點:
import runtime
相關的標頭檔案:objc/runtime.h
。- 使用
objc_allocateClassPair
方法建立新的類。 - 使用
class_addMethod
方法來給類增加新的方法。 - 使用
objc_registerClassPair
方法來註冊新的類。 - 使用
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就是為了解決上述問題提出的。
原理:將一個物件指標拆分為兩部分。如下圖:
引入後,記憶體變化如下圖:
特點:
- 專門用來儲存小的物件,例如
NSNumber
和NSDate
- 指標的值不再是地址了,而是真正的值。所以,實際上它不再是一個物件了,它只是一個披著物件’皮‘的普通變數而已。所以,它的記憶體並不儲存在堆中,也不需要
malloc
和free
- 在記憶體讀取上有著以前3倍的效率,建立時比之前快106倍
注:Tagged Pointer
並不是真正的物件,而是一個偽物件,沒有 isa
指標
2.2 64位下 isa 指標優化
32位環境:
物件的引用計數都儲存在一個外部表中。
Retain
操作包含如下的5個步驟:
- 獲取全域性的記錄引用計數的
hash
表。 - 為了執行緒安全,給該
hash
表加鎖。 - 查詢到目標物件的引用計數值。
- 將該引用計數值加1,寫回
hash
表。 - 給該
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個步驟:
- 檢查 isa 指標上面的標記位,看引用計數是否儲存在 isa 變數中,如果不是,則使用以前的步驟,否則執行第2步。
- 檢查當前物件是否正在釋放,如果是,則不做任何事情。
- 增加該物件的引用計數,但是並不馬上寫回到 isa 變數中。
- 檢查增加後的引用計數的值是否能夠被19位表示,如果不是,則切換為以前的辦法,否則執行第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個部分:
isa
指標,所有物件都有該指標,用於實現物件的相關的功能。flags
用於按bit
位表示一些block
的附加資訊,在後面介紹的block copy
的實現程式碼中可以看到該變數的使用。reserved
保留變數。invoke
函式指標,指向具體的block
實現的函式呼叫地址。descriptor
表示該block
的附加描述資訊,主要是size
的大小,以及copy
和 dispose 函式的指標。variable
capture
過來的變數,block 能夠訪問它外部的區域性變數,就是因為將這些變數(或變數的地址)複製到了結構體中。
3.2 分類:
block
的型別:
_NSConcreteGlobalBlock
全域性的靜態block
,不會訪問任何外部變數。_NSConcreteStackBlock
儲存在棧中的block
,當函式返回時會被銷燬。_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 的實現,從中我們可以看出:
- 一個
block
實際是一個物件,它主要由一個isa
、一個impl
和一個descriptor
組成。 - 由於這裡沒有開啟
ARC
,所以我們看到isa
的指向還是_NSConcreteStackBlock
。但在開啟ARC
時,block
應該是_NSConcreteGlobalBlock
類。 impl
是實際函式指標,本例中,它指向__main_block_func_0
。這裡的impl
相當於之前提到的invoke
變數,只是clang
編譯器對變數的命名不一樣而已。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;
}
在本例中,我們可以看到:
- 本例中,
isa
指向_NSConcreteStackBlock
,說明這是一個分配在棧上的例項。 __main_block_impl_0
中增加一個變數a
,在block
中引用的變數a
,實際是在宣告block
時,被複制到__main_block_impl_0
結構體中的那個變數a
。__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;
}
從程式碼中我們可以看到:
- 原始碼中增加了一個名為
__Block_byref_i_0
的結構體,用於儲存我們要capture
並且修改的變數i
。 __main_block_impl_0
中引用的是__Block_byref_i_0
的結構體指標,這樣就可以起到修改外部變數的作用。__Block_byref_i_0
的結構體帶有isa
,說明它也是一個物件。- 我們需要負責
__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。