block是带有自动变量的匿名函数。
通过对clang转换代码以及debug分析，可以很好的了解block的整个工作机制。
概念准备
名词概念
- block
在内存中，是一个结构体的实例。可以存在数据区（_NSConcreteGlobalBlock），栈（_NSConcreteStackBlock），堆（_NSConcreteMallocBlock）。 - __block变量。
在内存中，是一个结构体实例。可以存在栈，堆。 - MRC，ARC
引用计数是否自动管理，是编译器做的工作。 - 全局变量 全局静态变量 局部静态变量 自动变量（局部变量）
- 作用域 存在
变量的作用域是变量可见和可访问的区域。存在是在内存中的生命周期。 - block语法
^ 返回类型 （参数列表） 表达式 - block变量类型
typedef void(^blk_t)(void); //blk_t是block的变量类型
void (^blk)(void) = ^{}; // blk 为block变量名 - Class id
类型定义 - 程序的内存划分
代码区 数据区（静态区、常量区） 堆 栈
源码
//源码
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
static int a = 10;// 局部静态变量
int b = 20;// 局部变量
__block int c = 30;// __block变量
id array = [[NSMutableArray alloc] init];// 对象
__block NSMutableArray *blockArray = [[NSMutableArray alloc] init];// __block对象
void (^blk)(void) = ^{
NSLog(@"%d",a);
NSLog(@"%d",b);
NSLog(@"%d",c);
NSLog(@"%@",array);
NSLog(@"%@",blockArray);
};
blk();
return 0;
}
通过 $ clang -rewrite-objc main.m 指令转换代码
// block 转换后的结构体 定义
struct __main_block_impl_0 {
struct __block_impl impl;//impl结构体
struct __main_block_desc_0* Desc;//描述结构体
int *a;// 成员变量 捕获的局部静态变量 的指针
int b;// 成员变量 捕获的局部变量 类型与block外部变量一致
id array;// 成员变量 捕获的对象 类型与block外部变量一致
__Block_byref_c_0 *c; // by ref 成员变量 捕获的__block变量
__Block_byref_blockArray_1 *blockArray; // by ref 成员变量 捕获的__block对象
// 构造函数 fp block实现的函数指针
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int *_a, int _b, id _array, __Block_byref_c_0 *_c, __Block_byref_blockArray_1 *_blockArray, int flags=0) : a(_a), b(_b), array(_array), c(_c->__forwarding), blockArray(_blockArray->__forwarding) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
// impl 结构体 定义
struct __block_impl {
void *isa; //block类型 全局block 栈block 堆block （代码debug时，通过断点，在xcode中可以看到）
int Flags; //标志信息 包含block的引用计数
int Reserved; // 保留
void *FuncPtr;// 实现的函数指针
};
// 描述 block 定义
static struct __main_block_desc_0 {
size_t reserved;// 保留
size_t Block_size;// block大小
void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*);// copy的函数指针 在block实例从栈复制到堆时，由底层代码调用，以实现对 block捕获的 __block变量实例或对象实例 的拷贝
void (*dispose)(struct __main_block_impl_0*);
// dispose的函数指针 在block实例从堆上移除时，由底层代码调用，以实现对 block捕获的 __block变量实例或对象实例 的废弃
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0), __main_block_copy_0, __main_block_dispose_0};// __main_block_desc_0_DATA 描述 block 的一个实例
// __block 变量 转换后的 结构体 定义
struct __Block_byref_c_0 {
void *__isa;// 类型
__Block_byref_c_0 *__forwarding;// __forwarding 指向__block变量 实例 在block由栈到堆拷贝时，block持有的变量，指向自身实例（在堆上） block外部变量，则指向拷贝后的实例
int __flags;// 标志
int __size;// 结构体实例大小
int c;//捕获的实际的值 类型与捕获的__block 修饰的变量类型一致
};
// __block 对象 转换后的 结构体 定义
struct __Block_byref_blockArray_1 {
void *__isa;// 类型
__Block_byref_blockArray_1 *__forwarding;// __forwarding 指向__block变量 实例 在block由栈到堆拷贝时，block持有的变量，指向自身实例（在堆上） block外部变量，则指向拷贝后的实例
int __flags;// 标志
int __size;// 结构体实例大小
void (*__Block_byref_id_object_copy)(void*, void*);// 对象拷贝的函数指针
void (*__Block_byref_id_object_dispose)(void*);// 对象dispose的函数指针
NSMutableArray *blockArray;//捕获的实际的值 类型与捕获的__block 修饰的变量类型一致
};
// block内部实现函数 参数为 block实例
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
__Block_byref_c_0 *c = __cself->c; // bound by ref
__Block_byref_blockArray_1 *blockArray = __cself->blockArray; // bound by ref
int *a = __cself->a; // bound by copy
int b = __cself->b; // bound by copy
id array = __cself->array; // bound by copy
NSLog((NSString *)&__NSConstantStringImpl__var_folders_p7_mm0wqkdd16n5qr2cb14c6ljr0000gn_T_main_4ad5e7_mi_0,(*a));
NSLog((NSString *)&__NSConstantStringImpl__var_folders_p7_mm0wqkdd16n5qr2cb14c6ljr0000gn_T_main_4ad5e7_mi_1,b);
NSLog((NSString *)&__NSConstantStringImpl__var_folders_p7_mm0wqkdd16n5qr2cb14c6ljr0000gn_T_main_4ad5e7_mi_2,(c->__forwarding->c));
NSLog((NSString *)&__NSConstantStringImpl__var_folders_p7_mm0wqkdd16n5qr2cb14c6ljr0000gn_T_main_4ad5e7_mi_3,array);
NSLog((NSString *)&__NSConstantStringImpl__var_folders_p7_mm0wqkdd16n5qr2cb14c6ljr0000gn_T_main_4ad5e7_mi_4,(blockArray->__forwarding->blockArray));
}
// block拷贝函数 参数 block实例
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->c, (void*)src->c, 8/*BLOCK_FIELD_IS_BYREF*/);// __block 变量 拷贝 BLOCK_FIELD_IS_BYREF
_Block_object_assign((void*)&dst->array, (void*)src->array, 3/*BLOCK_FIELD_IS_OBJECT*/);// 对象拷贝 BLOCK_FIELD_IS_BYREF
_Block_object_assign((void*)&dst->blockArray, (void*)src->blockArray, 8/*BLOCK_FIELD_IS_BYREF*/);}
// block dispose函数 参数 block实例
static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->c, 8/*BLOCK_FIELD_IS_BYREF*/);_Block_object_dispose((void*)src->array, 3/*BLOCK_FIELD_IS_OBJECT*/);_Block_object_dispose((void*)src->blockArray, 8/*BLOCK_FIELD_IS_BYREF*/);}
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->a, (void*)src->a, 8/*BLOCK_FIELD_IS_BYREF*/);//BLOCK_FIELD_IS_BYREF __block变量 BLOCK_FIELD_IS_OBJECT
}
// __block对象 拷贝函数
static void __Block_byref_id_object_copy_131(void *dst, void *src) {
_Block_object_assign((char*)dst + 40, *(void * *) ((char*)src + 40), 131);
}
// __block对象 dispose函数
static void __Block_byref_id_object_dispose_131(void *src) {
_Block_object_dispose(*(void * *) ((char*)src + 40), 131);
}
int main(int argc, const char * argv[]) {
static int a = 10;
int b = 20;
// __block变量 结构体构造 及赋值
__attribute__((__blocks__(byref))) __Block_byref_c_0 c = {(void*)0,(__Block_byref_c_0 *)&c, 0, sizeof(__Block_byref_c_0), 30};
id array = ((NSMutableArray *(*)(id, SEL))(void *)objc_msgSend)((id)((NSMutableArray *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("NSMutableArray"), sel_registerName("alloc")), sel_registerName("init"));
// __block对象 结构体构造 及赋值
__attribute__((__blocks__(byref))) __Block_byref_blockArray_1 blockArray = {(void*)0,(__Block_byref_blockArray_1 *)&blockArray, 33554432, sizeof(__Block_byref_blockArray_1), __Block_byref_id_object_copy_131, __Block_byref_id_object_dispose_131, ((NSMutableArray *(*)(id, SEL))(void *)objc_msgSend)((id)((NSMutableArray *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("NSMutableArray"), sel_registerName("alloc")), sel_registerName("init"))};
// block 构造及赋值
void (*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, &a, b, array, (__Block_byref_c_0 *)&c, (__Block_byref_blockArray_1 *)&blockArray, 570425344));
// block调用 通过block实现的函数指针调用
((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
return 0;
}
block内部使用变量
全局变量、全局静态变量
在变量的作用域内，可直接调用
局部静态变量
不在变量的作用域内，但是变量存放在数据区，通过捕获变量的地址，实现对变量的捕获
自动变量
不在变量的作用域内，block需要捕获变量
一般类型
捕获值（瞬时值）
对象
捕获对象的地址。若block为堆block，需要对对象持有，需要对对象有copy、dispose的操作，所以在block的copy、dispose函数中，有对对象的 _Block_object_assign、_Block_object_dispose函数调用操作。（BLOCK_FIELD_IS_OBJECT）
__block变量
不在变量的作用域内，block需要捕获变量。若block为堆block，需要对__block变量持有，需要对__block变量有copy、dispose的操作，所以在block的copy、dispose函数中，有对__block变量的 _Block_object_assign、_Block_object_dispose（与对象变量的传参不同）函数调用操作。（BLOCK_FIELD_IS_BYREF）
- __block修饰一般类型变量
__block结构体中存放变量的值（瞬时值） - __block修饰对象变量
__block结构体中存放对象的地址。若block为堆block，需要对对象持有，需要对对象有copy、dispose的操作，所以在__block结构体的__Block_byref_id_object_copy_131、__Block_byref_id_object_dispose_131函数中，有对对象的 _Block_object_assign、_Block_object_dispose函数调用操作。在__block结构体结构体实例调用copy，dispose时，会调用__block结构体结构体实例的对象成员变量调用拷贝、处理函数。
block类型
根据block使用场景不同，block会存储在内存的不同区域：数据区、栈、堆。所以有三种不同类型的block。
_NSConcreteGlobalBlock
block内使用的变量不需要持有，如全局变量，全局静态变量，局部静态变量（需要持有变量的指针），单例对象。
_NSConcreteStackBlock
block内使用自动变量（__block修饰的自动变量也是自动变量），在block实例化时，会存放在栈上（__block变量的实例也存放在栈上）。
_NSConcreteMallocBlock
对block需要持有，则需要将其放到堆中。栈上的block通过 copy操作，实现block在堆上的存储。
block拷贝
数据区block：什么也不做
堆block：引用计数增加
栈block：将block复制到堆
其中栈block拷贝过程，除了将block赋值到堆，对block结构体中对象变量和__block变量也会做_Block_object_assign处理。对于__block实例，也会被复制到堆中。无论堆中__block实例，还是栈中__block实例，__forwarding会指向堆中__block实例。这样能保证访问及操作的是同一个地址。
示例分析
#import <Foundation/Foundation.h>
// ARC环境
int main(int argc, const char * argv[]) {
int a = 10;
int b = 20;
/*
blk 默认使用 __strong修饰，在arc环境下，该赋值表达式，在编译时，block会被插入 copy调用。
block会经历以下过程：1、初始化block，block存放在栈上 2、block调用copy，block被从栈上复制到堆上，并将堆上的地址赋值给 blk变量。
*/
NSLog(@"1== %p",&b);//0x16fdff228
/*
block内部没有使用a，故不会捕获变量a。
block内部使用了b，则在block实例化时，会将外部b的值拷贝到block实例的b成员变量上。此时block 内部的b的地址与外部b的地址不同。在block赋值给blk过程中，block从栈拷贝到了堆。block的成员b现在存放在堆上。
*/
void (^blk)(void) = ^{
NSLog(@"%d",b);// 20
NSLog(@"4== %p",&b);//0x100604900
};
NSLog(@"2== %p",&b);//0x16fdff228
b = 30;
NSLog(@"3== %p",&b);//0x16fdff228
blk();
/*
变量b的地址打印分析：
1、2、3地址相同，内存在栈上
4地址与1、2、3不同，内存在堆上
*/
return 0;
}
// 以下三个示例，基本一致，只是调整 arc、mrc 或者 在arc时用__weak修饰block变量
// 比较观察，能分析出 1、__block变量是如何工作的（包括__forwarding） 2、block拷贝时从栈到堆的情景
#import <Foundation/Foundation.h>
// MRC环境
int main(int argc, const char * argv[]) {
__block int a = 20;
/*
__block修饰a，会实例化一个__block结构体实例，a的值存放在实例中。__block实例存放在栈上。
*/
NSLog(@"1== %p",&a);//0x16fdff228
/*
block内部使用了a，则在block实例化时，会将外部__block实例的地址拷贝到block的成员变量(类型为__block结构体类型)。此时block内部的与外部的__block实例是一个。
*/
void (^blk)(void) = ^{
NSLog(@"%d",a);// 30
NSLog(@"4== %p",&a);//0x16fdff228
};
NSLog(@"2== %p",&a);//0x16fdff228
a = 30;
NSLog(@"3== %p",&a);//0x16fdff228
blk();
/*
变量a的地址打印分析：（a为__block实例中的成员变量a）
1、2、3、4地址相同，内存在栈上
*/
return 0;
}
// ARC环境
int main(int argc, const char * argv[]) {
__block int a = 20;
/*
__block修饰a，会实例化一个__block结构体实例，a的值存放在实例中。__block实例存放在栈上。
*/
NSLog(@"1== %p",&a);//0x16fdff228
/*
block内部使用了a，则在block实例化时，会将外部__block实例的地址拷贝到block的成员变量(类型为__block结构体类型)。此时block内部的与外部的__block实例是一个。
*/
__weak void (^blk)(void) = ^{
NSLog(@"%d",a);// 30
NSLog(@"4== %p",&a);//0x16fdff228
};
NSLog(@"2== %p",&a);//0x16fdff228
a = 30;
NSLog(@"3== %p",&a);//0x16fdff228
blk();
/*
变量a的地址打印分析：（a为__block实例中的成员变量a）
1、2、3、4地址相同，内存在栈上
*/
return 0;
}
// ARC环境
int main(int argc, const char * argv[]) {
__block int a = 20;
/*
__block修饰a，会实例化一个__block实例，a的值存放在实例中。
__block实例存放在栈上。
*/
NSLog(@"1== %p",&a);//0x16fdff228
/*
block内部使用了a，在block实例化时，会将外部__block实例的地址拷贝到block的成员变量(类型为__block结构体类型)。此时block内部的与外部的__block实例是一个。
但是在ARC环境下，blk默认__strong修饰，在赋值过程中，编译器会为block添加copy操作。block实例从栈拷贝到堆，__block实例也从栈拷贝到堆，block实例持有堆上的__block实例，栈、堆上的__block实例上的__forwarding指向堆上的__block实例。
故，赋值完成后，会分别存在栈、堆__block实例，但是实例的__forwarding都指向堆实例。
*/
void (^blk)(void) = ^{
NSLog(@"%d",a);// 30
NSLog(@"4== %p",&a);//0x106004098
};
NSLog(@"2== %p",&a);//0x106004098
a = 30;
NSLog(@"3== %p",&a);//0x106004098
blk();
/*
a的地址打印分析：（a为__block实例的__forwarding指向的__block实例的成员变量a）
1、0x16fdff228 内存在栈上
2、3、4地址相同，内存在堆上
*/
return 0;
}
// 错误示例
int main(int argc, const char * argv[]) {
int a = 20;
void (^blk)(void) = ^{
/*
block的调用过程是转换为函数调用的，block内部使用的外部变量，相当于函数参数，不能直接给参数赋值。
*/
a = 1;// 编译错误：block内部不能给外部变量赋值 Variable is not assignable (missing __block type specifier)
};
blk();
return 0;
}
int main(int argc, const char * argv[]) {
NSMutableArray *array = [[NSMutableArray alloc] init];
void (^blk)(void) = ^{
array = [[NSMutableArray alloc] init];// 编译错误：block内部不能给外部变量赋值 Variable is not assignable (missing __block type specifier)
// 不能对array做赋值操作，但是可以对 array做可变数组的操作（array就是一个可变数组实例）
};
blk();
return 0;
}
int main(int argc, const char * argv[]) {
char c[10] = "abc";
void (^blk)(void) = ^{
NSLog(@"%c",c[2]);//编译错误 Cannot refer to declaration with an array type inside block
//内在原因：block捕获自动变量，是将值传递给block实例，c语言数组赋值本身就是c语言做了特殊的处理。 正如c语言不支持将数组直接复制给变量。可以使用指针来处理这种情况。如果想对数组进行拷贝，也需要循环遍历赋值。
};
blk();
return 0;
}
int main(int argc, const char * argv[]) {
char *c = "abc";
void (^blk)(void) = ^{
NSLog(@"%c",c[2]);//使用指针
};
blk();
return 0;
}
//block对外部对象的持有，是发生在block copy，block从栈复制到堆的过程中。
#import <Foundation/Foundation.h>
// MRC
typedef void(^blk_t)(void);
blk_t blk;
void func(void){
NSMutableArray *array = [[NSMutableArray alloc] init];
/*
mrc时，因为block实例在栈上，虽然block实例捕获了 array变量，但是当array出了它的作用域，array实例被释放，所以在调用block时，array实例不存在
*/
blk = ^{
[array addObject:@"a"];// 运行错误 Terminating app due to uncaught exception 'NSInvalidArgumentException', reason: '-[__NSStackBlock__ addObject:]: unrecognized selector sent to instance 0x16fdff1e0'
NSLog(@"%ld",[array count]);
};
}
int main(int argc, const char * argv[]) {
func();
blk();
return 0;
}
// MRC
typedef void(^blk_t)(void);
blk_t blk;
void func(void){
__block NSMutableArray *array = [[NSMutableArray alloc] init];
/*
mrc时，即使添加了 __block修饰，也只是在block及array变量中加了一层__block的实例。array变量，但是当array出了它的作用域，array实例被释放，所以在调用block时，array实例不存在。
block对外部对象的持有，是发生在block本身拷贝，从栈复制到堆的过程中。
*/
blk = ^{
[array addObject:@"a"];// 运行错误 EXC_BREAKPOINT
NSLog(@"%ld",[array count]);
};
}
int main(int argc, const char * argv[]) {
func();
blk();
return 0;
}
// __week修饰外部变量
// ARC
#import <Foundation/Foundation.h>
typedef void(^blk_t)(void);
blk_t blk;
void func(void){
NSMutableArray *array = [[NSMutableArray alloc] init];
__weak NSMutableArray *array2 = array;
/*
对象只有array一个变量持有，在array出了作用域，对象将被释放。所以blcok内部的array2指针会被置为nil
*/
blk = ^{
[array2 addObject:@"a"];
NSLog(@"%ld",[array2 count]);// 0
};
}
int main(int argc, const char * argv[]) {
func();
blk();
return 0;
}
// ARC
#import <Foundation/Foundation.h>
typedef void(^blk_t)(void);
blk_t blk;
void func(void){
NSMutableArray *array = [[NSMutableArray alloc] init];
__block NSMutableArray __weak *array2 = array;
/*
添加__block修饰，只是会改变array2的类型，但是依旧不持有对象。对象仍只有array一个变量持有，在array出了作用域，对象将被释放。所以blcok的__block类型的成员变量中的array2这个指针被置为nil。
*/
blk = ^{
[array2 addObject:@"a"];
NSLog(@"%ld",[array2 count]);// 0
};
}
int main(int argc, const char * argv[]) {
func();
blk();
return 0;
}
// __weak修饰，解决循环引用
#import <Foundation/Foundation.h>
typedef void(^blk_t)(void);
blk_t blk;
@interface MyObject : NSObject{
blk_t blk_;
}
@end
@implementation MyObject
- (instancetype)init{
self = [super init];
if(self){
id __weak weakSelf = self;
/*
blk_是self的成员变量，self持有blk。block内部使用self，这样会引起循环引用。需要打破循环引用。在外部，用__weak修饰self，这样blk_不会再持有self。
因为blk_是self的成员变量，所以self的生命周期一定比blk_长。这种情况使用__weak修饰外部变量，是没有问题的。
*/
blk_ = ^{
NSLog(@"%@",weakSelf);
};
}
return self;
}
- (void)dealloc{
NSLog(@"dealloc");
}
@end
int main(int argc, const char * argv[]) {
@autoreleasepool {
MyObject *obj = [[MyObject alloc] init];
}
NSLog(@"gg");
return 0;
}
// __block修饰，解决循环引用
#import <Foundation/Foundation.h>
typedef void(^blk_t)(void);
blk_t blk;
@interface MyObject : NSObject{
blk_t blk_;
}
@end
@implementation MyObject
- (instancetype)init{
self = [super init];
if(self){
__block id blockSelf = self;
/*
self持有blk_;blk_持有__block变量，__block变量持有self。
在block调用时，将__block变量置nil，打破__block变量持有self。
*/
blk_ = ^{
NSLog(@"%@",blockSelf);
blockSelf = nil;
};
}
return self;
}
- (void)execBlock{
blk_();
}
- (void)dealloc{
NSLog(@"dealloc");
}
@end
int main(int argc, const char * argv[]) {
@autoreleasepool {
MyObject *obj = [[MyObject alloc] init];
[obj execBlock];
}
NSLog(@"gg");
return 0;
}
综述
- block是什么及block如何存放？
block是带有自动变量的匿名函数。是一个结构体。block可能存放在数据区、栈、堆。block内部不使用自动变量，block存放在数据区。block内部使用自动变量，实例化的block为栈block。栈block通过copy的操作，从栈复制到堆，形成堆block。 - __block修饰变量是怎么回事？
__block修饰变量，会将变量转换成一个结构体，该结构体以变量的类型将变量的值存放在其成员变量中。该结构体体中存在一个以该结构体类型为类型的成员变量__forwarding。如果变量为id类型或者对象类型，还会持有控制变量copy dispose的函数指针。该结构体进行copy dispose操作时，会调用copy dispose的函数。 - block怎么捕获内部使用的外部变量？
block是一个结构体，block捕获的变量以成员变量的形式存放在结构体中。全局变量，全局静态变量，在其作用域内，不需要block捕获；局部静态变量，不在其作用域内，但是局部静态变量存在，block捕获其地址；block会捕获自动变量，并将其以外部的类型存放在成员变量中。 - block与捕获变量的关系？
block捕获的变量如果是__block修饰的变量或者id类型、对象类型变量，在block从栈复制到堆时，需要对这些变量持有；当block被释放时，需要对这些变量做处理。这种情况下，block的des结构体中会存在copy，dispose的函数指针成员变量。copy函数中是对__block修饰的变量或者id类型、对象类型变量的拷贝操作，dispose函数中是对__block修饰的变量或者id类型、对象类型变量的dispose操作。 - block循环引用的情况及如何解决？
对象持有block，block持有对象（直接持有或者通过__block结构体间接持有），都会引起循环引用的发生。需要打破引用环：1、在外部使用__weak修饰外部变量，打断block对对象的持有。这种情况下，因为block不持有对象，所以在block调用时可能对象已经销毁，或者block执行过程中对象被销毁（这种情况可以在block内部通过将__strong变量指向对象，实现对对象在block内部的持有）。2、在外部用__block修饰外部变量，在block内部，使用完对象，将变量置nil，打破block对对象的持有。这种情况下，只有调用了block，block才不持有对象，不然会造成内存泄漏。 - block从栈复制到堆的过程及发生情景。
栈block调用copy操作时，block会从栈复制到堆，如果block中有copy函数指针，会调用copy函数。block从堆上释放时，会调用dispose函数。
发生情景：
1、栈block主动调用copy时。
2、arc时，栈block作为函数或者方法返回值。mrc,编译错误， arc，用__weak变量接收，block被释放
3、栈block赋值给__strong修饰的id类型或block类型变量时。
4、cocoa框架的含有usingBlock方法名的方法中传递栈block（方法内部会做copy）；GCD的api中传递栈block（方法内部会做copy）。
参考
《Objective-C高级编程 iOS与OS X多线程和内存管理》
