平时的开发中基本每天都要使用到block，其实对于block的底层实现并不是很清楚，今天主要写下block的本质。
主要分为以下几个方面
* block的底层实现
* 捕获变量
* block类型
一. block的底层实现
代码如下
int main(int argc, const char * argv[]) {
@autoreleasepool {
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);
}
return 0;
}
为了探索Block的底层结构，我们将main.m文件转化为C++的源码、我们打开命令行。cd到包含main.m文件的文件夹，然后输入:clang -rewrite-objc main.m，这个时候在该文件夹的目录下会生成main.cpp文件。找到main函数
//定义block __main_block_impl_0实际是调用的结构体的构造函数。将__main_block_func_0函数指针，和__main_block_desc_0_DATA描述传递给结构体，block地址->__main_block_impl_0结构体地址
void (*block)(int, int) = ((void (*)(int, int))&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, age));
// block的调用
((void (*)(__block_impl *, int, int))((__block_impl *)block)->FuncPtr)((__block_impl *)block, 10, 10);
这两行代码非常长，看起来简直吃力，下面进行简化代码
变量前面的()一般是做强制类型转换的，比如在调用block这一行，block前面有一个()是(__block_impl *)，这就是进行了一个强制类型转换，将其转换为一个_block_impl类型的结构体指针，那像这样的强制类型转换非常妨碍我们理解代码，我们可以暂时将这些强制类型转换去掉，这样可以帮助我们理解代码。
简化后的代码如下：
//定义block
void (*block)(void) = &__main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA);
//调用block
block->FuncPtr(block);
先看定义block
void (*block)(void) = &__main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA);
这句代码的意思是调用_main_block_impl_0这个函数，给这个函数传进两个参数_main_block_func_0和&_main_block_desc_0_DATA,然后得到这个函数的返回值，取函数返回值的地址，赋值给block这个指针。
分析下_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;
};
再来看下__main_block_desc_0结构体
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)};
这是一个C++的结构体。而且在这个结构体内还包含一个函数，这个函数的函数名和结构体名称一致，这在C语言中是没有的，这是C++特有的。
在C++的结构体包含的函数称为结构体的构造函数，它就相当于是OC中的init方法，用来初始化结构体。OC中的init方法返回的是对象本身，C++的结构体中的构造方法返回的也是结构体对象。
那么再分析下__main_block_impl_0这个结构体思路就很清晰了，__main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA);返回的就是_main_block_impl_0这个结构体对象，然后取结构体对象的地址赋值给block指针。换句话说，block指向的就是初始化后的_main_block_impl_0结构体对象。
_main_block_impl_0这个结构体对象的地址从哪来的呢？会不会是也是其他函数的地址呢？ 我们再看一下初始化_main_block_impl_0结构体传进去的参数：
第一个参数 _main_block_func_0
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);
}
这个函数其实就是把我们Block中要执行的代码封装到这个函数内部了。我们可以看到这个函数内部有四行打印的代码就是OC block那几个NSLog。
把这个函数指针传给_main_block_impl_0的构造函数的第一个参数，然后用这个函数指针去初始化_main_block_impl_0这个结构体的第一个成员变量impl的成员变量FuncPtr。也就是说FuncPtr这个指针指向_main_block_func_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)};
在结构体的构造函数中，0赋值给了reserved，sizeof(struct __main_block_impl_0)是赋值给了Block_size，可以看出这个结构体存放的是_main_block_impl_0这个结构体的信息。在_main_block_impl_0的构造函数中我们可以看到，_main_block_desc_0这个结构体的地址被赋值给了_main_block_impl_0的第二个成员变量Desc这个结构体指针。也就是说Desc这个结构体指针指向_main_block_desc_0_DATA这个结构体。
所以第一句定义block的代码
void (*block)(void) = &__main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA);
总结起来就是：
1.创建一个函数_main_block_func_0,这个函数的作用就是将我们block中要执行的代码封装到函数内部，方便调用。
2.创建一个结构体_main_block_desc_0,这个结构体中主要包含_main_block_impl_0这个结构体占用的存储空间大小等信息。
3.将1中创建的_main_block_func_0这个函数的地址，和2中创建的_main_block_desc_0这个结构体的地址传给_main_block_impl_0的构造函数。
4.利用_main_block_func_0初始化_main_block_impl_0结构体的第一个成员变量impl的成员变量FuncPtr。这样_main_bck_impl_0这个结构体也就得到了block中那个代码块的地址。
5.利用_mian_block_desc_0_DATA去初始化_mian_block_impl_0的第二个成员变量Desc。
以上过程总结图示：
block底层结构图示：
调用block：
((void (*)(__block_impl *, int, int))((__block_impl *)block)->FuncPtr)((__block_impl *)block, 10, 10);
分析
((__block_impl *)block)->FuncPtr
这行代码是将block转化成(__block_impl *)类型再调用FuncPtr，得到之前存储block中的代码。为什么block可以直接转化成(__block_impl *)这种类型呢？因为block指向的是_main_block_impl_0这个结构体的首地址，而_main_block_impl_0的第一个成员变量是struct __block_impl impl;，所以impl和_main_block_impl_0的首地址是一样的，因此指向_main_block_impl_0的首地址的指针也就可以被强制转换为指向impl的首地址的指针。
之前说过，FuncPtr这个指针在构造函数中是被初始化为指向_mian_block_func_0这个函数的地址。因此通过block->FuncPtr调用也就获取了_main_block_func_0这个函数的地址，然后对_main_block_func_0进行调用，也就是执行block中的代码了。这中间block又被当做参数传进了_main_block_func_0这个函数。
参数
((__block_impl *)block, 10, 10)
二. 捕获变量
捕获变量又分为三种：捕获-auto变量| 捕获-static变量 | 捕获-全局变量
1.捕获-auto变量
auto变量是声明在函数内部的变量，比如int a = 0;这句代码声明在函数内部，那a就是auto变量，等价于auto int a = 0;auto变量时分配在栈区，当超出作用域时，其占用的内存会被系统自动销毁并生成。下面看一段代码：
int a = 10;
void (^block)(void) = ^{
NSLog(@"%d", a);
};
a = 20;
block();
输出：10
自动变量a的值明明已经变为了20，为什么输出结果还是10呢？我们把这段代码转化为C++的源码看看。
int main(int argc, char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
int a = 10;
void (*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, a));
a = 20;
((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
return 0;
}
}
对比一下上面分析的没有捕获自动变量的源代码，我们发现这里_main_block_impl_0中传入的参数多了一个a。然后我们往上翻看看_main_block_impl_0的结构：
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
int a; //这里也多了一个a
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _a, int flags=0) : a(_a) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
在_main_block_impl_0这个结构体中我们发现多了一个int类型的成员变量a，在结构体的构造函数中多了一个参数int _a，并且用这个int _a去初始化成员变量a。所以在void (*block)(void) = &__main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA, a);中传入了自动变量a用来初始化_main_block_impl_0的成员变量a。那这个时候_main_block_impl_0的成员变量a就被赋值为10了。由于上面这一步是值传递，所以当执行a = 20时，_main_block_impl_0结构体的成员变量a的值是不会随之改变的，仍然是10。然后我们再来看一下_main_block_func_0的结构有何变化：
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
int a = __cself->a; // bound by copy
NSLog((NSString *)&__NSConstantStringImpl__var_folders_74_wk04zv690mz36wn0g18r5nxm0000gn_T_main_fb5f0d_mi_0, a);
}
可以看到，通过传入的_main_block_impl_0这个结构体获得其成员变量a的值。
2.捕获-static变量
上面讲的捕获的是自动变量，在函数内部声明的变量默认为自动变量，即默认用auto修饰。那么如果在函数内部声明的变量用static修饰，又会带来哪些不同呢？static变量和auto变量的不同之处在于变量的内存的回收时机。auto变量在其作用域结束时就会被系统自动回收，而static变量在变量的作用域结束时并不会被系统自动回收。
先看一段代码：
static int a = 10;
void (^block)(void) = ^{
NSLog(@"%d", a);
};
a = 20;
block();
输出：20
结果是20，这个和2中的打印结果不一样，为什么局部变量从auto变成了static结果会不一样呢？我们还是从源码来分析：
int main(int argc, char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
static int a = 10;
void (*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, &a));
a = 20;
((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
return 0;
}
}
和2不一样的是，这里传入_main_block_impl_0的是&a，
也即是a这个变量的地址值。那么这个&a是赋值给谁了呢？我们上翻找到_main_block_impl_0的结构：
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
int *a;
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int *_a, int flags=0) : a(_a) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
这里我们可以看到结构体多了一个指针类型的成员变量int *a,然后在构造函数中，将传递过来的&a，赋值给这个指针变量。也就是说，在_main_block_impl_0这个结构体中多了一个成员变量，这个成员变量是指针，指向a这个变量。所以当a变量的值发生变化时，能够得到最新的值。
3.捕获-全局变量
2和3分析了两种类型的局部变量，auto局部变量和static局部变量。这一部分则分析全局变量。全局变量会不会像局部变量一样被block所捕获呢？我们还是看一下实例：
int height = 10;
static int weight = 20;
int main(int argc, char * argv[]) {
@autoreleasepool {
void (^block)(void) = ^{
NSLog(@"%d %d", height, weight);
};
height = 30;
weight = 40;
block();
return 0;
}
}
打印：30 40
查看源码
int height = 10;
static int weight = 20;
int main(int argc, char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
void (*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
height = 30;
weight = 40;
((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
return 0;
}
}
这里我们可以看到，height和weight这两个全局变量没有作为参数传入_main_block_impl_0中去。然后我们再查看一下_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_0中并没有增加成员变量。然后我们再看_main_block_func_0的结构：
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
NSLog((NSString *)&__NSConstantStringImpl__var_folders_74_wk04zv690mz36wn0g18r5nxm0000gn_T_main_46c51b_mi_0, height, weight);
}
可以看到，这个地方在调用的时候是直接调用的全局变量height和weight, 所以block并不会捕获全局变量
总结：
思考： 为什么对于不同类型的变量，block的处理方式不同呢？
这是由变量的生命周期决定的。对于auto变量，当作用域结束时，会被系统自动回收，而block很可能是在超出auto变量作用域的时候去执行，如果之前没有捕获auto变量，那么后面执行的时候，auto变量已经被回收了，得不到正确的值。对于static局部变量，它的生命周期不会因为作用域结束而结束，所以block只需要捕获这个变量的地址，在执行的时候通过这个地址去获取变量的值，这样可以获得变量的最新的值。而对于全局变量，在任何位置都可以直接读取变量的值。
思考： 为什么对于auto变量block捕获的是数值而 对于static局部变量捕获的是地址？
还是由变量的生命周期决定的，对于auto变量，当作用域结束时，会被系统自动回收，地址就会变成空的，造成坏地址访问。对于static局部变量，它的生命周期不会因为作用域结束而结束，所以block只需要捕获这个变量的地址，在执行的时候通过这个地址去获取变量的值。
思考： static局部变量生命周期什么时候结束？
说明：
在局部变量的说明前再加上static说明符就构成静态局部变量。例如：static int a,b; static float array[5]={1,2,3,4,5}；
静态局部变量属于静态存储方式，它具有以下特点：
(1)静态局部变量在函数内定义，但不象自动变量那样，当调用时就存在，退出函数时就消失。静态局部变量始终存在着，也就是说它的生存期为整个源程序。
(2)静态局部变量的生存期虽然为整个源程序，但是其作用域仍与自动变量相同，即只能在定义该变量的函数内使用该变量。退出该函数后，尽管该变量还继续存在，但不能使用它。
(3)允许对构造类静态局部量赋初值。若未赋以初值，则由系统自动赋以0值。
(4)对基本类型的静态局部变量若在说明时未赋以初值，则系统自动赋予0值。而对自动变量不赋初值，则其值是不定的。根据静态局部变量的特点，可以看出它是一种生存期为整个源程序的量。虽然离开定义它的函数后不能使用，但如再次调用定义它的函数时，它又可继续使用，而且保存了前次被调用后留下的值。因此，当多次调用一个函数且要求在调用之间保留某些变量的值时，可考虑采用静态局部变量。虽然用全局变量也可以达到上述目的，但全局变量有时会造成意外的副作用，因此仍以采用局部静态变量为宜。
补充：静态全局变量
全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量。全局变量本身就是静态存储方式，静态全局变量当然也是静态存储方式。这两者在存储方式上并无不同。这两者的区别虽在于非静态全局变量的作用域是整个源程序，当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。而静态全局变量则限制了其作用域，即只在定义该变量的源文件内有效，在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用，因此可以避免在其它源文件中引起错误。从以上分析可以看出， 把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域，限制了它的使用范围。因此static 这个说明符在不同的地方所起的作用是不同的。应予以注意。
4.变量捕获-self变量
@implementation Person
- (void)test{
void(^block)(void) = ^{
NSLog(@"%@", self);
};
}
@end
这个Person类中只有一个东西，就是test这个函数，那么这个block有没有捕获self变量呢？
要搞清这个问题，我们只需要知道搞清楚这里self变量是局部变量还是全局变量，如果是局部变量，那么是一定会捕获的，而如果是全局变量，则一定不会被捕获。
我们把这个Person.m文件转化为c++的源码，然后找到test函数在c++中的表示：
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));
}
我们可以看到，本来Person.m中，这个test函数我是没有传任何参数的，但是转化为c++的代码后，这里传入了两个参数，一个是self参数，一个是_cmd。self很常见，_cmd表示test函数本身。所以我们就很清楚了，self是作为参数传进来，也就是局部变量，那么block应该是捕获了self变量，事实是不是这样呢？我们只需要查看一下_Person_test_block_impl_0的结构就可以知道了。
_Person_test_block_impl_0的结构：
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确实是作为成员变量被捕获了。
三. Block的类型
前面已经说过了，Block的本质就是一个OC对象，既然它是OC对象，那么它就有类型。
在搞清楚Block的类型之前，先把ARC关掉，因为ARC帮我们做了太多的事，不方便我们观察结果。关掉ARC的方法在Build Settings里面搜索Objective-C Automatic Reference Counting，把这一项置为NO。
代码如下
int height = 10;
static int weight = 20;
int main(int argc, char * argv[]) {
@autoreleasepool {
int age = 10;
void (^block)(void) = ^{
NSLog(@"%d %d", height, age);
};
NSLog(@"%@\n %@\n %@\n %@", [block class], [[block class] superclass], [[[block class] superclass] superclass], [[[[block class] superclass] superclass] superclass]);
return 0;
}
}
打印
__NSStackBlock__
__NSStackBlock
NSBlock
NSObject
这说明上面定义的这个block的类型是NSStackBlock，并且它最终继承自NSObject也说明Block的本质是OC对象。
Block有三种类型，分别是NSGlobalBlock, MallocBlock, NSStackBlock。
代码举例：
int main(int argc, const char * argv[]) {
@autoreleasepool {
// 1. 内部没有调用外部变量的block
void (^block1)(void) = ^{
NSLog(@"Hello");
};
// 2. 内部调用外部变量的block
int a = 10;
void (^block2)(void) = ^{
NSLog(@"Hello - %d",a);
};
// 3. 直接调用的block的class
NSLog(@"%@ %@ %@", [block1 class], [block2 class], [^{
NSLog(@"%d",a);
} class]);
}
return 0;
}
// 输出
__NSGlobalBlock__ __NSMallocBlock__ __NSStackBlock__
这三种类型的Block对象的存储区域如下：
数据段中的
__NSGlobalBlock__直到程序结束才会被回收，不过我们很少使用到
__NSGlobalBlock__类型的block，因为这样使用block并没有什么意义。
__NSStackBlock__类型的block存放在栈中，我们知道栈中的内存由系统自动分配和释放，作用域执行完毕之后就会被立即释放，而在相同的作用域中定义block并且调用block似乎也多此一举。
__NSMallocBlock__是在平时编码过程中最常使用到的。存放在堆中需要我们自己进行内存管理。
Block类型的解释说明
截获了自动变量的Block是NSStackBlock类型，没有截获自动变量的Block则是NSGlobalStack类型,NSStackBlock类型的Block进行copy操作之后其类型变成了NSMallocBlock类型。
每一种类型的block调用copy后的结果如下所示
思考1：NSStackBlock类型的Block进行copy操作后Block对象为什么从栈复制到了堆这样做有什么道理？我们首先来看一段代码
void (^block)(void);
void test() {
int age = 10;
block = ^{
NSLog(@"age=%d", age);
};
}
int main(int argc, char * argv[]) {
@autoreleasepool {
test();
block();
return 0;
}
}
打印结果可能该是10，那么结果是不是这样呢？我们打印看一下：
age=-411258824
很奇怪，打印了一个这么奇怪的数字。这是为什么呢？
通过上面的总结可知，block捕获了了自动变量age，所以它是NSStackBlock类型的，因此block是存放在栈区，age是被捕获作为结构体的成员变量，其值也是被保存在栈区。所以当test这个函数调用完毕后，它栈上的东西就有可能被销毁了，一旦销毁了，age值就不确定是多少了。通过打印结果也可以看到，确实是影响到了block的执行。
如果我们对block执行copy操作，会是什么结果呢？
void (^block)(void);
void test() {
int age = 10;
block = [^{
NSLog(@"age=%d", age);
} copy]; // 调用一下copy方法
}
int main(int argc, char * argv[]) {
@autoreleasepool {
test();
block();
return 0;
}
}
打印结果：
age=10
这个时候得出了正确的输出。
因为对block进行copy操作后，block从栈区被复制到了堆区，它的成员变量age也随之被复制到了堆区，这样test函数执行完之后，它的栈区被销毁并不影响block，因此能得出正确的输出。
补充.ARC环境下自动为Block进行copy操作的情况
void (^block)(void);
void test() {
int age = 10;
block = ^{
NSLog(@"age=%d", age);
};
}
int main(int argc, char * argv[]) {
@autoreleasepool {
test();
block();
return 0;
}
}
这种使用方式其实非常常见，我们在使用的时候也没有发现有什么问题，那为什么在MRC环境下就有问题呢？因为在ARC环境下编译器为我们做了很多copy操作。其中有一个规则就是如果Block被强指针指着，那么编译器就会对其进行copy操作。我们看到这里：
^{
NSLog(@"age=%d", age);
};
这个Block块是被强指针指着(上面说过void (*block)(void) = &__main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA);)，所以它会进行copy操作，由于其使用了自动变量，所以是栈区的Block。经过复制以后就到了堆区，这样由于Block在堆区，所以就不受Block执行完成的影响，随时可以获取age的正确值。
总结一下ARC环境下自动进行copy操作的情况一共有以下几种：
-
block作为函数返回值时。
-
将block赋值给__strong指针时。
-
block作为Cocoa API中方法名含有usingBlock的方法参数时。
-
GCD中的API。
block作为函数返回值时
typedef void(^Block)(void);
Block test() {
int age = 10;
return ^{
NSLog(@"age=%d", age);
};
}
int main(int argc, char * argv[]) {
@autoreleasepool {
Block block = test();
block();
return 0;
}
}
test函数的返回值是一个block，那这种情况的时候，在栈区的
^{
NSLog(@"age=%d", age);
};
因为被一个强指针指着，所以这个block会被复制到堆区
block作为Cocoa API中方法名含有usingBlock的方法参数时
NSArray *array = [[NSArray alloc] init];
[array enumerateObjectsUsingBlock:^(id _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {
NSLog(@"%d", idx);
}];
enumerateObjectsUsingBlock:这个函数中的block会进行copy操作
GCD中的API
GCD中的很多API的参数都有block，这个时候都会对block进行一次copy操作，比如下面这个dispatch_after函数：
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
NSLog(@"wait");
});
更多精彩内容
我的主页
我的博客主页