Block是iOS开发中一种比较特殊的数据结构，它可以保存一段代码，在合适的地方再调用，具有语法简介、回调方便、编程思路清晰、执行效率高等优点，受到众多猿猿的喜爱。但是Block在使用过程中，如果对Block理解不深刻，容易出现Cycle Retain的问题。本文主要从ARC模式下解析一下Block的底层实现，以及Block的三种类型（栈、堆、全局）的区别。
一、Block定义
1. Block 定义及使用
返回值类型 (^block变量名)(形参列表) = ^返回值类型 (形参列表) {
};
// 调用Block保存的代码
block变量名(实参);
2. 项目中使用格式
在项目中，通常会重新定义block的类型的别名，然后用别名来定义block的类型
// 定义block类型
typedef void (^Block)(int);
// 定义block
Block block = ^(int a){};
// 调用block
block(3);
二、Block底层实现
block的底层实现是结构体，和类的底层实现类似，都有isa指针，可以把block当成是一个对象。下面通过创建一个控制台程序，来窥探block的底层实现
1. block内存结构
block 的内存结构图
Block_layout结构体成员含义如下：
- isa: 指向所属类的指针，也就是block的类型
- flags: 标志变量，在实现block的内部操作时会用到
- Reserved: 保留变量
- invoke: block执行时调用的函数指针，block内部的执行代码都在这个函数中
- descriptor: block的详细描述，包含 copy/dispose 函数，处理block引用外部变量时使用
- variables: block范围外的变量，如果block没有调用任何外部变量，该变量就不存在
Block_descriptor结构体成员含义如下：
- reserved: 保留变量
- size: block的内存大小
- copy: 拷贝block中被
__block修饰的外部变量 - dispose: 和
copy方法配置应用，用来释放资源
具体实现代码如下（代码来自Block_private.h）:
enum {
BLOCK_REFCOUNT_MASK = (0xffff),
BLOCK_NEEDS_FREE = (1 << 24),
BLOCK_HAS_COPY_DISPOSE = (1 << 25),
BLOCK_HAS_CTOR = (1 << 26), /* Helpers have C++ code. */
BLOCK_IS_GC = (1 << 27),
BLOCK_IS_GLOBAL = (1 << 28),
BLOCK_HAS_DESCRIPTOR = (1 << 29)
};
/* Revised new layout. */
struct Block_descriptor {
unsigned long int reserved;
unsigned long int size;
void (*copy)(void *dst, void *src);
void (*dispose)(void *);
};
struct Block_layout {
void *isa;
int flags;
int reserved;
void (*invoke)(void *, ...);
struct Block_descriptor *descriptor;
/* Imported variables. */
};
2. 创建block
int main(int argc, const char * argv[]) {
@autoreleasepool {
// 最简block
^{ };
}
return 0;
}
3. 转换结构
利用 clang 把 *.m 的文件转换为 *.cpp 文件，就可以看到 block 的底层实现了
$ clang -rewrite-objc main.m
转换后的代码：
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;
__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;
}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
}
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;
(void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA);
}
return 0;
}
从代码中可以看出，__main_block_impl_0就是block的C++实现（最后面的_0代表是main中的第几个block），__main_block_func_0是block的代码块，__main_block_desc_0是block的描述，__block_impl是block的定义。
__block_impl成员含义如下：
- isa: 指向所属类的指针，也就是block的类型
- flags，标志变量，在实现block的内部操作时会用到
- Reserved，保留变量
- FuncPtr，block执行时调用的函数指针
__main_block_impl_0解释如下：
- impl: block对象
- Desc: block对象的描述
其中，__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) 这是显式构造函数，flags的默认值为0，函数体如下：
__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_0的isa指针指向了_NSConcreteStackBlock，所有的局部block都是在栈上门创建
- 从main函数中看， __main_block_impl_0的FuncPtr指向了函数__main_block_func_0
- __main_block_impl_0的Desc也指向了定义__main_block_desc_0时就创建的__main_block_desc_0_DATA，其中Block_size记录了block结构体大小等信息
__main_block_desc_0成员含义如下：
- reserved: 保留变量
- Block_size: block内存大小，sizeof(struct __main_block_impl_0)
三、Block类型
block有三种类型：
- _NSConcreteGlobalBlock: 存储在全局数据区
- _NSConcreteStackBlock: 存储在栈区
- _NSConcreteMallocBlock: 存储在堆区
APUE的进程虚拟内存段分布图如下：
其中，_NSConcreteGlobalBlock 和 _NSConcreteStackBlock 可以由程序创建，而 _NSConcreteMallocBlock 则无法由程序创建，只能由 _NSConcreteStackBlock 通过拷贝生成。
1. 全局block 和 栈block
测试代码如下：
void (^globalBlock)() = ^{
};
int main(int argc, const char * argv[]) {
@autoreleasepool {
void (^stackBlock1)() = ^{
};
}
return 0;
}
clang转换后的代码如下：
// globalBlock
struct __globalBlock_block_impl_0 {
...
__globalBlock_block_impl_0(void *fp, struct __globalBlock_block_desc_0 *desc, int flags=0) {
impl.isa = &_NSConcreteGlobalBlock;
...
}
};
...
// stackBlock
struct __main_block_impl_0 {
...
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) {
impl.isa = &_NSConcreteStackBlock;
...
}
};
...
int main(int argc, const char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
void (*stackBlock)() = (void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA);
}
return 0;
}
可以看出， globalBlock 的 isa 指向了 _NSConcreteGlobalBlock，即在全局区域创建，编译时其具体代码在代码段中，block变量则存储在全局数据区；而stackBlock 的 isa 则指向了 _NSConcreteStackBlock，表明在栈区创建。
2. 捕获外部参数对栈区block结构的影响
由于堆区 block 是由栈区 block 转化而成， 所以下面主要分析栈区 block 如何转化为堆区 block。
捕获局部非静态变量
代码：
int a = 0;
^{a;};
转化后：
struct __Person__test_block_impl_0 {
...
int a;
// a(_a)是构造函数的参数列表初始化形式，相当于a = _a。从_I_Person_test看，传入的就是a
__Person__test_block_impl_0(void *fp, struct __Person__test_block_desc_0 *desc, int _a, int flags=0) : a(_a) {
impl.isa = &_NSConcreteStackBlock;
...
}
};
static void _I_Person_test(Person * self, SEL _cmd) {
int a;
(void (*)())&__Person__test_block_impl_0((void *)__Person__test_block_func_0, &__Person__test_block_desc_0_DATA, a);
}
可以看到，block 对于栈区变量的引用只是值传递，由于 block 内部变量 a 和 外部变量 a 不在同一个作用域，所以在 block 内部不能把变量 a 作为左值(left-value)，因为赋值没有意义。所以，如果出现如下代码，编译器会提示错误：
a = 10;
捕获局部静态变量
代码：
static int a;
^{
a = 10;
};
转换后：
struct __Person__test_block_impl_0 {
...
int *a;
__Person__test_block_impl_0(void *fp, struct __Person__test_block_desc_0 *desc, int *_a, int flags=0) : a(_a) {
impl.isa = &_NSConcreteStackBlock;
...
}
};
static void __Person__test_block_func_0(struct __Person__test_block_impl_0 *__cself) {
int *a = __cself->a; // bound by copy
// 这里通过局部静态变量a的地址来对其进行修改
(*a) = 10;
}
static void _I_Person_test(Person * self, SEL _cmd) {
static int a;
// 传入a的地址
(void (*)())&__Person__test_block_impl_0((void *)__Person__test_block_func_0, &__Person__test_block_desc_0_DATA, &a);
}
由于局部静态变量也存储在静态数据区，和程序拥有一样的生命周期，但是其作用范围局限在定义它的函数中，所有在block里是通过地址来访问。
捕获全局变量
代码：
// 全局静态
static int a;
// 全局
int b;
- (void)test
{
^{
a = 10;
b = 10;
};
}
转换后：
static int a;
int b;
static void __Person__test_block_func_0(struct __Person__test_block_impl_0 *__cself) {
a = 10;
b = 10;
}
static void _I_Person_test(Person * self, SEL _cmd) {
(void (*)())&__Person__test_block_impl_0((void *)__Person__test_block_func_0, &__Person__test_block_desc_0_DATA);
}
可以看出，因为全局变量都在静态数据区，在程序结束前不会被销毁，所以block直接访问了对应的变量，而没有在Persontest_block_impl_0结构体中给变量预留位置。
捕获对象的变量
代码：
@interface Person()
{
int _a;
}
@end
@implementation Person
- (void)test
{
void (^block)() = ^{
_a;
};
}
@end
转换后：
struct __Person__test_block_impl_0 {
...
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;
...
}
};
static void __Person__test_block_func_0(struct __Person__test_block_impl_0 *__cself) {
Person *self = __cself->self; // bound by copy
(*(int *)((char *)self + OBJC_IVAR_$_Person$_a));
}
static void _I_Person_test(Person * self, SEL _cmd) {
void (*block)() = ((void (*)())&__Person__test_block_impl_0((void *)__Person__test_block_func_0, &__Person__test_block_desc_0_DATA, self, 570425344));
}
可以看到，即使 block只是引用对象的变量，但是底层依然引用的是对象本身 self，这和直接使用 self.a产生的循环引用的问题是一样的。所以，要在 block 内使用对象的弱引用，即可解决循环引用的问题。并且，对变量a的访问也是通过 self的地址加 a的偏移量的形式。
捕获__block修饰的基本变量
代码：
__block int a;
^{
a = 10;
};
转换后：
struct __Block_byref_a_0 {
void *__isa;
__Block_byref_a_0 *__forwarding;
int __flags;
int __size;
int a;
};
struct __main_block_impl_0 {
...
__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;
...
}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
__Block_byref_a_0 *a = __cself->a; // bound by ref
(a->__forwarding->a) = 10;
}
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*/);}
static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->a, 8/*BLOCK_FIELD_IS_BYREF*/);}
static struct __main_block_desc_0 {
...
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_a_0 a = {(void*)0,(__Block_byref_a_0 *)&a, 0, sizeof(__Block_byref_a_0), 1};
((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_a_0 *)&a, 570425344));
}
return 0;
}
可以看到，被__block修饰的变量被封装成了一个对象，类型为__Block_byref_a_0，然后把&a作为参数传给了block。
__Block_byref_a_0 成员含义如下：
- __isa: 指向所属类的指针，被初始化为
(void*)0 - __forwarding: 指向对象在堆中的拷贝
- __flags: 标志变量，在实现block的内部操作时会用到
- __size: 对象的内存大小
- a: 原始类型的变量
其中，isa、__flags 和 __size 的含义和之前类似，而 __forwarding 是用来指向对象在堆中的拷贝，runtime.c 里有源码说明：
static void _Block_byref_assign_copy(void *dest, const void *arg, const int flags) {
...
struct Block_byref *copy = (struct Block_byref *)_Block_allocator(src->size, false, isWeak);
copy->flags = src->flags | _Byref_flag_initial_value; // non-GC one for caller, one for stack
// 堆中拷贝的forwarding指向它自己
copy->forwarding = copy; // patch heap copy to point to itself (skip write-barrier)
// 栈中的forwarding指向堆中的拷贝
src->forwarding = copy; // patch stack to point to heap copy
copy->size = src->size;
...
}
这样做是为了保证在 block内 或 block 变量后面对变量a的访问，都是直接访问堆内的对象，而不上栈上的变量。同时，在 block 拷贝到堆内时，它所捕获的由 __block 修饰的局部基本类型也会被拷贝到堆内（拷贝的是封装后的对象），从而会有 copy 和 dispose处理函数。
Block_byref的结构定义在 Block_private.h 文件里有介绍:
struct Block_byref {
void *isa;
struct Block_byref *forwarding;
int flags; /* refcount; */
int size;
void (*byref_keep)(struct Block_byref *dst, struct Block_byref *src);
void (*byref_destroy)(struct Block_byref *);
/* long shared[0]; */
};
// flags/_flags类型
enum {
/* See function implementation for a more complete description of these fields and combinations */
// 是一个对象
BLOCK_FIELD_IS_OBJECT = 3, /* id, NSObject, __attribute__((NSObject)), block, ... */
// 是一个block
BLOCK_FIELD_IS_BLOCK = 7, /* a block variable */
// 被__block修饰的变量
BLOCK_FIELD_IS_BYREF = 8, /* the on stack structure holding the __block variable */
// 被__weak修饰的变量，只能被辅助copy函数使用
BLOCK_FIELD_IS_WEAK = 16, /* declared __weak, only used in byref copy helpers */
// block辅助函数调用（告诉内部实现不要进行retain或者copy）
BLOCK_BYREF_CALLER = 128 /* called from __block (byref) copy/dispose support routines. */
};
可以看到，Block_byref 和 __Block_byref_a_0 的前4个成员类型相同，可以互相转化。
** copy 函数
copy 的实现函数是 _Block_object_assign，它根据对象的 flags 来判断是否需要拷贝，或者只是赋值，函数实现在 runtime.c 里：
// _Block_object_assign源码
void _Block_object_assign(void *destAddr, const void *object, const int flags) {
...
else if ((flags & BLOCK_FIELD_IS_BYREF) == BLOCK_FIELD_IS_BYREF) {
// copying a __block reference from the stack Block to the heap
// flags will indicate if it holds a __weak reference and needs a special isa
_Block_byref_assign_copy(destAddr, object, flags);
}
...
}
// _Block_byref_assign_copy源码
static void _Block_byref_assign_copy(void *dest, const void *arg, const int flags) {
// 这里因为前面4个成员的内存分布一样，所以直接转换后，使用Block_byref的成员变量名，能访问到__Block_byref_a_0的前面4个成员
struct Block_byref **destp = (struct Block_byref **)dest;
struct Block_byref *src = (struct Block_byref *)arg;
...
else if ((src->forwarding->flags & BLOCK_REFCOUNT_MASK) == 0) {
// 从main函数对__Block_byref_a_0的初始化，可以看到初始化时将flags赋值为0
// 这里表示第一次拷贝，会进行复制操作，并修改原来flags的值
// static int _Byref_flag_initial_value = BLOCK_NEEDS_FREE | 2;
// 可以看出，复制后，会并入BLOCK_NEEDS_FREE，后面的2是block的初始引用计数
...
copy->flags = src->flags | _Byref_flag_initial_value;
...
}
// 已经拷贝到堆了，只增加引用计数
else if ((src->forwarding->flags & BLOCK_NEEDS_FREE) == BLOCK_NEEDS_FREE) {
latching_incr_int(&src->forwarding->flags);
}
// 普通的赋值，里面最底层就*destptr = value;这句表达式
_Block_assign(src->forwarding, (void **)destp);
}
主要操作都在代码注释中了，总体来说，__block修饰的基本类型会被包装为对象，并且只在最初block拷贝时复制一次，后面的拷贝只会增加这个捕获变量的引用计数。
** dispose 函数
dispose 的实现函数是 _Block_object_dispose，代码依然可以在 runtime.c 里：
void _Block_object_dispose(const void *object, const int flags) {
//printf("_Block_object_dispose(%p, %x)
", object, flags);
if (flags & BLOCK_FIELD_IS_BYREF) {
// get rid of the __block data structure held in a Block
_Block_byref_release(object);
}
...
}
// Old compiler SPI
static void _Block_byref_release(const void *arg) {
struct Block_byref *shared_struct = (struct Block_byref *)arg;
int refcount;
// dereference the forwarding pointer since the compiler isn't doing this anymore (ever?)
shared_struct = shared_struct->forwarding;
...
refcount = shared_struct->flags & BLOCK_REFCOUNT_MASK;
...
else if ((latching_decr_int(&shared_struct->flags) & BLOCK_REFCOUNT_MASK) == 0) {
...
}
}
可以看到，被__block修改的变量，释放时要 latching_decr_int减引用计数，直到计数为0，就释放改对象；而普通的对象、block，就直接释放销毁。
捕获没有__block修饰的对象
代码：
NSObject *a = [[NSObject alloc] init];
Block block = ^ {
a;
};
转换后部分结果如下：
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
NSObject *a = __cself->a; // bound by copy
a;
}
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, 3/*BLOCK_FIELD_IS_OBJECT*/);}
static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->a, 3/*BLOCK_FIELD_IS_OBJECT*/);}
int main(int argc, const char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
...
Block block = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, a, 570425344));
}
return 0;
}
对象在没有__block修饰时，并没有产生__Block_byref_a_0结构体，只是将标志位修改为BLOCK_FIELD_IS_OBJECT。而在_Block_object_assign中对应的判断分支代码如下:
...
else if ((flags & BLOCK_FIELD_IS_OBJECT) == BLOCK_FIELD_IS_OBJECT) {
_Block_retain_object(object);
_Block_assign((void *)object, destAddr);
}
...
可以看到，block复制时，会retain捕捉对象，以增加其引用计数。
捕获有__block修饰的对象
代码：
__block NSObject *a = [[NSObject alloc] init];
Block block = ^ {
a;
};
转化后部分结果如下：
struct __Block_byref_a_0 {
void *__isa;
__Block_byref_a_0 *__forwarding;
int __flags;
int __size;
void (*__Block_byref_id_object_copy)(void*, void*);
void (*__Block_byref_id_object_dispose)(void*);
NSObject *a;
};
int main(int argc, const char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
attribute__((__blocks__(byref))) __Block_byref_a_0 a = {(void*)0,(__Block_byref_a_0 *)&a, 33554432, sizeof(__Block_byref_a_0), __Block_byref_id_object_copy_131, __Block_byref_id_object_dispose_131,....};
Block block = (void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_a_0 *)&a, 570425344);
}
// 以下的40表示__Block_byref_a_0对象a的位移（4个指针(32字节)＋2个int变量(8字节)＝40字节）
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_a_0外，还另外增加了两个辅助函数__Block_byref_id_object_copy、__Block_byref_id_object_dispose,以实现对对象内存的管理。其中两者的最后一个参数131表示BLOCK_BYREF_CALLER|BLOCK_FIELD_IS_OBJECT，BLOCK_BYREF_CALLER表示在内部实现中不对a对象进行retain或copy；以下为_Block_object_assign函数的部分代码：
if ((flags & BLOCK_BYREF_CALLER) == BLOCK_BYREF_CALLER) {
...
else {
// do *not* retain or *copy* __block variables whatever they are
_Block_assign((void *)object, destAddr);
}
}
_Block_byref_assign_copy函数的以下代码会对上面的辅助函数__Block_byref_id_object_copy_131进行调用；570425344表示BLOCK_HAS_COPY_DISPOSE | BLOCK_HAS_DESCRIPTOR，即（1<<25 | 1<<29），_Block_byref_assign_copy函数的部分代码:
if (src->flags & BLOCK_HAS_COPY_DISPOSE) {
// Trust copy helper to copy everything of interest
// If more than one field shows up in a byref block this is wrong XXX
copy->byref_keep = src->byref_keep;
copy->byref_destroy = src->byref_destroy;
(*src->byref_keep)(copy, src);
}
四、ARC中block的工作特点
在ARC模式下，在栈间传递block时，不需要手动copy栈中的block，即可让block正常工作。主要原因是ARC对栈中的block自动执行了copy，将_NSConcreteStackBlock类型的block转换成了_NSConcreteMallocBlock类型的block。
1. block，非函数参数
代码：
int i = 10;
void (^block)() = ^{i;};
__unsafe_unretained void (^weakBlock)() = ^{i;};
void (^stackBlock)() = ^{};
NSLog(@"%@", ^{i;});
NSLog(@"%@", block);
NSLog(@"%@", weakBlock);
NSLog(@"%@", stackBlock);
/* ARC
<__NSStackBlock__: 0x7fff5fbff708>
<__NSMallocBlock__: 0x100300000>
<__NSStackBlock__: 0x7fff5fbff738>
<__NSGlobalBlock__: 0x100001110>
*/
/* MRC
<__NSStackBlock__: 0x7fff5fbff6e0>
<__NSStackBlock__: 0x7fff5fbff740>
<__NSStackBlock__: 0x7fff5fbff710>
<__NSGlobalBlock__: 0x1000010e0>*/
从打印结果可以看出，ARC模式下，block 只有引用了外部的变量，并且被强引用，才会被拷贝到堆上；只引用了外部的变量，或者被弱引用都只在栈上创建；如果没有引用外部变量，无论是否被强引用，都会被转换为全局 block，也就是说，在编译时，这个block的所有内容已经在代码段中生成了。
2. block，作为参数传递
代码
typedef void (^Block)();
NSMutableArray *arrays;
void testBlock() {
int a = 5;
[arrays addObject:^{
NSLog(@"%d", a);
}];
}
int main(int argc, const char * argv[]) {
@autoreleasepool {
// insert code here..
arrays = @[].mutableCopy;
testBlock();
Block block = [arrays firstObject];
NSLog(@"%@", block);
/* ARC
* <__NSMallocBlock__: 0x1006034c0>
*/
/* MRC
* 崩溃，野指针
*/
}
return 0;
}
可以看出，ARC模式下，栈区的block 被拷贝到了堆区，在 testBlock 函数结束后依然可以访问；而 MRC模式下，由于我们没有手动执行[block copy]来将block拷贝到堆区，随着函数生命周期结束，block被销毁，访问时出现野指针错误，但是如果把testBlock函数中的block打印语句删掉:
NSLog(@"%d", a);
那么，block就变为全局的，在MRC模式下，再次访问不会出错。
参考文章
http://www.jianshu.com/p/51d04b7639f1
http://www.jianshu.com/p/aff2cad778c0
http://www.galloway.me.uk/2013/05/a-look-inside-blocks-episode-3-block-copy/