#iOS底層原理 - Block本質探究
本質
block 本質是一個OC物件，也存在 isa 指標。或者說Block 是封裝了函式呼叫和函式呼叫環境的OC物件。
1.底層實現
編寫一段最簡單的OC程式碼頂一個block，程式碼如：
int main(int argc, const char * argv[]) {
@autoreleasepool {
int abc = 10086;
void(^block)(int number) = ^(int number) {
NSLog(@"%d",number);
};
}
return 0;
}
複製程式碼使用 xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m 命令將其OC程式碼轉化為底層的C++程式碼，觀察block的底層結構。
我們開啟編譯生成的main.cpp程式碼，會發現上述程式碼被轉化為如下：
int main(int argc, const char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
int abc = 10086;
void(*block)(int number) = ((void (*)(int))&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
}
return 0;
}
複製程式碼block 程式碼塊被定義為 __main_block_impl_0 結構體。
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;
}
};
複製程式碼結構體中包含兩個不同的結構體變數 __block_impl 和 __main_block_desc_0
__block_impl
struct __block_impl {
void *isa;
int Flags;
int Reserved;
void *FuncPtr;
};
複製程式碼包含isa指標說明，block本質上也是一個OC物件，FuncPtr 指向block所封裝的程式碼塊地址，等執行block時會通過FuncPtr尋找將要執行的程式碼塊，並且呼叫。
__main_block_desc_0
static struct __main_block_desc_0 {
size_t reserved;
size_t Block_size;
}
複製程式碼其中： Block_size 為當前block 佔用記憶體大小。
__main_block_func_0
block 封裝的程式碼塊被定義為 __main_block_func_0 結構體
static void __main_block_func_0(struct __main_block_impl_0 *__cself, int number) {
NSLog((NSString *)&__NSConstantStringImpl__var_folders_gf_ct0sq2w17s16j4b1pz5_zx500000gn_T_main_68909d_mi_0,number);
}
複製程式碼2. Block 變數捕獲
auto 變數
如果我們將main函式改為：
int main(int argc, const char * argv[]) {
@autoreleasepool {
int abc = 10086;
void(^block)() = ^() {
NSLog(@"%d",abc);
};
abc = 10010;
block();
}
return 0;
}
複製程式碼在block內部引用外部變數，我們再看看內部組成結構。同樣執行 xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m 命令。
我們可以看到，較之前，__main_block_impl_0 結構體新增一個 int 型別變數abc，用於儲存所引用的外部變數的值。因為是值儲存，所以在block生成之後，無論外部變數做何更改，abc依然是之前所定義的值。
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
int abc;
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _abc, int flags=0) : abc(_abc) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
}
複製程式碼static 變數
因為我們所定義的外部變數 abc 之前沒有任何修飾符，也就是預設的auto變數，此時block是值捕獲。如果將外部變數宣告為 static 型別再觀察底層實現。
int main(int argc, const char * argv[]) {
@autoreleasepool {
int abc = 10086;
static int def = 100;
void(^block)(void) = ^() {
NSLog(@"abc: %d - def: %d",abc,def);
};
abc = 10010;
def = 200;
block();
}
return 0;
}
複製程式碼轉化為c++底層實現為：
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
int abc;
int *def;
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _abc, int *_def, int flags=0) : abc(_abc), def(_def) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
複製程式碼使用static 修飾的變數在block內部為指標傳遞，block直接捕獲外部變數的記憶體地址，此時若外部變數在block宣告之後修改，block內部也會同步進行修改。
全域性 變數
如果使用全域性變數，block不會捕獲。因為宣告全域性變數的型別會在程式的整個宣告週期都不會被釋放，所以在使用block時，直接會去訪問全域性變數的值。所以捕獲就沒有意義了，感興趣的可以自行檢視底層實現。
3. Block 的型別
當我們宣告一個block 並且列印他的繼承鏈我們可以看到：
void(^block)(void) = ^() {
NSLog(@"abc");
};
NSLog(@"%@",[block class]);
NSLog(@"%@",[[block class] superclass]);
NSLog(@"%@",[[[block class] superclass] superclass]);
NSLog(@"%@",[[[[block class] superclass] superclass] superclass]);
複製程式碼輸出：
2018-06-28 10:37:23.901162+0800 BlockDemo[17574:719984] __NSGlobalBlock__
2018-06-28 10:37:23.901504+0800 BlockDemo[17574:719984] __NSGlobalBlock
2018-06-28 10:37:23.901522+0800 BlockDemo[17574:719984] NSBlock
2018-06-28 10:37:23.901535+0800 BlockDemo[17574:719984] NSObject
Program ended with exit code: 0
複製程式碼故我們可得出結論block的繼承關係為：NSGlobalBlock ： __NSGlobalBlock ： NSBlock : NSObject
從而也進一步證明了block 本質上為 OC物件。並且，在不引用外部變數的情況下，block為 NSGlobalBlock 型別。
我們定義三個不同的block，分別列印他們的實際型別：
int main(int argc, const char * argv[]) {
@autoreleasepool {
void(^block1)(void) = ^() {
NSLog(@"abc");
};
NSLog(@"%@",[block1 class]);
int abc = 1;
void(^block2)(void) = ^() {
NSLog(@"abc: %d",abc);
};
NSLog(@"%@",[block2 class]);
NSLog( @"%@", [^(){
NSLog(@"hello %d",abc);
} class]);
}
return 0;
}
複製程式碼輸出：
2018-06-28 10:48:32.096859+0800 BlockDemo[17719:728991] __NSGlobalBlock__
2018-06-28 10:48:32.097224+0800 BlockDemo[17719:728991] __NSMallocBlock__
2018-06-28 10:48:32.097243+0800 BlockDemo[17719:728991] __NSStackBlock__
複製程式碼我們可以得出結論，
block 型別分三種：分別為 __NSGlobalBlock__ __NSMallocBlock__ __NSStackBlock__
他們在記憶體中位置分別：
那他們是如何區分的呢？可以使用如下表格來說明:
| Block 型別 | 條件 |
|---|---|
| NSGlobalBlock | block 內部沒有訪問auto變數 |
| NSStackBlock | block 內部訪問了 auto變數 |
| NSMallocBlock | NSStackBlock 呼叫了copy |
NSStackBlock 執行 copy 後會將棧區的block 複製到堆區，便於程式設計師管理，那其他型別的block執行 copy 會有什麼變化呢？如下表所示：
| Block 型別 | 儲存域 | 執行 copy 後效果 |
|---|---|---|
| NSGlobalBlock | 程式的資料區域 | 無任何改變 |
| NSStackBlock | 棧 | 從棧複製到堆 |
| NSMallocBlock | 堆 | 引用計數器加1 |
4. ARC 下某些情況下系統會對 Block 自動執行一次 copy 操作，將 Block 從棧區轉移到堆區
1.當 block 作為函式返回值時
typedef void(^MyBlock)(void);
MyBlock testFunc() {
int a = 10;
MyBlock myBlock = ^ {
NSLog(@"test --- %d",a);
};
return myBlock;
}
int main(int argc, const char * argv[]) {
@autoreleasepool {
MyBlock myB = testFunc();
NSLog(@"%@",[myB class]);
}
return 0;
}
複製程式碼如果此程式碼在MRC 環境下，會崩潰。Block訪問的變數已被釋放。 如果在ARC環境下，在引數的返回值為block時，系統會對block自動執行一次 copy 操作，使其變為 NSMallocBlock 型別。
2.當Block 被強指標引用時會自動執行copy操作
int main(int argc, const char * argv[]) {
@autoreleasepool {
int abc = 10;
MyBlock myB = ^ {
NSLog(@"+++ %d",abc);
};
NSLog(@"%@",[myB class]);
}
return 0;
}
複製程式碼如上程式碼，在MRC環境輸出：__NSStackBlock__ 。在 ARC環境輸出：__NSMallocBlock__
3.當 Block 做為cocoa API 或 GCD API 的方法引數時也會自動執行 copy 操作
例如：
NSArray *array = @[@1];
[array enumerateObjectsUsingBlock:^(id _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {
}];
複製程式碼 static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
});
複製程式碼所以在 MAC 環境下的block屬性必須使用 copy 修飾，而ARC環境下的block屬性即可使用 strong 修飾，也可以使用 copy 修飾，兩者都會對block自動執行copy操作，故無任何區別。
5.Block 內部引用物件
觀察如下程式碼
int main(int argc, const char * argv[]) {
@autoreleasepool {
{
XWPerson *person = [[XWPerson alloc] init];
person.age = 10;
^{
NSLog(@"person -- %ld",(long)person.age);
}();
}
NSLog(@"*******");
}
return 0;
}
複製程式碼會發現當 函式體內 大括號執行完畢後 XWPerson 即被釋放，此時的block 是 棧型別的Block 即 __NSStackBlock__. 儲存在棧區的block即便引用了物件，也會跟隨大括號一併釋放。
如果將以上程式碼改為：
int main(int argc, const char * argv[]) {
@autoreleasepool {
MyBlock myBlock;
{
XWPerson *person = [[XWPerson alloc] init];
person.age = 10;
myBlock = ^{
NSLog(@"person -- %ld",(long)person.age);
};
myBlock();
}
NSLog(@"*******");
}
return 0;
}
複製程式碼我們會發現在執行到 **** 時，person 物件依然沒有被釋放，此時block 已經對 person 物件進行了強引用。因為 此時 的block 為強指標引用，型別為 堆block __NSMallocBlock__.
為什麼堆 block 會對外部物件強引用呢？
此時 使用 xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc -fobjc-arc -fobjc-runtime=ios-8.0.0 main.m 命令 觀察其底層 c++ 實現：
此時block 定義為：
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
XWPerson *__strong person;
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, XWPerson *__strong _person, int flags=0) : person(_person) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
複製程式碼其中 main_block_desc_0 定義為：
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*);
}
複製程式碼較之前block引用基本成員型別時，其 main_block_desc_0 多了兩個引數分別為 copy 和 dispose。並且傳入的都是 __main_block_impl_0 block 本身。
當 block 執行 copy 操作的時候，執行的是
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->person, (void*)src->person, 3/*BLOCK_FIELD_IS_OBJECT*/);}
複製程式碼方法。最終呼叫的 _Block_object_assign 方法會對block引入的物件 person 進行引用計數操作，當所引入的物件使用 strong 修飾則使其引用計數加1，若使用weak修飾則引用計數不變。
當 block 執行完畢的時候會呼叫 dispose 方法，而dispose 在底層會呼叫
static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->person, 3/*BLOCK_FIELD_IS_OBJECT*/);}
複製程式碼方法，將block內部引用的物件成員引用計數減1，如果此時外部物件使用strong 修飾，引用計數在copy加1後 此時再減1.依然會強引用外部物件，不會釋放，如果使用weak修飾，此時因為自身以及被釋放，所以不會再持有所引用外部物件，然而此時所引用外部物件是否會被釋放取決於它的引用計數是否為 0。
6. block 內部修改外部變數的值。
我們知道，如果block 內部捕獲的外部變數為 auto 型別，在block 內部生成的是該變數的值型別變數，無法通過block內部的值修改外部變數。 如果想在block內部修改外部變數的值有幾種方法？
1.外部變數使用 static 修飾
使用 static 修飾的變數block內部會直接獲取到變數的記憶體地址，可以直接修改。
2.使用 __block
若使用 static 變數修飾，該變數的生命週期就會無限延長，這不符合我們的設計思路，故我們可以使用 __block 來修飾外部變數，從而達到在block內部修改外部成員變數的目的。
那 __block 是如何實現此需求的呢？
int main(int argc, const char * argv[]) {
@autoreleasepool {
__block int a = 10;
MyBlock block = ^{
a = 20;
NSLog(@"a --- %d",a);
};
block();
}
return 0;
}
複製程式碼使用 xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc -fobjc-arc -fobjc-runtime=ios-8.0.0 main.m 命令將其轉化為c++ 實現：
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
__Block_byref_a_0 *a; // by ref
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_a_0 *_a, int flags=0) : a(_a->__forwarding) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
複製程式碼我們可知 通過 __block 修飾的外部成員變數被定義為 __Block_byref_a_0 物件！它的宣告為：
struct __Block_byref_a_0 {
void *__isa;
__Block_byref_a_0 *__forwarding;
int __flags;
int __size;
int a;
};
複製程式碼此時在main函式內宣告 __block 型別的變數會以此方式初始化：
__attribute__((__blocks__(byref))) __Block_byref_a_0 a = {(void*)0,(__Block_byref_a_0 *)&a, 0, sizeof(__Block_byref_a_0), 10};
複製程式碼其中 __forwarding 儲存的原變數 a 的記憶體地址，size 為當前變數的記憶體大小，10 儲存未原變數的值。
如此，我們在block 內部修改 原變數時：
(a->__forwarding->a) = 20;
複製程式碼直接取原變數的地址進行更改，從而實現在block內部更改外部變數。
7. __block 和 物件型別的auto變數 的記憶體管理
對於block內部捕獲的物件型別的auto變數和__block修飾的變數。如果block在棧區，不會對他們進行記憶體管理，即不會強引用外部變數
如果block被複制到堆區，則會呼叫內部 copy 函式對外部 __block 修飾的變數和物件型別的auto變數進行記憶體管理。
當block從記憶體中移除時，同樣也會呼叫dispose函式對所引用的外部變數進行釋放。
8. 迴圈引用
使用 block 很容易形成迴圈引用，如果一個類中定義的block內部引用了該類的外部屬性，包括 類本身的 self， 均會導致 self 強引用 block，block 也強引用 self。導致self不會被釋放。如下程式碼就會造成迴圈引用：
.h
#import <Foundation/Foundation.h>
@interface XWPerson : NSObject
@property (nonatomic, assign) NSInteger age;
@property (nonatomic, copy) void(^personBlock)(void);
@end
複製程式碼.m
#import "XWPerson.h"
@implementation XWPerson
- (void)test {
self.personBlock = ^{
NSLog(@"%d",self.age); //此處若即便使用 _age 也會產生迴圈引用。
};
}
- (void)dealloc {
NSLog(@" XWPerson -- dealloc -- age:%ld",(long)_age);
}
@end
複製程式碼產生迴圈引用的本質原因是，在block內部實現裡，會將self 捕獲到block內部，並且strong 強引用。如下程式碼所示：
struct __XWPerson__test_block_impl_0 {
struct __block_impl impl;
struct __XWPerson__test_block_desc_0* Desc;
XWPerson *const __strong self;
__XWPerson__test_block_impl_0(void *fp, struct __XWPerson__test_block_desc_0 *desc, XWPerson *const __strong _self, int flags=0) : self(_self) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
複製程式碼9. 避免產生迴圈引用
1. (ARC 環境下) __weak ： 弱引用物件，指向的物件銷燬時，會自動將指標置為nil。因此一般通過__weak來解決問題。
int main(int argc, const char * argv[]) {
@autoreleasepool {
XWPerson *person1 = [[XWPerson alloc] init];
person1.age = 18;
__weak typeof(person1) weakPerson = person1;
person1.personBlock = ^{
NSLog(@"%ld",(long)weakPerson.age);
};
person1.personBlock();
}
return 0;
}
複製程式碼2. (ARC / MRC 環境下) __unsafe_unretained ： 弱引用物件，指向的物件銷燬時，不會自動將指標置為nil。再次引用該物件時可能會產生訪問殭屍物件的錯誤，產生崩潰，故不建議使用！
__unsafe_unretained XWPerson *person1 = [[XWPerson alloc] init];
3. (ARC / MRC 環境下) __block : 使用__block 修飾物件. 在ARC環境下-前提是一定要呼叫此block，並且要在block內部將所引用的外部變數手動置nil。因為 MRC 環境下，引用__block 修飾的物件不會使其引用計數加1，所以不需要手動置nil，也不是必需要使用block。
int main(int argc, const char * argv[]) {
@autoreleasepool {
__block XWPerson *person1 = [[XWPerson alloc] init];
person1.age = 18;
person1.personBlock = ^{
NSLog(@"%ld",(long)person1.age);
person1 = nil;
};
person1.personBlock();
}
return 0;
}
複製程式碼