先对block有一个基本的认识
block本质上也是一个oc对象，他内部也有一个isa指针。block是封装了函数调用以及函数调用环境的OC对象。
block的本质
int main(int argc, const char * argv[]) {
@autoreleasepool {
void (^block)(void) = ^{
NSLog(@"this is a block!");
};
block();
}
return 0;
}
通过命令行将代码转换成 c++ 代码
xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m
main 函数转化成的 C++ 代码如下
int main(int argc, const char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
void (*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
}
return 0;
}
将c++中block的声明和调用分别取出来查看其内部实现。
定义block变量
void (*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
可以发现，block定义中调用了__main_block_impl_0函数，并且将__main_block_impl_0函数的地址赋值给了 block。那么我们来看一下__main_block_impl_0函数内部结构。
__main_block_imp_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;
}
};
__main_block_imp_0结构体内有一个同名构造函数__main_block_imp_0，构造函数中对一些变量进行了赋值最终会返回一个结构体。也就是说最终将一个__main_block_imp_0结构体的地址赋值给了block变量
__main_block_impl_0结构体内可以发现__main_block_impl_0构造函数中传入了三个参数。(void *)__main_block_func_0、&__main_block_desc_0_DATA、flags。其中flags有默认值 0，也就说flags参数在调用的时候可以省略不传。
__main_block_func_0
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
NSLog((NSString *)&__NSConstantStringImpl__var_folders_xj_ybnbwbrx1tn7s5wnhqsx7lbw0000gn_T_main_958c22_mi_0);
}
发现代码是一个 NSLog 打印，恰恰是我们在block块中写下的代码。
那么 __main_block_func_0 函数中其实存储着我们 block 中写下的代码。而__main_block_impl_0函数中传入的是(void *)__main_block_func_0，也就说将我们写在block块中的代码封装成__main_block_func_0函数，并将__main_block_func_0函数的地址传入了__main_block_impl_0的构造函数中保存在结构体内。
&__main_block_desc_0_DATA
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_desc_0中存储着两个参数，reserved 和Block_size，并且 reserved 赋值为0，而 Block_size 则存储着__main_block_impl_0的占用空间大小。最终将__main_block_desc_0结构体的地址传入__main_block_func_0中赋值给Desc。
回过头来查看__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结构体
struct __block_impl {
void *isa;
int Flags;
int Reserved;
void *FuncPtr;
};
可以发现__block_impl结构体内部就有一个isa指针，因此可以证明block本质上就是一个oc对象。而在构造函数中将函数中传入的值分别存储在__main_block_impl_0结构体实例中，最终将结构体的地址赋值给block。
通过上面对__main_block_impl_0结构体构造函数的参数的分析可得结论：
__block_impl结构体中isa指针存储着&_NSConcreteStackBlock地址，可以暂时理解为其类对象地址，block就是_NSConcreteStackBlock类型的。- block 代码块中的代码被封装成
__main_block_func_0函数，FuncPtr 则存储着__main_block_func_0函数的地址。- Desc 指向
__main_block_desc_0结构体对象，其中存储__main_block_impl_0结构体所占用的内存。
调用block执行内部代码
((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
可以发现调用 block 是通过 block 找到 FunPtr 直接调用，通过上面分析我们知道block指向的是__main_block_impl_0 类型结构体，但是我们发现 __main_block_impl_0 结构体中并不直接就可以找到FunPtr，而FunPtr 是存储在 __block_impl 中的，为什么block可以直接调用__block_impl 中的 FunPtr 呢？
重新查看上述源代码可以发现，(__block_impl *)block 将 block 强制转化为 __block_impl 类型的，因为 __block_impl 是__main_block_impl_0结构体的第一个成员，那么 __block_impl 的内存地址就是 __main_block_impl_0结构体的内存地址。所以可以转化成功,并找到 FunPtr 成员。
FunPtr 中存储着通过代码块封装的函数地址，那么调用此函数，也就是会执行代码块中的代码。
验证block的本质 __main_block_impl_0 结构体类型。
struct __main_block_desc_0 {
size_t reserved;
size_t Block_size;
};
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;
int age;
};
int main(int argc, const char * argv[]) {
@autoreleasepool {
int age = 20;
void (^block)(void) = ^{
NSLog(@"this is a block! -- %d", age);
};
struct __main_block_impl_0 *blockStruct = (__bridge struct __main_block_impl_0 *)block;
block();
}
return 0;
}
通过打断点查看自定义的结构体是否被赋值成功，以及里面的值。
接下来断点来到block代码块中，看一下堆栈信息中的函数调用地址。Debuf workflow -> always show Disassembly
可以看到地址确实和FuncPtr中的代码块地址一样。
block底层的数据结构可以通过一张图来展示
block的变量捕获
为了保证block内部能够正常访问外部的变量，block有个变量捕获机制
局部变量
auto变量
auto自动变量，离开作用域就销毁，局部变量前面自动添加auto关键字。自动变量会捕获到block内部，也就是说block内部会专门新增加一个参数来存储变量的值。
int main(int argc, const char * argv[]) {
@autoreleasepool {
int age = 20;
void (^block)(void) = ^{
NSLog(@"this is a block! -- %d", age);
};
block();
}
return 0;
}
通过命令行将代码转换成 c++ 代码
xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m
查看生成的C++代码
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
int age;
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _age, int flags=0) : age(_age) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
int age = __cself->age; // bound by copy
NSLog((NSString *)&__NSConstantStringImpl__var_folders_xj_ybnbwbrx1tn7s5wnhqsx7lbw0000gn_T_main_933af9_mi_0, age);
}
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, const char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
int age = 20;
void (*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, age));
((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
}
return 0;
}
static struct IMAGE_INFO { unsigned version; unsigned flag; } _OBJC_IMAGE_INFO = { 0, 2 };
由代码可知捕获auto变量确实是值传递。
static变量
static 修饰的变量为指针传递，同样会被block捕获。
分别添加aotu修饰的局部变量和static修饰的局部变量，通过源码来看一下他们之间的差别
int main(int argc, const char * argv[]) {
@autoreleasepool {
static int height = 10;
int age = 20;
void (^block)(void) = ^{
NSLog(@"this is a block! -- %d --%d",height, age);
};
// struct __main_block_impl_0 *blockStruct = (__bridge struct __main_block_impl_0 *)block;
block();
}
return 0;
}
通过命令行将代码转换成 c++ 代码
xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m
查看生成的C++代码
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
int *height;
int age;
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int *_height, int _age, int flags=0) : height(_height), age(_age) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
int *height = __cself->height; // bound by copy
int age = __cself->age; // bound by copy
NSLog((NSString *)&__NSConstantStringImpl__var_folders_xj_ybnbwbrx1tn7s5wnhqsx7lbw0000gn_T_main_11af52_mi_0,(*height), age);
}
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, const char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
static int height = 10;
int age = 20;
void (*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, &height, age));
((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
}
return 0;
}
static struct IMAGE_INFO { unsigned version; unsigned flag; } _OBJC_IMAGE_INFO = { 0, 2 };
从上述源码中可以看出，height, age 两个变量都有捕获到block内部。但是age传入的是值，而height传入的则是地址。
为什么两种变量会有这种差异呢，因为自动变量可能会销毁，block在执行的时候有可能自动变量已经被销毁了，那么此时如果再去访问被销毁的地址肯定会发生坏内存访问，因此对于自动变量一定是值传递而不可能是指针传递了。而静态变量不会被销毁，所以完全可以传递地址。而因为传递的是值得地址，所以在block调用之前修改地址中保存的值，block中的值会随之改变。
全局变量
int width = 10;
static int length = 11;
int main(int argc, const char * argv[]) {
@autoreleasepool {
static int height = 10;
int age = 20;
void (^block)(void) = ^{
NSLog(@"this is a block! -- %d --%d -- %d --%d",height, age, width, length);
};
block();
}
return 0;
}
通过命令行将代码转换成 c++ 代码
xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m
查看生成的C++代码
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
int *height;
int age;
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int *_height, int _age, int flags=0) : height(_height), age(_age) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
int *height = __cself->height; // bound by copy
int age = __cself->age; // bound by copy
NSLog((NSString *)&__NSConstantStringImpl__var_folders_xj_ybnbwbrx1tn7s5wnhqsx7lbw0000gn_T_main_4a2f6a_mi_0,(*height), age, width, length);
}
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, const char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
static int height = 10;
int age = 20;
void (*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, &height, age));
((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
}
return 0;
}
static struct IMAGE_INFO { unsigned version; unsigned flag; } _OBJC_IMAGE_INFO = { 0, 2 };
通过上述代码可以发现，__main_block_imp_0 并没有添加全局变量 width 和 length，因此block不需要捕获全局变量，因为全局变量无论在哪里都可以访问。
最后做一个总结
局部变量都会被block捕获，自动变量是值捕获，静态变量为地址捕获。全局变量则不会被block捕获
思考：以下代码中block是否会捕获变量呢？
@interface Person : NSObject
@property(nonatomic, copy) NSString *name;
- (void)test;
@end
@implementation Person
- (void)test
{
void(^block)(void) = ^{
NSLog(@"%@",self);
};
block();
}
@end
int main(int argc, const char * argv[]) {
@autoreleasepool {
Person *person = [[Person alloc] init];
person.name = @"jack";
[person test];
}
return 0;
}
转化为c++代码查看其内部结构
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_xj_ybnbwbrx1tn7s5wnhqsx7lbw0000gn_T_main_a3f23a_mi_0,self);
}
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);
}
可以发现，self同样被block捕获，test方法默认传递了两个参数self和_cmd，那么self肯定是局部变量。上面讲到局部变量肯定会被block捕获。
如果 test 方法中代码如下
- (void)test
{
void(^block)(void) = ^{
NSLog(@"%@",self.name);
NSLog(@"%@",_name);
};
block();
}
转化为c++代码查看其内部结构
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_xj_ybnbwbrx1tn7s5wnhqsx7lbw0000gn_T_main_0d2dd0_mi_0,((NSString *(*)(id, SEL))(void *)objc_msgSend)((id)self, sel_registerName("name")));
NSLog((NSString *)&__NSConstantStringImpl__var_folders_xj_ybnbwbrx1tn7s5wnhqsx7lbw0000gn_T_main_0d2dd0_mi_1,(*(NSString **)((char *)self + OBJC_IVAR_$_Person$_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);
}
可以发现，即使block中使用的是实例对象的属性，block中捕获的仍然是实例对象，self.name 调用了 get 方法 objc_msgSend)(self, sel_registerName("name"))，而 _name 直接通过地址获取 (char *)self + OBJC_IVAR_$_Person$_name。
block的类型
block有3种类型：
__NSGlobalBlock__（ _NSConcreteGlobalBlock ）
__NSStackBlock__（ _NSConcreteStackBlock ）
__NSMallocBlock__（ _NSConcreteMallocBlock ）
可以通过调用class方法或者isa指针查看具体类型
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]);
NSLog(@"%@", [[[[block class] superclass] superclass] superclass]);
}
return 0;
}
打印内容
从上述打印内容可以看出block最终都是继承自NSBlock类型，而NSBlock继承于NSObjcet。那么block其中的isa指针其实是来自NSObject中的。这也更加印证了block的本质其实就是OC对象。
通过代码查看一下block在什么情况下其类型会各不相同
int main(int argc, const char * argv[]) {
@autoreleasepool {
void (^block1)(void) = ^{
NSLog(@"Hello");
};
int age = 10;
void (^block2)(void) = ^{
NSLog(@"Hello - %d", age);
};
NSLog(@"\n %@ \n %@ \n %@", [block1 class], [block2 class], [^{
NSLog(@"%d", age);
} class]);
}
return 0;
}
打印结果
将代码转化成 C++ 代码
// __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;
}
};
// __main_block_impl_1
struct __main_block_impl_1 {
struct __block_impl impl;
struct __main_block_desc_1* Desc;
int age;
__main_block_impl_1(void *fp, struct __main_block_desc_1 *desc, int _age, int flags=0) : age(_age) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
// __main_block_impl_2
struct __main_block_impl_2 {
struct __block_impl impl;
struct __main_block_desc_2* Desc;
int age;
__main_block_impl_2(void *fp, struct __main_block_desc_2 *desc, int _age, int flags=0) : age(_age) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
int main(int argc, const char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
void (*block1)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
int age = 10;
void (*block2)(void) = ((void (*)())&__main_block_impl_1((void *)__main_block_func_1, &__main_block_desc_1_DATA, age));
NSLog((NSString *)&__NSConstantStringImpl__var_folders_xj_ybnbwbrx1tn7s5wnhqsx7lbw0000gn_T_main_aeebac_mi_4, ((Class (*)(id, SEL))(void *)objc_msgSend)((id)block1, sel_registerName("class")), ((Class (*)(id, SEL))(void *)objc_msgSend)((id)block2, sel_registerName("class")), ((Class (*)(id, SEL))(void *)objc_msgSend)((id)((void (*)())&__main_block_impl_2((void *)__main_block_func_2, &__main_block_desc_2_DATA, age)), sel_registerName("class")));
}
return 0;
}
查看转化的c++代码发现block的类型与打印出来的类型不一样，c++源码中三个block的isa指针全部都指向_NSConcreteStackBlock类型地址。
猜测runtime运行时过程中也许对类型进行了转变。最终类型当然以runtime运行时类型也就是我们打印出的类型为准。
block在内存中的存储
上图中可以发现，根据block的类型不同，block存放在不同的区域中。
数据段中的NSGlobalBlock直到程序结束才会被回收，很少使用到NSGlobalBlock类型的block，因为这样使用block并没有什么意义。
NSStackBlock类型的block存放在栈中，我们知道栈中的内存由系统自动分配和释放，作用域执行完毕之后就会被立即释放，而在相同的作用域中定义block并且调用block似乎也多此一举。
NSMallocBlock是在平时编码过程中最常使用到的。存放在堆中需要我们自己进行内存管理。
block是如何定义其类型
我们先关闭ARC回到MRC环境下
看一下如下代码的打印结果如何
int main(int argc, const char * argv[]) {
@autoreleasepool {
void (^block1)(void) = ^{
NSLog(@"Hello");
};
int age = 10;
void (^block2)(void) = ^{
NSLog(@"Hello - %d", age);
};
NSLog(@"\n %@ \n %@ \n %@", [block1 class], [block2 class], [[block2 copy] class]);
}
return 0;
}
打印结果
通过打印的内容可以发现正如下图中所示。
没有访问auto变量的block是
__NSGlobalBlock__类型的，存放在数据段中。
访问了auto变量的block是
__NSStackBlock__类型的，存放在栈中。
__NSStackBlock__类型的block调用copy成为__NSMallocBlock__类型并被复制存放在堆中。
上面提到过
__NSGlobalBlock__类型的我们很少使用到，因为如果不需要访问外界的变量，直接通过函数实现就可以了，不需要使用block。
但是
__NSStackBlock__访问了auto变量，并且是存放在栈中的。
栈中的代码在作用域结束之后内存就会被销毁，那么很有可能block内存销毁之后才去调用它，那样就会发生问题
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;
}
打印结果
可以发现a的值变为了不可控的一个数字。为什么会发生这种情况呢？因为上述代码中创建的block是NSStackBlock类型的，因此block是存储在栈中的，那么当test函数执行完毕之后，栈内存中block所占用的内存已经被系统回收，因此就有可能出现乱得数据。
为了避免这种情况发生，可以通过copy将NSStackBlock类型的block转化为NSMallocBlock类型的block，将block存储在堆中，以下是修改后的代码。
void (^block)(void);
void test()
{
// __NSStackBlock__ 调用copy 转化为__NSMallocBlock__
int age = 10;
block = [^{
NSLog(@"block---------%d", age);
} copy];
}
int main(int argc, const char * argv[]) {
@autoreleasepool {
test();
block();
[block release];
}
return 0;
}
此时在打印就会发现数据正确
每一种类型的block调用copy后的结果如下所示
所以在平时开发过程中MRC环境下经常需要使用copy来保存block，将栈上的block拷贝到堆中，即使栈上的block被销毁，堆上的block也不会被销毁，需要我们自己调用release操作来销毁。而在ARC环境下回系统会自动copy。
ARC 帮我们做了什么？
在ARC环境下，编译器会根据情况自动将栈上的block复制到堆上，比如以下情况
block作为函数返回值时
typedef void(^Block)(void);
Block myBlock()
{
// __NSStackBlock__ 调用copy 转化为__NSMallocBlock__
int age = 10;
Block block = ^{
NSLog(@"block---------%d", age);
};
return block;
}
int main(int argc, const char * argv[]) {
@autoreleasepool {
Block block = myBlock();
block();
}
return 0;
}
打印内容：
在block中访问了auto变量时，block的类型为
__NSStackBlock__，上面打印内容发现blcok为__NSMallocBlock__类型的，并且可以正常打印出a的值，说明block内存并没有被销毁，被复制到堆中，说明RAC在 block作为函数返回值时会自动帮助我们对block进行copy操作，以保存block，并在适当的地方进行release操作。
将block赋值给__strong指针时
typedef void(^Block)(void);
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(@"%@",[block2 class]);
}
return 0;
}
从打印内容可以看出，当block被赋值给__strong指针时，RAC会自动进行一次copy操作。
block作为Cocoa API中方法名含有usingBlock的方法参数时
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(), ^{
});
blockblock属性的建议写法
MRC下block属性的建议写法
@property (copy, nonatomic) void (^block)(void);
ARC下block属性的建议写法
@property (strong, nonatomic) void (^block)(void);
@property (copy, nonatomic) void (^block)(void);
block对对象变量的捕获
int main(int argc, const char * argv[]) {
@autoreleasepool {
Block block;
{
Person *person = [[Person alloc] init];
person.name = @"jack";
block = ^{
NSLog(@"------block内部%@",person.name);
};
} // 执行完毕，person没有被释放
NSLog(@"--------");
}
return 0;
}
上面大括号的代码块执行完毕之后，person 没有被释放，person为auto变量，将会被 block 捕获，即block有一个强引用引用person，所以block不被销毁的话，person也不会销毁。
查看对应的 C++ 代码可发现 block 持有 person 的引用
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
Person *person;
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, Person *_person, int flags=0) : person(_person) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
将代码的运行环境转为 MRC
int main(int argc, const char * argv[]) {
@autoreleasepool {
Block block;
{
Person *person = [[Person alloc] init];
person.name = @"jack";
block = ^{
NSLog(@"------block内部%@",person.name);
};
[person release];
} // 执行完毕，person没有被释放
NSLog(@"--------");
}
return 0;
}
运行发现大括号的代码块执行完毕之后，person 就被释放，这是因为MRC环境下block在栈空间，栈空间对外面的person不会进行强引用。
block调用copy操作之后，person不会被释放
block = [^{
NSLog(@"------block内部%@",person.name);
} copy];
只对栈空间的block进行一次copy操作，将栈空间的block拷贝到堆中，person就不会被释放，说明堆空间的block可能会对person进行一次retain操作，以保证person不会被销毁。堆空间的block自己销毁之后也会对持有的对象进行release操作。
也就是说栈空间上的block不会对对象强引用，堆空间的block有能力持有外部调用的对象，即对对象进行强引用或去除强引用的操作。
__weak
__weak添加之后，person在大括号代码块执行完毕之后就被销毁了。
int main(int argc, const char * argv[]) {
@autoreleasepool {
Block block;
{
Person *person = [[Person alloc] init];
person.name = @"jack";
__weak typeof(person) weakPerson = person;
block = ^{
NSLog(@"------block内部%@",weakPerson.name);
};
} // 执行完毕，person没有被释放
NSLog(@"--------");
}
return 0;
}
将代码转化为c++来看一下，__weak修饰变量，需要告知编译器使用ARC环境及版本号否则会报错，添加说明-fobjc-arc -fobjc-runtime=ios-8.0.0
xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc -fobjc-arc -fobjc-runtime=ios-8.0.0 main.m
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
Person *__weak weakPerson;
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, Person *__weak _weakPerson, int flags=0) : weakPerson(_weakPerson) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
__weak修饰的变量，在生成的__main_block_impl_0中也是用__weak修饰的。
__main_block_copy_0 和 __main_block_dispose_0
当block中捕获对象类型的变量时，我们发现block结构体__main_block_impl_0的描述结构体__main_block_desc_0中多了两个参数copy和dispose函数，查看源码：
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*/);}
static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->person, 3/*BLOCK_FIELD_IS_OBJECT*/);}
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};
发现 copy 和 dispose 函数中传入的都是 __main_block_impl_0 结构体本身。
copy 本质就是 __main_block_copy_0函数， __main_block_copy_0函数内部调用 _Block_object_assign函数，_Block_object_assign 中传入的是 person 对象的地址，person 对象，以及3。
dispose 本质就是 __main_block_dispose_0 函数， __main_block_dispose_0 函数内部调用 _Block_object_dispose 函数，_Block_object_dispose 函数传入的参数是 person 对象，以及3。
_Block_object_assign函数调用时机及作用
当block进行copy操作的时候就会自动调用 __main_block_desc_0 内部的 __main_block_copy_0 函数， __main_block_copy_0 函数内部会调用 _Block_object_assign 函数。
_Block_object_assign 函数会自动根据 __main_block_impl_0 结构体内部的person是什么类型的指针，对 person 对象产生强引用或者弱引用。可以理解为 _Block_object_assign 函数内部会对person 进行引用计数器的操作，如果 __main_block_impl_0 结构体内 person 指针是 __strong 类型，则为强引用，引用计数+1，如果是 __weak 类型，则为弱引用，引用计数不变。
_Block_object_dispose函数调用时机及作用
当block从堆中移除时就会自动调用 __main_block_desc_0 中的 __main_block_dispose_0 函数，__main_block_dispose_0 函数内部会调用 _Block_object_dispose 函数。
_Block_object_dispose 会对 person 对象做释放操作，类似于release，也就是断开对 person 对象的引用。
总结
- 当block内部访问了对象类型的auto变量时，如果block是在栈上，将不会对auto变量产生强引用
- 如果block被拷贝到堆上，会调用block内部的copy函数，copy函数内部会调用
_Block_object_assign函，_Block_object_assign函数会根据auto变量的修饰符（__strong、__weak、__unsafe_unretained）做出相应的操作，形成强引用（retain）或者弱引用 - 如果block从堆上移除，会调用block内部的dispose函数，dispose函数内部会调用
_Block_object_dispose函数
_Block_object_dispose函数会自动释放引用的auto变量（release） -
用图总结一下后两条
copy 和 dispose 调用的时机
block内修改变量的值
int main(int argc, const char * argv[]) {
@autoreleasepool {
int age = 10;
Block block = ^ {
// age = 20; // 无法修改
NSLog(@"%d",age);
};
block();
}
return 0;
}
默认情况下block不能修改外部的局部变量，通过之前的源码分析可得原因如下：
age是在 main 函数内部声明的，说明 age 的内存存在于main函数的栈空间内部，但是block内部的代码
__main_block_func_0函数内部。__main_block_func_0函数内部无法访问age变量的内存空间，两个函数的栈空间不一样，__main_block_func_0内部拿到的age是block结构体内部的age，因此无法在__main_block_func_0函数内部去修改main函数内部的变量。
那应该如何做才能在block内修改变量的值
方式一：age使用static修饰
block内部捕获到的是 static 修饰的 age 变量的指针，所以在__main_block_func_0 函数内部就可以拿到 age 变量的内存地址，因此就可以在block内部修改age的值。
方式二：__block
__block用于解决block内部不能修改auto变量值的问题，__block不能修饰静态变量（static） 和全局变量
int main(int argc, const char * argv[]) {
@autoreleasepool {
__block int age = 10;
Block block = ^ {
age = 20; // 无法修改
NSLog(@"%d",age);
};
block();
}
return 0;
}
查看底层 C++ 源码
typedef void(*Block)(void);
struct __Block_byref_age_0 {
void *__isa; //isa 指针
__Block_byref_age_0 *__forwarding; //存储结构体自己的地址
int __flags;
int __size; // 变量占用的空间
int age; // age 变量
};
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
__Block_byref_age_0 *age; // __block 修饰的变量，变成了 __Block_byref_age_0 结构体指针
__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;
}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
__Block_byref_age_0 *age = __cself->age; // 拿到 age 的结构体
(age->__forwarding->age) = 20; // 通过结构体拿到 age 变量并赋值
NSLog((NSString *)&__NSConstantStringImpl__var_folders_xj_ybnbwbrx1tn7s5wnhqsx7lbw0000gn_T_main_85eda0_mi_0,(age->__forwarding->age));
}
//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->age, (void*)src->age, 8/*BLOCK_FIELD_IS_BYREF*/);}
// block 销毁时会调用
static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->age, 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, const char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
__attribute__((__blocks__(byref))) __Block_byref_age_0 age = {(void*)0,(__Block_byref_age_0 *)&age, 0, sizeof(__Block_byref_age_0), 10};
Block block = ((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 *)block)->FuncPtr)((__block_impl *)block);
}
return 0;
}
首先被 __block 修饰的age变量声明变为名为age的__Block_byref_age_0 结构体，也就是说加上 __block 修饰的话捕获到的block内的变量为 __Block_byref_age_0 类型的结构体。
分析 __Block_byref_age_0结构体内存储哪些元素
__isa指针：__Block_byref_age_0中也有isa指针也就是说__Block_byref_age_0本质也一个对象。__forwarding：__forwarding是__Block_byref_age_0结构体类型的，并且__forwarding存储的值为(__Block_byref_age_0 *)&age，即结构体自己的内存地址。__flags：0__size：sizeof(__Block_byref_age_0)即__Block_byref_age_0所占用的内存空间。age：真正存储变量的地方，这里存储局部变量10。
由c++源码可看到调用block时，首先取出 __main_block_impl_0中的age，通过age结构体拿到 __forwarding指针，上面提到过__forwarding中保存的就是__Block_byref_age_0结构体本身，在通过__forwarding拿到结构体中的 age 变量并修改其值。
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
__Block_byref_age_0 *age = __cself->age; // 拿到 age 的结构体
(age->__forwarding->age) = 20; // 通过结构体拿到 age 变量并赋值
NSLog((NSString *)&__NSConstantStringImpl__var_folders_xj_ybnbwbrx1tn7s5wnhqsx7lbw0000gn_T_main_85eda0_mi_0,(age->__forwarding->age));
}
NSLog 中使用 age 时也通过同样的方式获取 age 的值。
__block修饰对象类型
@interface Person : NSObject
@property(nonatomic, copy) NSString *name;
@end
@implementation Person
@end
typedef void(^Block)(void);
int main(int argc, const char * argv[]) {
@autoreleasepool {
__block Person *person = [[Person alloc] init];
Block block = ^{
person = [[Person alloc] init];
NSLog(@"%@",person);
};
block();
}
return 0;
}
生成c++源码查看
struct __Block_byref_person_0 {
void *__isa;
__Block_byref_person_0 *__forwarding;
int __flags;
int __size;
void (*__Block_byref_id_object_copy)(void*, void*);
void (*__Block_byref_id_object_dispose)(void*);
Person *__strong person;
};
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
__Block_byref_person_0 *person; // by ref
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_person_0 *_person, int flags=0) : person(_person->__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_person_0 *person = __cself->person; // bound by ref
(person->__forwarding->person) = ((Person *(*)(id, SEL))(void *)objc_msgSend)((id)((Person *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("Person"), sel_registerName("alloc")), sel_registerName("init"));
NSLog((NSString *)&__NSConstantStringImpl__var_folders_xj_ybnbwbrx1tn7s5wnhqsx7lbw0000gn_T_main_5dabb7_mi_0,(person->__forwarding->person));
}
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, 8/*BLOCK_FIELD_IS_BYREF*/);}
static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->person, 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, const char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
__attribute__((__blocks__(byref))) __Block_byref_person_0 person = {(void*)0,(__Block_byref_person_0 *)&person, 33554432, sizeof(__Block_byref_person_0), __Block_byref_id_object_copy_131, __Block_byref_id_object_dispose_131, ((Person *(*)(id, SEL))(void *)objc_msgSend)((id)((Person *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("Person"), sel_registerName("alloc")), sel_registerName("init"))};
Block block = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_person_0 *)&person, 570425344));
((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
}
return 0;
}
通过源码查看，对象被包装在一个新的结构体中，结构体内部会有一个person对象，不一样的地方是结构体内部添加了内存管理的两个函数 __Block_byref_id_object_copy 和__Block_byref_id_object_dispose
#define __OFFSETOFIVAR__(TYPE, MEMBER) ((long long) &((TYPE *)0)->MEMBER)
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);
}
__Block_byref_id_object_copy和__Block_byref_id_object_dispose函数的调用时机及作用在__block内存管理部分详细分析。
思考：__block修饰的age变量在编译时会被封装为结构体，那么当在外部使用age变量的时候，使用的
__Block_byref_age_0结构体呢？还是__Block_byref_age_0结构体内的age变量呢？
答：外部使用 age 变量是使用__Block_byref_age_0结构体内的age变量，apple为了隐藏__Block_byref_age_0结构体的实现，打印age变量的地址可以发现其实是__Block_byref_age_0结构体内age变量的地址。
__block内存管理
当block中捕获对象类型的变量时，block中的__main_block_desc_0 结构体内部会自动添加copy和dispose函数对捕获的变量进行内存管理。
当block内部捕获__block修饰的对象类型的变量时，__Block_byref_person_0结构体内部也会自动添加__Block_byref_id_object_copy和__Block_byref_id_object_dispose 对被__block包装成结构体中的对象进行内存管理。
当block内存在栈上时，并不会对__block变量产生内存管理。当blcok被copy到堆上时
会调用block内部的copy函数，copy函数内部会调用_Block_object_assign函数，_Block_object_assign函数会对__block变量形成强引用（相当于retain）
首先通过一张图看一下block复制到堆上时内存变化
当block被copy到堆上时，block内部引用的__block变量也会被复制到堆上，并且持有变量，如果block复制到堆上的同时，__block变量已经存在堆上了，则不会复制。
当block从堆中移除的话，就会调用dispose函数，也就是__main_block_dispose_0函数，__main_block_dispose_0函数内部会调用_Block_object_dispose函数，会自动释放引用的__block变量。
block内部决定什么时候将变量复制到堆中，什么时候对变量做引用计数的操作。
__block修饰的变量在 block 结构体中一直都是强引用，而其他类型的是由传入的对象指针类型决定。
接下来我们看一下 __block 修饰的变量生成的结构体有什么不同？
struct __Block_byref_person_0 {
void *__isa;
__Block_byref_person_0 *__forwarding;
int __flags;
int __size;
void (*__Block_byref_id_object_copy)(void*, void*);
void (*__Block_byref_id_object_dispose)(void*);
Person *__strong person;
};
struct __Block_byref_age_1 {
void *__isa;
__Block_byref_age_1 *__forwarding;
int __flags;
int __size;
int age;
};
struct __Block_byref_weakPerson_2 {
void *__isa;
__Block_byref_weakPerson_2 *__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_byref_id_object_copy和__Block_byref_id_object_dispose两个函数，用来对对象类型的变量进行内存管理的操作。而结构体对对象的引用类型，则取决于block捕获的对象类型的变量。weakPerson是弱指针，所以__Block_byref_weakPerson_2对weakPerson就是弱引用，person是强指针，所以__Block_byref_person_0对person就是强引用。
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {
_Block_object_assign((void*)&dst->age, (void*)src->age, 8/*BLOCK_FIELD_IS_BYREF*/);
_Block_object_assign((void*)&dst->person, (void*)src->person, 8/*BLOCK_FIELD_IS_BYREF*/);
_Block_object_assign((void*)&dst->weakPerson, (void*)src->weakPerson, 8/*BLOCK_FIELD_IS_BYREF*/);
_Block_object_assign((void*)&dst->person2, (void*)src->person2, 3/*BLOCK_FIELD_IS_OBJECT*/);
}
__main_block_copy_0函数中会根据变量是强弱指针及有没有被__block修饰做出不同的处理，强指针在block内部产生强引用，弱指针在block内部产生弱引用。被__block修饰的变量最后的参数传入的是8，没有被__block修饰的变量最后的参数传入的是3。
static void __main_block_dispose_0(struct __main_block_impl_0*src) {
_Block_object_dispose((void*)src->age, 8/*BLOCK_FIELD_IS_BYREF*/);
_Block_object_dispose((void*)src->person, 8/*BLOCK_FIELD_IS_BYREF*/);
_Block_object_dispose((void*)src->weakPerson, 8/*BLOCK_FIELD_IS_BYREF*/)
;_Block_object_dispose((void*)src->person2, 3/*BLOCK_FIELD_IS_OBJECT*/);
}
同理 __main_block_dispose_0 根据变量有没有被__block修饰做出不同的处理，被__block修饰的变量最后的参数传入的是8，没有被__block修饰的变量最后的参数传入的是3。
__forwarding指针
我们知道 __forwarding 指针指向的是结构体自己。当使用变量的时候，通过结构体找到 __forwarding 指针，在通过__forwarding 指针找到相应的变量。这样设计的目的是为了方便内存管理。通过上面对__block变量的内存管理分析我们知道，block被复制到堆上时，会将block中引用的变量也复制到堆中。
当block在栈中时，__Block_byref_age_0结构体内的__forwarding指针指向结构体自己。
而当block被复制到堆中时，栈中的__Block_byref_age_0结构体也会被复制到堆中一份，而此时栈中的__Block_byref_age_0结构体中的__forwarding指针指向的就是堆中的__Block_byref_age_0结构体，堆中__Block_byref_age_0结构体内的__forwarding指针依然指向自己。
通过__forwarding指针巧妙的将修改的变量赋值在堆中的__Block_byref_age_0中。
被__block修饰的对象类型的内存管理
int main(int argc, const char * argv[]) {
@autoreleasepool {
__block Person *person = [[Person alloc] init];
Block block = ^ {
NSLog(@"%p", person);
};
block();
}
return 0;
}
生成c++代码查看__Block_byref_person_0结构体及其声明
//__Block_byref_person_0结构体
struct __Block_byref_person_0 {
void *__isa; // 8
__Block_byref_person_0 *__forwarding; //8
int __flags; //4
int __size; //4
void (*__Block_byref_id_object_copy)(void*, void*); //8
void (*__Block_byref_id_object_dispose)(void*); //8
Person *__strong person; //8
};
// 8 + 8 + 4 + 4 + 8 + 8 + 8 = 48
// __Block_byref_person_0结构体声明
__attribute__((__blocks__(byref))) __Block_byref_person_0 person = {
(void*)0,(__Block_byref_person_0 *)&person,
33554432,
sizeof(__Block_byref_person_0),
__Block_byref_id_object_copy_131,
__Block_byref_id_object_dispose_131,
((Person *(*)(id, SEL))(void *)objc_msgSend)((id)((Person *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("Person"), sel_registerName("alloc")), sel_registerName("init"))};
__block修饰的对象类型生成的结构体中新增加了两个函数 void (*__Block_byref_id_object_copy)(void*, void*);和void (*__Block_byref_id_object_dispose)(void*);。这两个函数为__block修饰的对象提供了内存管理的操作。
可以看出为void (*__Block_byref_id_object_copy)(void*, void*);和void (*__Block_byref_id_object_dispose)(void*);赋值的分别为__Block_byref_id_object_copy_131和__Block_byref_id_object_dispose_131 找到这两个函数
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);
}
上述源码中可以发现__Block_byref_id_object_copy_131函数中同样调用了_Block_object_assign函数，而_Block_object_assign函数内部拿到dst指针即block对象自己的地址值加上40个字节。并且_Block_object_assign最后传入的参数是131，同block直接对对象进行内存管理传入的参数3，8都不同。可以猜想_Block_object_assign内部根据传入的参数不同进行不同的操作的。
通过对上面__Block_byref_person_0结构体占用空间计算发现__Block_byref_person_0结构体占用的空间为48个字节。而加40恰好指向的就为person指针。
也就是说copy函数会将person地址传入_Block_object_assign函数，_Block_object_assign中对Person对象进行强引用或者弱引用。
如果使用__weak修饰变量查看一下其中的源码
int main(int argc, const char * argv[]) {
@autoreleasepool {
Person *person = [[Person alloc] init];
__block __weak Person *weakPerson = person;
Block block = ^ {
NSLog(@"%p", weakPerson);
};
block();
}
return 0;
}
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
__Block_byref_weakPerson_0 *weakPerson; // by ref
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_weakPerson_0 *_weakPerson, int flags=0) : weakPerson(_weakPerson->__forwarding) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
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;
};
__main_block_impl_0中没有任何变化，__main_block_impl_0对weakPerson依然是强引用，但是__Block_byref_weakPerson_0中对weakPerson变为了__weak指针。
也就是说无论如何block内部中对__block修饰变量生成的结构体都是强引用，结构体内部对外部变量的引用取决于传入block内部的变量是强引用还是弱引用。
当block从堆中移除的时候。会调用dispose函数，block块中去除对__Block_byref_person_0 *person;的引用，__Block_byref_person_0结构体中也会调用dispose操作去除对Person *person;的引用。以保证结构体和结构体内部的对象可以正常释放。
MRC环境下
int main(int argc, const char * argv[]) {
@autoreleasepool {
__block Person *person = [[Person alloc] init];
Block block = [^ {
NSLog(@"%p", person);
} copy];
[person release];
block();
[block release];
}
return 0;
}
上述代码打印结果
2019-06-27 17:07:48.657846+0800 block[2383:142138] person - dealloc
2019-06-27 17:07:48.658156+0800 block[2383:142138] 0x1020001c0
尽管调用了copy操作，__block结构体不会对person产生强引用，依然是弱引用。
循环引用
循环引用会导致内存泄漏
@interface Person : NSObject
@property(nonatomic, copy) NSString *name;
@property(nonatomic, copy) void(^block)(void);
@end
@implementation Person
- (void)dealloc
{
NSLog(@"Person - dealloc");
}
@end
int main(int argc, const char * argv[]) {
@autoreleasepool {
Person *person = [[Person alloc] init];
person.name = @"jack";
person.block = ^{
NSLog(@"%@",person.name);
};
}
NSLog(@"大括号结束啦");
return 0;
}
运行代码打印结果为
2019-06-27 17:15:57.764411+0800 block[2407:144423] 大括号结束啦
可以发现大括号结束之后，person依然没有被释放，产生了循环引用。
通过一张图看一下他们之间的内存结构
Person对象和block对象相互之间产生了强引用，导致双方都不会被释放，进而造成内存泄漏。
解决循环引用问题 - ARC
首先为了能随时执行block，肯定希望person对block对强引用，而block内部对person的引用为弱引用最好。
使用__weak 和 __unsafe_unretained修饰符可以解决循环引用的问题
__weak会使block内部将指针变为弱指针。block对person对象为弱指针的话，也就不会出现相互引用而导致不会被释放了。
__weak 和 __unsafe_unretained的区别。
- __weak不会产生强引用，指向的对象销毁时，会自动将指针置为nil。因此一般通过__weak来解决问题。
- __unsafe_unretained不会产生强引用，不安全，指向的对象销毁时，指针存储的地址值不变。
使用__block也可以解决循环引用的问题。
int main(int argc, const char * argv[]) {
@autoreleasepool {
__block Person *person = [[Person alloc] init];
person.name = @"jack";
person.block = ^{
NSLog(@"%@",person.name);
person = nil;
};
}
NSLog(@"大括号结束啦");
return 0;
}
在block内部使用变量使用的其实是
__block修饰的变量生成的结构体__Block_byref_person_0内部的person对象，那么当person对象置为nil也就断开了结构体对person的强引用，那么三角的循环引用就自动断开。该释放的时候就会释放了。但是有弊端，必须执行block，并且在block内部将person对象置为nil。也就是说在block执行之前代码是因为循环引用导致内存泄漏的。
解决循环引用问题 - MRC
使用__unsafe_unretained解决。在MRC环境下不支持使用__weak，使用原理同ARC环境下相同。
使用__block也能解决循环引用的问题。因为在__block内存管理中提到过，MRC环境下，尽管调用了copy操作，__block结构体不会对person产生强引用，依然是弱引用。因此同样可以解决循环引用的问题。
__strong 和 __weak
__weak typeof(self) weakSelf = self;
person.block = ^{
__strong typeof(weakSelf) myself = weakSelf;
NSLog(@"age is %d", myself->_age);
};
在block内部重新使用__strong修饰self变量是为了在block内部有一个强指针指向weakSelf避免在block调用的时候weakSelf已经被销毁。