iOS Block的本质(二)
1. 介绍引入block本质
- 通过上一篇文章Block的本质（一）已经基本对block的底层结构有了基本的认识，block的底层就是
__main_block_impl_0 - 通过以下这张图展示底层各个结构体之间的关系。
2. block的变量捕获
- 为了保证block内部能够正常访问外部的变量，block有一个变量捕获机制。
局部变量
-
auto变量
- Block的本质（一）我们已经了解过block对age变量的捕获。
- auto自动变量，离开作用域就销毁，局部变量前面自动添加auto关键字。自动变量会捕获到block内部，也就是说block内部会专门新增加一个参数来存储变量的值。
- auto只存在于局部变量中，访问方式为值传递，通过上述对age参数的解释我们也可以确定确实是值传递。
-
static变量
- static 修饰的变量为指针传递，同样会被block捕获。
-
分析aotu修饰的局部变量和static修饰的局部变量之间的差别
int main(int argc, const char * argv[]) { @autoreleasepool { auto int a = 10; static int b = 10; void(^block)(void) = ^{ NSLog(@"age is %d, height is %d", a, b); }; a = 1; b = 2; block(); } return 0; } // log : 信息--> age = 10, height = 2 // block中a的值没有被改变而b的值随外部变化而变化。 -
重新生成c++代码看一下内部结构中两个参数的区别。
struct __main_block_impl_0 { struct __block_impl impl; struct __main_block_desc_0* Desc; int a; // a 为值 int *b; // b 为指针 __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _a, int *_b, int flags=0) : a(_a), b(_b) { impl.isa = &_NSConcremainackBlock; 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 int *b = __cself->b; // bound by copy NSLog((NSString *)&__NSConstantStringImpl__var_folders_2r__m13fp2x2n9dvlr8d68yry500000gn_T_main_fd2a14_mi_0, a, (*b)); } 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)}; -
从上述源码中可以看出，a,b两个变量都有捕获到block内部。但是a传入的是值，而b传入的则是地址。
-
为什么两种变量会有这种差异呢，因为自动变量可能会销毁，block在执行的时候有可能自动变量已经被销毁了，那么此时如果再去访问被销毁的地址肯定会发生坏内存访问，因此对于自动变量一定是值传递而不可能是指针传递了。而静态变量不会被销毁，所以完全可以传递地址。而因为传递的是值得地址，所以在block调用之前修改地址中保存的值，block中的地址是不会变得。所以值会随之改变。
-
全局变量
- 我们同样以代码的方式看一下block是否捕获全局变量
int age_ = 10; static int height_ = 10; int main(int argc, const char * argv[]) { @autoreleasepool { void(^block)(void) = ^{ NSLog(@"age is %d, height is %d", age_, height_); }; age_ = 1; height_ = 2; block(); } return 0; } // log 信息--> age = 1, height = 2 -
同样生成c++代码查看全局变量调用方式
int age_ = 10; static int height_ = 10; 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 = &_NSConcremainackBlock; impl.Flags = flags; impl.FuncPtr = fp; Desc = desc; } }; static void __main_block_func_0(struct __main_block_impl_0 *__cself) { NSLog((NSString *)&__NSConstantStringImpl__var_folders_2r__m13fp2x2n9dvlr8d68yry500000gn_T_main_fd2a14_mi_0, age_, height_); } 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)}; -
通过上述代码可以发现，__main_block_imp_0并没有添加任何变量，因此block不需要捕获全局变量，因为全局变量无论在哪里都可以访问。
- 局部变量因为跨函数访问所以需要捕获，全局变量在哪里都可以访问 ，所以不用捕获。
-
block的变量总结
- 总结：局部变量都会被block捕获，自动变量是值捕获，静态变量为地址捕获。全局变量则不会被block捕获
- 总结：局部变量都会被block捕获，自动变量是值捕获，静态变量为地址捕获。全局变量则不会被block捕获
3. 变量捕获拓展
-
以下Persion类代码中block变量分析
@interface Person : NSObject @property (copy, nonatomic) NSString *name; - (void)test; - (instancetype)initWithName:(NSString *)name; @end #import "Person.h" @implementation Person int age_ = 10; - (void)test { void (^block)(void) = ^{ NSLog(@"-------%d", [self name]); }; block(); } - (instancetype)initWithName:(NSString *)name { if (self = [super init]) { self.name = name; } return self; } @end -
同样转化为c++代码查看其内部结构
int age_ = 10; 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; } }; static void __Person__test_block_func_0(struct __Person__test_block_impl_0 *__cself) { Person *self = __cself->self; // bound by copy NSLog((NSString *)&__NSConstantStringImpl__var_folders_2r__m13fp2x2n9dvlr8d68yry500000gn_T_Person_1027e6_mi_0, ((NSString *(*)(id, SEL))(void *)objc_msgSend)((id)self, sel_registerName("name"))); } static void __Person__test_block_copy_0(struct __Person__test_block_impl_0*dst, struct __Person__test_block_impl_0*src) {_Block_object_assign((void*)&dst->self, (void*)src->self, 3/*BLOCK_FIELD_IS_OBJECT*/);} static void __Person__test_block_dispose_0(struct __Person__test_block_impl_0*src) {_Block_object_dispose((void*)src->self, 3/*BLOCK_FIELD_IS_OBJECT*/);} static struct __Person__test_block_desc_0 { size_t reserved; size_t Block_size; void (*copy)(struct __Person__test_block_impl_0*, struct __Person__test_block_impl_0*); void (*dispose)(struct __Person__test_block_impl_0*); } __Person__test_block_desc_0_DATA = { 0, sizeof(struct __Person__test_block_impl_0), __Person__test_block_copy_0, __Person__test_block_dispose_0}; 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); } static instancetype _I_Person_initWithName_(Person * self, SEL _cmd, NSString *name) { if (self = ((Person *(*)(__rw_objc_super *, SEL))(void *)objc_msgSendSuper)((__rw_objc_super){(id)self, (id)class_getSuperclass(objc_getClass("Person"))}, sel_registerName("init"))) { ((void (*)(id, SEL, NSString *))(void *)objc_msgSend)((id)self, sel_registerName("setName:"), (NSString *)name); } return self; } static NSString * _I_Person_name(Person * self, SEL _cmd) { return (*(NSString **)((char *)self + OBJC_IVAR_$_Person$_name)); } extern "C" __declspec(dllimport) void objc_setProperty (id, SEL, long, id, bool, bool); static void _I_Person_setName_(Person * self, SEL _cmd, NSString *name) { objc_setProperty (self, _cmd, __OFFSETOFIVAR__(struct Person, _name), (id)name, 0, 1); } // @end struct _prop_t { const char *name; const char *attributes; }; -
可以发现，self同样被block捕获，接着我们找到test方法可以发现，test方法默认传递了两个参数self和_cmd。
-
同理得，类方法也同样默认传递了类对象self和方法选择器_cmd。
-
不论对象方法还是类方法都会默认将self作为参数传递给方法内部，既然是作为参数传入，那么self肯定是局部变量。上面讲到局部变量肯定会被block捕获。
-
在block内部使用name成员变量或者调用实例的属性
- (void)test { void(^block)(void) = ^{ NSLog(@"%@",self.name); NSLog(@"%@",_name); }; block(); }
-
得到结论：在block中使用的是实例对象的属性，block中捕获的仍然是实例对象，并通过实例对象通过不同的方式去获取使用到的属性。
4. block的类型
1.类型分析
-
通过源码分析得到，block中的isa指针指向的是_NSConcreteStackBlock类对象地址。那么block是否就是_NSConcreteStackBlock类型的呢？
-
我们通过代码用class方法或者isa指针查看具体类型。
int main(int argc, const char * argv[]) { @autoreleasepool { // __NSGlobalBlock__ : __NSGlobalBlock : NSBlock : NSObject void (^block)(void) = ^{ NSLog(@"Hello"); }; NSLog(@"%@", [block class]); NSLog(@"%@", [[block class] superclass]); NSLog(@"%@", [[[block class] superclass] superclass]); NSLog(@"%@", [[[[block class] superclass] superclass] superclass]); } return 0; } // log 打印结果 __NSGlobalBlock__ // log 打印结果 __NSGlobalBlock // log 打印结果 NSBlock // log 打印结果 NSObjcet -
从上述打印内容可以看出block最终都是继承自NSBlock类型，而NSBlock继承于NSObjcet。那么block其中的isa指针其实是来自NSObject中的。这也更加印证了block的本质其实就是OC对象。
2.类型分类
-
block有3中类型
- __NSGlobalBlock__ （ _NSConcreteGlobalBlock ）
- __NSStackBlock__ （ _NSConcreteStackBlock ）
- __NSMallocBlock__ （ _NSConcreteMallocBlock ）
-
通过代码查看一下block在什么情况下其类型会各不相同
int main(int argc, const char * argv[]) { @autoreleasepool { // 1. 内部没有调用外部变量的block void (^block1)(void) = ^{ }; // 2. 内部调用外部变量的block int a = 10; void (^block2)(void) = ^{ NSLog(@"log ：%d",a); }; // 3. 直接调用的block的class NSLog(@"%@ %@ %@", [block1 class], [block2 class], [^{ NSLog(@"%d",a); } class]); } return 0; } // 最后一行 Log ：打印结果 __NSGlobalBlock__， __NSStackBlock__ ，__NSMallocBlock__ -
上述代码转化为c++代码查看源码时却发现block的类型与打印出来的类型不一样，c++源码中三个block的isa指针全部都指向_NSConcreteStackBlock类型地址。
-
我们可以推测runtime运行时过程中也许对类型进行了转变。最终类型当然以runtime运行时类型也就是我们打印出的类型为准。
5. block在内存中的存储
-
通过下面一张图看一下不同block的存放区域
-
上图中可以发现，根据block的类型不同，block存放在不同的区域中。
数据段中的__NSGlobalBlock__直到程序结束才会被回收，不过我们很少使用到__NSGlobalBlock__类型的block，因为这样使用block并没有什么意义。 -
__NSStackBlock__类型的block存放在栈中，我们知道栈中的内存由系统自动分配和释放，作用域执行完毕之后就会被立即释放，而在相同的作用域中定义block并且调用block似乎也多此一举。
-
__NSMallocBlock__是在平时编码过程中最常使用到的。存放在堆中需要我们自己进行内存管理。
-
block是如何定义其类型
-
接着我们使用代码验证上述问题，首先关闭ARC回到MRC环境下，因为ARC会帮助我们做很多事情，可能会影响我们的观察。
// MRC环境！！！ int main(int argc, const char * argv[]) { @autoreleasepool { // Global：没有访问auto变量：__NSGlobalBlock__ void (^block1)(void) = ^{ NSLog(@"block1---------"); }; // Stack：访问了auto变量： __NSStackBlock__ int a = 10; void (^block2)(void) = ^{ NSLog(@"block2---------%d", a); }; NSLog(@"%@ %@", [block1 class], [block2 class]); // __NSStackBlock__调用copy ： __NSMallocBlock__ NSLog(@"%@", [[block2 copy] class]); } return 0; } // Log 打印信息 --> __NSGlobalBlock__ ，__NSStackBlock__ ，__NSMallocBlock__ -
通过打印的内容可以验证上图中所示的正确性。
- 没有访问auto变量的block是__NSGlobalBlock__类型的，存放在数据段中。
- 访问了auto变量的block是__NSStackBlock__类型的，存放在栈中。
- __NSStackBlock__类型的block调用copy成为__NSMallocBlock__类型并被复制存放在堆中。
-
上面提到过__NSGlobalBlock__类型的我们很少使用到，因为如果不需要访问外界的变量，直接通过函数实现就可以了，不需要使用block。
-
但是__NSStackBlock__访问了aotu变量，并且是存放在栈中的，上面提到过，栈中的代码在作用域结束之后内存就会被销毁，那么我们很有可能block内存销毁之后才去调用他，那样就会发生问题，通过下面代码可以证实这个问题。MRC 环境下的。
void (^block)(void); void test() { // __NSStackBlock__ int a = 10; block = ^{ NSLog(@"block---------%d", a); }; } int main(int argc, const char * argv[]) { @autoreleasepool { test(); block(); } return 0; } // Log 打印信息 ：MRC 环境下 ： block---------272632424 // Log 打印信息 ：ARC 环境下 ： block---------10- 如果执行copy操作打印结果为10
void (^block)(void); void test() { // __NSStackBlock__ 调用copy 转化为__NSMallocBlock__ int age = 10; block = [^{ NSLog(@"block---------%d", age); } copy]; [block release]; } int main(int argc, const char * argv[]) { @autoreleasepool { // insert code here... test(); block(); // Log 打印信息 ： block---------10 } return 0; } -
可以发现a的值变为了不可控的一个数字。为什么会发生这种情况呢？因为上述代码中创建的block是__NSStackBlock__类型的，因此block是存储在栈中的，那么当test函数执行完毕之后，栈内存中block所占用的内存已经被系统回收，因此就有可能出现乱得数据。查看其c++代码可以更清楚的理解。
-
为了避免这种情况发生，可以通过copy将__NSStackBlock__类型的block转化为__NSMallocBlock__类型的block，将block存储在堆中，以下是修改后的代码。
void (^block)(void); void test() { // __NSStackBlock__ 调用copy 转化为__NSMallocBlock__ int age = 10; block = [^{ NSLog(@"block---------%d", age); } copy]; [block release]; } // Log 打印信息 ： block---------10 -
那么其他类型的block调用copy会改变block类型吗？下面表格已经展示的很清晰了。
-
所以在平时开发过程中MRC环境下经常需要使用copy来保存block，将栈上的block拷贝到堆中，即使栈上的block被销毁，堆上的block也不会被销毁，需要我们自己调用release操作来销毁。而在ARC环境下回系统会自动copy，是block不会被销毁。
6. ARC环境下的block
-
在ARC环境下，编译器会根据情况自动将栈上的block进行一次copy操作，将block复制到堆上。
-
会自动将block进行一次copy操作的情况。
-
block作为函数返回值时
typedef void (^Block)(void); Block myblock() { int a = 10; // 上文提到过，block中访问了auto变量，此时block类型应为__NSStackBlock__ Block block = ^{ NSLog(@"---------%d", a); }; return block; } int main(int argc, const char * argv[]) { @autoreleasepool { Block block = myblock(); block(); // 打印block类型为 __NSMallocBlock__ NSLog(@"%@",[block class]); } return 0; } Log 打印信息 ：---------10 Log 打印信息 ：__NSMallocBlock__- 上文提到过，如果在block中访问了auto变量时，block的类型为__NSStackBlock__，上面打印内容发现blcok为__NSMallocBlock__类型的，并且可以正常打印出a的值，说明block内存并没有被销毁。
- 上面提到过，block进行copy操作会转化为__NSMallocBlock__类型，来讲block复制到堆中，那么说明RAC在 block作为函数返回值时会自动帮助我们对block进行copy操作，以保存block，并在适当的地方进行release操作。
-
将block赋值给__strong指针时
- block被强指针引用时，ARC也会自动对block进行一次copy操作。
int main(int argc, const char * argv[]) { @autoreleasepool { // block内没有访问auto变量 Block block = ^{ NSLog(@"block---------"); }; NSLog(@"%@",[block class]); int a = 10; // block内访问了auto变量，但没有赋值给__strong指针 NSLog(@"%@",[^{ NSLog(@"block1---------%d", a); } class]); // block赋值给__strong指针 Block block2 = ^{ NSLog(@"block2---------%d", a); }; NSLog(@"%@",[block1 class]); } return 0; } Log 打印信息 ：__NSGlobalBlock__ Log 打印信息 ：__NSStackBlock__ Log 打印信息 ：__NSMallocBlock__ -
block作为Cocoa API中方法名含有usingBlock的方法参数时
- 例如：遍历数组的block方法，将block作为参数的时候。
NSArray *array = @[]; [array enumerateObjectsUsingBlock:^(id _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) { }]; -
block作为GCD API的方法参数时
- 例如：GDC的一次性函数或延迟执行的函数，执行完block操作之后系统才会对block进行release操作。
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(), ^{ });
7. block声明写法
- 通过上面对MRC及ARC环境下block的不同类型的分析，总结出不同环境下block属性建议写法。
-
MRC下block属性的建议写法
@property (copy, nonatomic) void (^block)(void); -
ARC下block属性的建议写法
@property (strong, nonatomic) void (^block)(void);
@property (copy, nonatomic) void (^block)(void);