block的本質
1.block的基本用法
// 不帶引數無回傳值的block
void (^block)(void) = ^{
NSLog(@"Hello, World!");
};
block();
// 帶引數無回傳值的block
void (^block)(int, int) = ^(int a , int b)
NSLog(@"this is a block!");
};
block(10, 20);
2.將block代碼轉換成C++檔案后發現，生成了一個__main_block_impl_0型別的結構體，block是指向這個結構體的指標
int age = 20;
void (^block)(int, int) = ^(int a , int b){
NSLog(@"this is a block! -- %d", age);
NSLog(@"this is a block!");
NSLog(@"this is a block!");
NSLog(@"this is a block!");
};
block(10, 10);
// 轉換后的C++代碼
int main(int argc, const char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
int age = 10;
// 定義block變數
// block = &__main_block_impl_0（__main_block_func_0, &__main_block_desc_0_DATA, age）
void (*block)(int, int) = ((void (*)(int, int))&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, age));
// 執行block內部代碼
// __main_block_impl_0可以直接轉換為__block_impl型別，是因為兩個型別的結構體地址是一樣的，而且相當于直接把__block_impl里的值都放到__main_block_impl_0里
// (block->FuncPtr)(block, 10, 10)
((void (*)(__block_impl *, int, int))((__block_impl *)block)->FuncPtr)((__block_impl *)block, 10, 10);
}
return 0;
}
3.__main_block_impl_0型別的結構體，里面包含了__block_impl型別的結構體變數impl和__main_block_desc_0型別的結構體變數Desc，一個回傳值為__main_block_impl_0型別的建構式，還會生成一個age來存盤外面參考的值
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
int age;
// 建構式（類似oc的init）
// __main_block_func_0的地址傳給fp
// : age(_age)語法會自動將_ag賦值給age
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _age, int flags=0) : age(_age) {
impl.isa = &_NSConcreteStackBlock; // isa指向的_NSConcreteStackBlock就是當前block型別
impl.Flags = flags;
impl.FuncPtr = fp; // 保存的就是__main_block_func_0的地址，也就是block執行邏輯的函式
Desc = desc; // 保存的是&__main_block_desc_0_DATA的地址（主要存盤的就是__main_block_impl_0的大小）
// 默認回傳的就是__main_block_impl_0結構體
}
};
4.__block_impl型別的結構體里包含isa指標，說明block也是一個OC物件，在__main_block_impl_0的建構式中isa指向的是_NSConcreteStackBlock型別的地址，側面說明這個型別也是當前編譯時的block的真實型別
struct __block_impl {
void *isa;
int Flags;
int Reserved;
void *FuncPtr;
};
5.__main_block_func_0是一個封裝了block執行邏輯代碼的函式，在__main_block_impl_0的建構式中通過引數void *fp賦值給FuncPtr指標變數，來保存執行代碼的地址
// 封裝了block執行邏輯的函式
static void __main_block_func_0(struct __main_block_impl_0 *__cself, int a, int b) {
int age = __cself->age; // bound by copy
NSLog((NSString *)&__NSConstantStringImpl__var_folders_2r__m13fp2x2n9dvlr8d68yry500000gn_T_main_3f4c4a_mi_0, age);
NSLog((NSString *)&__NSConstantStringImpl__var_folders_2r__m13fp2x2n9dvlr8d68yry500000gn_T_main_3f4c4a_mi_1);
NSLog((NSString *)&__NSConstantStringImpl__var_folders_2r__m13fp2x2n9dvlr8d68yry500000gn_T_main_3f4c4a_mi_2);
NSLog((NSString *)&__NSConstantStringImpl__var_folders_2r__m13fp2x2n9dvlr8d68yry500000gn_T_main_3f4c4a_mi_3);
}
6.__main_block_desc_0這個型別的結構體變數__main_block_desc_0_DATA里面的reserved賦值為0，Block_size賦值為sizeof(struct __main_block_impl_0)，也就是當前__main_block_impl_0這個結構體的大小，在__main_block_impl_0的建構式中通過引數desc賦值給Desc
static struct __main_block_desc_0 {
size_t reserved; // 0
size_t Block_size; // 計算的就是__main_block_impl_0這個結構體的大小
} __main_block_desc_0_DATA = https://www.cnblogs.com/funkyRay/p/{ 0, sizeof(struct __main_block_impl_0)};
7.__main_block_impl_0的建構式中 : age(_age)語法會自動將_age賦值給變數int age來保存，而且轉換后的呼叫__main_block_impl_0可以直接轉換為__block_impl型別，是因為兩個型別的結構體地址是一樣的，而且相當于直接把__block_impl里的值都放到__main_block_impl_0里
總結
block本質上也是一個OC物件，它內部也有個isa指標block是封裝了函式呼叫以及函式呼叫環境的OC物件
block的本質結構可以概括為下面這張圖
block的變數捕獲
為了保證block內部能夠正常訪問外部的變數，block有個變數捕獲機制
- 區域變數默認是被
auto修飾的，表示自動變數，離開作用域就銷毀，block的捕獲該變數是值傳遞 - 區域變數被
static修飾，會一直在記憶體中不被釋放，block的捕獲該變數是指標傳遞 - 全域變數因為是一直都在記憶體中存在的，所以不用捕獲
block的型別
block有3種型別，可以通過呼叫class方法或者isa指標查看具體型別，最終都是繼承自NSBlock型別__NSGlobalBlock__ （ _NSConcreteGlobalBlock ）-__NSStackBlock__ （ _NSConcreteStackBlock ）-__NSMallocBlock__ （ _NSConcreteMallocBlock）
block的真實型別都是以運行時為準的，通過Clang編譯出的C++型別不是最準確的，因為在運行時又會做了一些變動和處理，而且現在LLVM只會生成一種中間檔案，和Clang生成的檔案有差異
通過下面代碼觀察block的對應輸出
int main(int argc, const char * argv[]) {
@autoreleasepool {
void (^block)(void) = ^{
NSLog(@"Hello");
};
NSLog(@"%@", [block class]);
NSLog(@"%@", [[block class] superclass]);
NSLog(@"%@", [[[block class] superclass] superclass]);
}
return 0;
}
// 對應的輸出：__NSGlobalBlock__ NSBlock NSObject
不同記憶體區域對應的block型別不同
- 資料段對應的是
__NSGlobalBlock__型別的block - 堆段對應的是
__NSMallocBlock__型別的block - 堆疊段對應的是
__NSStackBlock__型別的block
不同操作對應的block型別不同
- 沒有訪問自動變數的block的型別是
__NSGlobalBlock__ - 訪問了自動變數的block的型別是
__NSStackBlock__ __NSStackBlock__的block呼叫了copy后型別會變為__NSMallocBlock__
每一種型別的block呼叫copy后的結果如下所示
修改Xcode的Build Setting->Objective-C Automatic Reference Counting為No，使編譯環境為MRC，然后輸出下面代碼可以查看block對應的型別
int main(int argc, const char * argv[]) {
@autoreleasepool {
int a = 10;
// 堆：動態分配記憶體,需要程式員申請申請，也需要程式員自己管理記憶體
void (^block1)(void) = ^{
NSLog(@"Hello");
};
int age = 10;
void (^block2)(void) = ^{
NSLog(@"Hello - %d", age);
};
NSLog(@"%@ %@ %@", [block1 class], [[block2 copy] class], [^{
NSLog(@"%d", age);
} class]);
}
return 0;
}
// 對應的輸出：__NSGlobalBlock__ __NSMallocBlock__ __NSStackBlock__
注意：block2在MRC環境下的型別為__NSStackBlock__，是存盤在堆疊段的，只有通過copy修飾才會變成__NSMallocBlock__，存盤在堆中，在ARC環境下即使不用copy修飾型別也是__NSMallocBlock__，因為編譯器會視情況自動進行copy操作
block的copy操作
在ARC環境下，編譯器會根據情況自動將堆疊上的block復制到堆上
1.block作為函式回傳值時
如果不進行copy操作，myblock內部的block回傳值作用域一結束就會被釋放
typedef void (^Block)(void);
Block myblock()
{
int age = 10;
return ^{
NSLog(@"---------%d", age);
};
}
int main(int argc, const char * argv[]) {
@autoreleasepool {
Block block = myblock();
block();
NSLog(@"%@", [block class]); // __NSMallocBlock__
}
return 0;
}
2.將block賦值給__strong指標時
typedef void (^Block)(void);
int main(int argc, const char * argv[]) {
@autoreleasepool {
int age = 10;
// 強指標Block block
Block block = ^{
NSLog(@"---------%d", age);
};
NSLog(@"%@", [block class]); // __NSMallocBlock__
}
return 0;
}
3.block作為Cocoa API中方法名含有usingBlock的方法引數時
NSArray *array = @[];
[array enumerateObjectsUsingBlock:^(id _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {
}];
4.block作為GCD API的方法引數時
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
});
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
});
不同環境下block屬性的寫法
1.MRC下block屬性的建議寫法
@property (copy, nonatomic) void (^block)(void);
2.ARC下block屬性的建議寫法
// 因為編譯器會自動視情況進行copy操作，所以兩種寫法都沒問題，只是為了統一規范建議使用copy來修飾屬性@property (strong, nonatomic) void (^block)(void);@property (copy, nonatomic) void (^block)(void);
物件型別的auto變數
當block內部訪問了物件型別的auto變數時1.如果block是在堆疊上，將不會對auto變數產生強參考
@interface Person : NSObject
@property (assign, nonatomic) int age;
@end
@implementation Person
- (void)dealloc
{
[super dealloc];
NSLog(@"Person - dealloc");
}
@end
typedef void (^Block)(void);
int main(int argc, const char * argv[]) {
@autoreleasepool {
Block block;
{
Person *person = [[Person alloc] init];
person.age = 10;
block = ^{
NSLog(@"---------%d", person.age);
};
// MRC環境下對應的記憶體管理
[person release];
NSLog(@"------%@", [block class]);
}
// 在這里打斷點，由于MRC環境下block是在堆疊區間的，所以不會對age進行強參考，person會隨著作用域結束而釋放
NSLog(@"------");
}
return 0;
}
2.如果block被拷貝到堆上，會根據auto變數的修飾符（__strong、__weak、__unsafe_unretained）做出相應的操作
@interface Person : NSObject
@property (assign, nonatomic) int age;
@end
@implementation Person
- (void)dealloc
{
NSLog(@"Person - dealloc");
}
@end
typedef void (^Block)(void);
int main(int argc, const char * argv[]) {
@autoreleasepool {
Block block;
{
Person *person = [[Person alloc] init];
person.age = 10;
// __strong Person *weakPerson = person;
__weak Person *weakPerson = person;
block = ^{
NSLog(@"---------%d", weakPerson);
};
NSLog(@"------%@", [block class]);
}
// 在這里打斷點，在ARC環境下block會自動拷貝到堆區間，切換修飾符__strong和__weak，person分別會不釋放和釋放
NSLog(@"------");
}
return 0;
}
將上面代碼檔案轉換成C++檔案可以看出，block內部的__main_block_desc_0結構體會呼叫copy函式，copy函式內部會呼叫_Block_object_assign函式，而_Block_object_assign函式會根據auto變數的修飾符（__strong、__weak、__unsafe_unretained）做出相應的操作，形成強參考（retain）或者弱參考
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
Person *__strong person;
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, Person *__strong _person, int flags=0) : person(_person) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
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/funkyRay/p/{ 0, sizeof(struct __main_block_impl_0), __main_block_copy_0, __main_block_dispose_0};
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*/);}
3.如果block從堆上移除，會呼叫block內部的dispose函式，dispose函式內部會呼叫_Block_object_dispose函式，_Block_object_dispose函式會自動釋放參考的auto變數（release）
static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->person, 3/*BLOCK_FIELD_IS_OBJECT*/);}
4.block只有參考的是基本資料型別才不會生成copy和dispose函式
5.如果用static修飾物件型別，那么生成的C++代碼如下
Block block;
{
static NSString *string = @"haha";
block = ^{
NSLog(@"---------%@", string);
};
}
// 生成的C++代碼
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
// string變數的型別是NSString **
NSString *__strong *string;
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, NSString *__strong *_string, int flags=0) : string(_string) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
注意：代碼里有__weak，轉換C++檔案可能會報錯cannot create __weak reference in file using manual reference，可以指定支持ARC、指定運行時系統版本
xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc -fobjc-arc -fobjc-runtime=ios-8.0.0 源檔案
```### __block修飾符
#### __block修飾基本資料型別
看下面代碼，怎樣可以在`block`內部修改`age`的值
typedef void (^Block)(void);
int main(int argc, const char * argv[]) {
@autoreleasepool {
int age = 10;
Block block1 = ^{
// age = 20;
NSLog(@"age is %d", age);
};
block1();
NSLog(@"age的記憶體地址 - %p", &age);
}
return 0;
}
1.用`static`來修飾`age屬性`，`block`內部參考的是`age`的地址值，可以根據地址去修改`age`的值，但不好的是`age屬性`會一直存放在記憶體中不銷毀，造成多余的記憶體占用，而且會改變`age屬性`的性質，不再是一個`auto變數`了
static int age = 10;
2.用`__block`來修飾屬性，底層會生成`__Block_byref_age_0`型別的結構體物件，里面存盤著`age`的真實值
__block int age = 10;
3.轉換成`C++檔案`來查看內部結構，會根據`__main_block_impl_0`里生成的`age`物件來修改內部的成員變數`age`而且在外面列印的`age`屬性的地址值也是`__Block_byref_age_0`結構體里的成員變數`age`的地址，目的就是不需要知道內部的真實實作，所看到的就是列印出來的值
struct __Block_byref_age_0 {
void *__isa;
__Block_byref_age_0 *__forwarding; // 保存的自己的地址
int __flags;
int __size;
int age;
};
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
__Block_byref_age_0 *age; // by ref
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_age_0 *_age, int flags=0) : age(_age->__forwarding) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
int main(int argc, const char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
// __Block_byref_age_0 age = {0, &age, 0, sizeof(__Block_byref_age_0), 10};
__attribute__((__blocks__(byref))) __Block_byref_age_0 age = {(void*)0,(__Block_byref_age_0 *)&age, 0, sizeof(__Block_byref_age_0), 10};
Block block1 = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_age_0 *)&age, 570425344));
((void (*)(__block_impl *))((__block_impl *)block1)->FuncPtr)((__block_impl *)block1);
}
return 0;
}
##### 總結:
- `__block`可以用于解決`block`內部無法修改`auto`變數值的問題
- 編譯器會將`__block`變數包裝成一個物件
- 其實修改的變數是`__block`生成的物件里面存盤的變數的值，而不是外面的`auto變數`，但是內部生成的相同的變數的地址和外面的`auto變數`地址值是一樣的，所以修改了內部的變數也會修改了外面的`auto變數`
- `__block`不能修飾全域變數、靜態變數（static）
##### __block的記憶體管理
1.程式編譯時，`block`和`__block`都是在堆疊中的，這時并不會對`__block`變數產生強參考
2.因為`__block`也會包裝成`OC物件`，所以`block`底層也會生成`copy函式`和`dispose函式`
3.當`block`被`copy`到堆時，會呼叫`block`內部的`copy函式`，`copy函式`內部會呼叫`_Block_object_assign`函式，`_Block_object_assign`函式會對`__block`變數形成強參考（retain）
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/funkyRay/p/{ 0, sizeof(struct __main_block_impl_0), __main_block_copy_0, __main_block_dispose_0};
static void __main_block_copy_0(struct __main_block_impl_0dst, struct __main_block_impl_0src) {_Block_object_assign((void)&dst->age, (void)src->age, 8/BLOCK_FIELD_IS_BYREF/);}
實際上這時`__block`修飾的變數因為被包裝成了`OC物件`，所以也會被拷貝到堆上，如果再有`block`強參考`__block`，由于`__block`變數已經拷貝到堆上了，就不會再拷貝了，下圖可以很好的表達出關系
3.當`block`從堆中移除時，會呼叫`block`內部的`dispose函式`，`dispose函式`內部會呼叫`_Block_object_dispose`函式，`_Block_object_dispose`函式會自動釋放參考的`__block`變數（release）
static void __main_block_dispose_0(struct __main_block_impl_0src) {_Block_object_dispose((void)src->age, 8/BLOCK_FIELD_IS_BYREF/);}
如果有多個`block`同時持有著`__block`變數，那么只有所有的block都從堆中移除了，`__block`變數才會被釋放
##### __block和OC物件在block中的區別
看下面的代碼，在`block`中的本質區別是什么
__block int age = 10;
NSObject *obj = [[NSObject alloc] init];
Block block1 = ^{
age = 20;
NSLog(@"age is %d", age);
NSLog(@"obj is %p", obj);
};
轉成`C++檔案`發現，`__block`生成的物件就是強參考，而`NSObject`物件會根據修飾符`__strong`或者`__weak`來區分是否要進行`retain操作`
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
NSObject *__strong obj;
__Block_byref_age_0 *age; // by ref
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, NSObject *__strong _obj, __Block_byref_age_0 *_age, int flags=0) : obj(_obj), age(_age->__forwarding) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
static void __main_block_copy_0(struct __main_block_impl_0dst, struct __main_block_impl_0src) {_Block_object_assign((void)&dst->age, (void)src->age, 8/BLOCK_FIELD_IS_BYREF/);_Block_object_assign((void)&dst->obj, (void)src->obj, 3/BLOCK_FIELD_IS_OBJECT/);}
**注意：`__weak`不能修飾基本資料型別，編譯器會報`__weak' only applies to Objective-C object or block pointer types; type here is 'int'`警告**
##### __forwarding指標
- 在堆疊中，`__block`中的`__forwarding指標`指向自己的記憶體地址
- 復制到堆中之后，`__forwarding指標`指向堆中的`__block`
- 堆中的`__forwarding`指向堆中的`__block`
- 這樣的目的都是為了不論訪問的`__block`是在堆疊上還是在堆上，都可以通過`__forwarding指標`找到存盤在堆中的`auto變數`
#### __block修飾物件型別
1.看下面代碼，用`__block`修飾的物件型別什么時候被釋放
typedef void (^Block)(void);
int main(int argc, const char * argv[]) {
@autoreleasepool {
Block block;
{
Person *person = [[Person alloc] init];
person.age = 10;
__block Person *weakPerson = person;
block = ^{
NSLog(@"---------%d", weakPerson.age);
};
NSLog(@"------%@", [block class]);
}
// 在這里打斷點觀察person是否會被釋放
NSLog(@"------");
}
return 0;
}
2.轉換成`C++檔案`可以發現，`__block`底層生成的結構體里面會參考著該物件型別，并且默認是用`__strong`來修飾，而且內部也會對應的生成`copy`和`dispose`函式
struct __Block_byref_weakPerson_0 {
void __isa;
__Block_byref_weakPerson_0 __forwarding;
int __flags;
int __size;
void (__Block_byref_id_object_copy)(void, void);
void (__Block_byref_id_object_dispose)(void*);
Person *__strong weakPerson;
};
3.我們看`main函式`里會將`__Block_byref_id_object_copy_131`和`__Block_byref_id_object_dispose_131`賦值給`__Block_byref_weakPerson_0`這個結構體物件
int main(int argc, const char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
Block block;
{
Person *person = ((Person *(*)(id, SEL))(void *)objc_msgSend)((id)((Person *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("Person"), sel_registerName("alloc")), sel_registerName("init"));
((void (*)(id, SEL, int))(void *)objc_msgSend)((id)person, sel_registerName("setAge:"), 10);
// __Block_byref_weakPerson_0 weakPerson = {0, &weakPerson, 33554432, sizeof(__Block_byref_weakPerson_0), __Block_byref_id_object_copy_131, __Block_byref_id_object_dispose_131, person};
__attribute__((__blocks__(byref))) __Block_byref_weakPerson_0 weakPerson = {(void*)0,(__Block_byref_weakPerson_0 *)&weakPerson, 33554432, sizeof(__Block_byref_weakPerson_0), __Block_byref_id_object_copy_131, __Block_byref_id_object_dispose_131, person};
block = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_weakPerson_0 *)&weakPerson, 570425344));
NSLog((NSString *)&__NSConstantStringImpl__var_folders_wn_kcs2c07n3mqd02d77tvjgtjr0000gn_T_main_8be7f8_mi_1, ((Class (*)(id, SEL))(void *)objc_msgSend)((id)block, sel_registerName("class")));
}
NSLog((NSString *)&__NSConstantStringImpl__var_folders_wn_kcs2c07n3mqd02d77tvjgtjr0000gn_T_main_8be7f8_mi_2);
}
return 0;
}
4.找到這兩個值能發現也是分別會呼叫`_Block_object_assign`和`_Block_object_dispose`這兩個函式，而且傳的物件就是`__Block_byref_weakPerson_0`內部的`weakPerson`這個物件，也就是說這個結構體內部也會對`weakPerson`這個物件進行著`retain`和`release`的操作
static void __Block_byref_id_object_copy_131(void *dst, void src) {
_Block_object_assign((char)dst + 40, *(void * ) ((char)src + 40), 131);
}
static void __Block_byref_id_object_dispose_131(void src) {
_Block_object_dispose((void * ) ((char)src + 40), 131);
5.我們把第一段代碼中的`weakPerson`加上`__weak`修飾符，再運行程式會發現，當`block`釋放了，`person`物件也釋放了
typedef void (^Block)(void);
int main(int argc, const char * argv[]) {
@autoreleasepool {
Block block;
{
Person *person = [[Person alloc] init];
person.age = 10;
__block __weak Person *weakPerson = person;
block = ^{
NSLog(@"---------%d", weakPerson.age);
};
NSLog(@"------%@", [block class]);
}
// 在這里打斷點觀察person是否會被釋放
NSLog(@"------");
}
return 0;
}
6.我們轉換成`C++檔案`能發現，`__Block_byref_weakPerson_0`里面的`person`物件修飾符變成了`__weak`
struct __Block_byref_weakPerson_0 {
void __isa;
__Block_byref_weakPerson_0 __forwarding;
int __flags;
int __size;
void (__Block_byref_id_object_copy)(void, void);
void (__Block_byref_id_object_dispose)(void*);
Person *__weak weakPerson;
};
##### 總結:
- `__block`修飾的物件型別也會生成一個新的結構體物件，并且只會被`block`進行強參考，同`__block`修飾基本資料型別是一樣的
- `__block`內部也會生成該物件型別的成員變數，而且會根據不同的修飾符`__strong`和`__weak`來對應著該物件型別是否被強參考
- `__block`內部也會生成`copy`和`dispose`函式
- 當`__block`變數被`copy`到堆時，會呼叫`__block`變數內部的`copy函式`，`copy函式`內部會呼叫`_Block_object_assign`函式，`_Block_object_assign`函式會根據所指向物件的修飾符`（__strong、__weak、__unsafe_unretained）`做出相應的操作，形成強參考（retain）或者弱參考
- 如果`__block`變數從堆上移除，會呼叫`__block`變數內部的`dispose函式`，`dispose函式`內部會呼叫`_Block_object_dispose`函式，`_Block_object_dispose`函式會自動釋放指向的物件（release）
**注意：在MRC環境下即使用\_\_block修飾，\_\_block內部只會對auto變數進行弱參考，無論加不加__weak，block釋放了，就全都釋放了，這點和在ARC環境下不同**
### 回圈參考
`block`在使用中很容易就會造成回圈參考問題，例如下面的代碼
typedef void (^Block) (void);
@interface Person : NSObject
@property (copy, nonatomic) Block block;
@property (assign, nonatomic) int age;
- (void)test;
@end
@implementation Person
- (void)test {
// 內部回圈參考
self.block = ^{
NSLog(@"age is %d", self.age);
};
}
@end
int main(int argc, const char * argv[]) {
@autoreleasepool {
Person *person = [[Person alloc] init];
person.age = 10;
// 回圈參考
person.block = ^{
NSLog(@"age is %d", person.age);
};
}
NSLog(@"111111111111");
return 0;
}
`person`物件里面的`block`屬性強參考著`block`物件，而`block`物件內部也會有一個`person`的成員變數指向這個`Person物件`，這樣就會造成回圈參考，誰也無法釋放
#### 解決方法
##### 在ARC環境下
讓其中一個指標變成弱參考
1.用`__weak`解決，不會產生強參考，當指向的物件銷毀時，會自動讓指標置為`nil`
@implementation Person
-
(void)test {
__weak typeof(self) weakSelf = self;self.block = ^{
NSLog(@"age is %d", weakSelf.age);
};
}
@end
int main(int argc, const char * argv[]) {
@autoreleasepool {
Person *person = [[Person alloc] init];
person.age = 10;
// __weak Person *weakPerson = person;
__weak typeof(person) weakPerson = person;
person.block = ^{
NSLog(@"age is %d", weakPerson.age);
};
}
NSLog(@"111111111111");
return 0;
}
2.用`__unsafe_unretained`解決，不會產生強參考，但是是不安全的，當指向的物件銷毀時，指標存盤的地址值不變，仍然是指向著那塊已經被回收的記憶體空間，那么再訪問這個這個變數就會造成野指標錯誤
@implementation Person
-
(void)test {
__unsafe_unretained typeof(self) weakSelf = self;self.block = ^{
NSLog(@"age is %d", weakSelf.age);
};
}
@end
int main(int argc, const char * argv[]) {
@autoreleasepool {
Person *person = [[Person alloc] init];
person.age = 10;
__unsafe_unretained Person *weakPerson = person;
person.block = ^{
NSLog(@"age is %d", weakPerson.age);
};
}
NSLog(@"111111111111");
return 0;
}
3.用``__block``解決，用`__block`修飾物件會造成三者相互參考造成回圈參考，需要手動呼叫block
int main(int argc, const char * argv[]) {
@autoreleasepool {
__block Person *person = [[Person alloc] init];
person.age = 10;
person.block = ^{
NSLog(@"age is %d", weakPerson.age);
person = nil;
};
}
person.block();
NSLog(@"111111111111");
return 0;
}
`block`內部也需要手動將`person`置空，這個`person`是`__block`內部生成的指向`Person物件`的變數
##### 在MRC環境下
1.用`__unsafe_unretained`解決，同ARC環境下一樣，只是MRC不支持`__weak`
Person *person = [[Person alloc] init];
__unsafe_unretained typeof(person) weakPerson = person;
person.block = [^{
NSLog(@"age is %d", weakPerson.age);
} copy];
[person release];
2.用`__block`解決，在MRC中，`__block`物件里是不會對`person物件`進行強參考的，所以不會造成回圈參考
__block Person *person = [[Person alloc] init];
person.age = 10;
person.block = [^{
NSLog(@"age is %d", person.age);
} copy];
[person release];
### 面試題
#### 1.看下面代碼，分別輸入的值是什么
int a = 10;
static int b = 10;
int main(int argc, const char * argv[]) {
@autoreleasepool {
auto int age = 10;
static int height = 10;
void (^block)(void) = ^{
NSLog(@"age is %d, height is %d", age, height);
NSLog(@"a is %d, b is %d", a, b);
};
age = 20;
height = 20;
a = 20;
b = 20;
block();
// 輸出結果為：age=10，height=20，a=20，b=20
}
return 0;
}
`age`是自動變數，是值傳遞
`height`表示的是指標傳遞，`block`捕獲的是該變數的地址
而`a、b`都為全域變數，所以`block`根本不用捕獲，需要時直接拿取當前最新的值就可以了
int a = 10;
static int b = 10;
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
int age;
int *height;
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _age, int *_height, int flags=0) : age(_age), height(_height) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
int main(int argc, const char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
auto int age = 10;
static int height = 10;
void (*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, age, &height));
age = 20;
height = 20;
a = 20;
b = 20;
((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
}
return 0;
}
#### 2.看下面代碼，block內部會不會捕獲self
@interface Person : NSObject
@property (copy, nonatomic) NSString *name;
- (instancetype)initWithName:(NSString *)name;
@end
@implementation Person
-
(void)test
{
void (^block)(void) = ^{
NSLog(@"-------%d", [self name]);
};
block();
} -
(instancetype)initWithName:(NSString *)name
{
if (self = [super init]) {
self.name = name;
}
return self;
}
@end
會捕獲，因為`self`本質也是一個區域變數，`block`內部會生成一個變數來保存`Person物件`的地址
struct __Person__test_block_impl_0 {
struct __block_impl impl;
struct __Person__test_block_desc_0* Desc;
Person *self;
__Person__test_block_impl_0(void *fp, struct __Person__test_block_desc_0 *desc, Person *_self, int flags=0) : self(_self) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
// 函式都會生成隱式引數self和_cmd
static void _I_Person_test(Person * self, SEL _cmd) {
void (block)(void) = ((void ()())&__Person__test_block_impl_0((void )__Person__test_block_func_0, &__Person__test_block_desc_0_DATA, self, 570425344));
((void ()(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
}
#### 3.\_\_block的作用是什么？有什么使用注意點
可以將修飾的變數包裝成一個物件，解決在`block`內部無法修改外部變數的問題，
`__block`內部會進行記憶體管理，還有在`MRC環境下`是不會對物件進行強參考
#### 4.block的屬性修飾詞為什么是copy？使用block有哪些使用注意？
`block`一旦沒有進行`copy操作`，就不會在堆上，放到堆上的目的是方便我們來控制他的生命周期，可以更有效的進行記憶體管理，
注意回圈參考轉載請註明出處，本文鏈接：https://www.uj5u.com/yidong/273194.html
標籤：iOS