【iOS】Blocks
- IT业界
- 2025-08-27 22:00:02
【iOS】Blocks 文章目录 【iOS】Blocks前言什么是BlocksBlock语法Block类型变量 截获自动变量__block修饰符 截获的自动变量Block的实质截获自动变量值__block说明符Block的存储域__block变量存储域截获对象__block变量和对象Block循环引用 小结 前言
笔者最近看了小白书的Blocks的板块，这篇博客简单总结一下有关于Blocks的内容，笔者也是初次较为深入的学习Block。如有错误，请不吝赐教。
什么是Blocks用小白本里的话来讲就是：带有自动变量（局部变量）的匿名函数。
我们认识Blocks从C语言的函数开始认识他：
int func(int count);这是我们C语言的函数内容，这时候我们从C语言的函数指针开始：
int (*funptr)(int) = &func; int result = funptr(1); NSLog(@"%d", result);这样我们可以通过函数指针不需要知道函数名都可以调用这个函数，而Block则可以运行我们直接使用匿名函数。我们首先要认识一下我们的C语言函数中可能用到的一些变量类型：
自动变量函数的参数静态局部变量静态全局变量全局变量能在函数的多次调用之间传递值的有后面三者。虽然这些变量的作用域不同，但在整个程序当中，一个变量总保持在一个内存区域。因此，虽然多次调用函数，但该变量值总能保持不变，在任何时候以任何状态调用，使用的都是同样的变量值。
int buttonId; void buttonCallback (int event) { printf ("buttonId:&d event=&d\n" , buttonId, event) ; } void setButtonCallbacks () { for (int i = 0; i < 30; ++i) { buttonid = 1; setButtonCallback (BUTTON_IDOFFSET + i, &buttonCallback) ; } }这里用到了一个回调函数，这个回掉函数有一个问题，那就是我们所有的最后的回掉结果都会是我们最后的那个置，但是如果我们把他变成函数内的变量在进行一个参数传递就不会出现那中问题了。
void buttonCallback (int event, int buttonId) { printf ("buttonId:&d event=&d\n" , buttonId, event) ; }用Block来写就相当于：
void setButtonCallbacks() { for (int i = 0; i < BUTTON_MAX; ++i) { setButtonCallbackUsingBlock(BUTTON_IDOFFSET + i, ^(int event) { printf("buttonId:&d event=%d\n", i, event); }); } }Block又被称为闭包，在不同的语言中都有应用。
Block语法这里我们认识一下语法格式：
^int(int count) { return 1; };然后我们可以省略返回值类型：
^(int count) { return 1; };如果我们不需要用到参数那么可以仅仅保留表达式：
^{ return 1; }; Block类型变量我们先看之前的函数指针的内容：
int (*funptr)(int) = &func; int result = funptr(1); NSLog(@"%d", result);Block也是这样子应用的。
同样地，在Block 语法下，可将 Block 语法赋值给声明为 Block 类型的变量中。即源代码中一旦使用Block语法就相当于生成了可赋值给 Block 类型变量的“值”。Blocks 中由Block 语法生成的值也被称为“Block”。在有关Blocks 的文档中，“Block”既指源代码中的Block 语法，也指由Block 语法所生成的值。
int (^blk)(int);与前面的使用函数指针的源代码对比可知，声明Block类型变量仅仅是将声明函数指针类型变量的“*”变为“^”。该Block类型变量与一般的C语言变量完全相同，可作为以下用途使用。
自动变量函数参数静态变量静态全局变量全局变量我们这里就不多赘述，主要展示一下我们在函数中使用Block,Block作为参数：
void func(int (^blk)(int)) { // 在函数体中，可以调用 blk 这个 Block。 }Block作为返回值：
int (^func())(int) { return ^(int count) { return count + 1; }; }这时候我们一般会采用typdef来定义不同的内容：
typedef int (^blk_t)(int);这样让我们的代码更加直观，更方便我们去理解这种类似的代码
截获自动变量 int main(int argc, const char * argv[]) { @autoreleasepool { int val = 10; int fmt = 15; void (^blk)(void) = ^ { NSLog(@"%ld %ld",val, fmt); }; fmt = 20; val = 30; blk(); } return 0; }该源代码中，Block语法的表达式使用的是之前声明的目动变量 fmt 和 val。 Blocks 中，Block表达式截获所使用的自动变量的值，即保存该自动变量的瞬间值。因为Block表达式保存了自动变量的值，所以在执行 Block 语法后，即使改写Block 中使用的自动变量的值也不会影响Block 执行时自动变量的值。该源代码就在 Block 语法后改写了 Block 中的自动变量 val 和 fmt。
下面我们一起看一下执行结果。
10 15 __block修饰符如果我们想让我们的Block中的自动变量在Block中进行修改的，那么我们只需要给他加上__block的修饰符就可以了，这样就可以在Blcok中修改我们设置在外面的局部变量了。
int main(int argc, const char * argv[]) { @autoreleasepool { __block int val = 10; int fmt = 15; void (^blk)(void) = ^ { val = 30; NSLog(@"%ld %ld",val, fmt); }; fmt = 20; blk(); } return 0; } 30 15 Type: Notice | Timestamp: 2025-02-18 19:09:28.135305+08:00 | Process: BStudy | Library: BStudy | TID: 0x286c5b7 截获的自动变量我们不能在block中变更我们的int值，那能不能给数组添加数据呢，答案是显而易见的，这是可以的：
int main(int argc, const char * argv[]) { @autoreleasepool { __block int val = 10; int fmt = 15; NSMutableArray* array = [@[] mutableCopy]; void (^blk)(void) = ^ { [array addObject:@"1"]; }; fmt = 20; blk(); } return 0; }这是没有问题的，而向截获的变量 array 赋值则会产生编译错误。该源代码中截获的变量值为 NSMutableArray 类的对象。如果用C语言来描述，即是截获 NSMutableArray 类对象用的结构体实例指针。虽然赋值给截获的自动变量 array 的操作会产生编译错误，但使用截获的值却不会有任何问题。下面源代码向截的自动变量进行赋值，因此会产生编译错误。
同样添加__block修饰符就可以变更：
这里主要是两个C语言的字符串和字符数组的区别：
int main(int argc, const char * argv[]) { @autoreleasepool { __block int val = 10; int fmt = 15; const char text[] = "hello"; void (^blk)(void) = ^ { printf("%c", text[2]); }; fmt = 20; blk(); } return 0; }这种方式会报错，但是下面这种方式则不会报错：
int main(int argc, const char * argv[]) { @autoreleasepool { __block int val = 10; int fmt = 15; const char* text = "hello"; void (^blk)(void) = ^ { printf("%c", text[2]); }; fmt = 20; blk(); } return 0; }这是因为现在的OC的block没有实现对于我们的C语言数组的自动截获，而使用指针则可以解决这个问题。
Block的实质这不过是概念上的问题，在实际编译时无法转换成我们能够理解的源代码，但 clang （LLVM编译器）具有转换为我们可读源代码的功能。通过“-rewrite-objc”选项就能将含有 Block 语法的源代码变换为C++的源代码。说是C++，其实也仅是使用了struct结构，其本质是C语言源代码。
首先我们看一下这段最简单的代码：
int main(int argc, const char * argv[]) { @autoreleasepool { void (^blk)(void) = ^{ printf("123"); }; blk(); } return 0; }他通过clang编译后变成这个部分：
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) { printf("123"); } 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 (*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA)); ((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk); } return 0; } static struct IMAGE_INFO { unsigned version; unsigned flag; } _OBJC_IMAGE_INFO = { 0, 2 };转化后的代码，我们可以很清晰的看到我们写在Block中的内容：
static void __main_block_func_0(struct __main_block_impl_0 *__cself) { printf("123"); }这里我们显而易见可以看见_cself是一个block_impl的一个指针，这个指针指向下面这个结构体：
struct __main_block_impl_0 { struct __block_impl impl; struct __main_block_desc_0* Desc; };impl的结构体如下：后面两个是升级的大小和函数指针
struct __mian_block_impl_0 { void *isa; int Flags; int Reserved; void *FuncPtr; };第二个成员变量如下：
static struct __main_block_desc_0 { size_t reserved; size_t Block_size; }他的结构为今后升级的大小和Block的大小。
初始化Block的构造函数如下：
__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; }现在这里我们看一下调用构造函数的一个过程：
void (*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));去掉转化的一个过程，我们可以看到其实是：
struct __main_block_impl_0 tmp = __main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA); struct __main_block_impl_0 *blk = &tmp;这里其实就是创建一个局部变量，然后把他赋值给这个我们的blk。这段代码对应：
void (^blk)(void) = ^{ printf("123"); };将Block语法生成的Block赋值给Block类型变量，就相当于吧结构体实例指针复制给blk指针
这时候我们看一下他生成实例变量的一个过程：
__main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA);第一个参数是由 Block 语法转换的C语言函数指针。第二个参数是作为静态全局变量初始化
的_ _main_block_desc_O结构体实例指针。以下为__main_block_dese_0结构体实例的初始化部分代码:
static struct __main_block_desc_0 __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0), };这部分代码就是根据__main_block_impl_0的大小来分配一个内存大小。
下面我们看一下之前的__main_block_impl _ 是怎么实现的初始化的
isa = &NSConcreteStackBlock; Flags = 0; Reserved = 0; FuncPtr = __main_block_func_0; Desc = &__main_block_desc_0_DATA;把一个函数指针__main_block_func_0赋值给FuncPtr这个成员变量。这个函数也就是我们之前写在Block中的函数内容:
static void __main_block_func_0(struct __main_block_impl_0 *__cself) { printf("123"); }这时候我们看一下使用blk（）的部分：
((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);实际上代表这部分代码：
(*blk->impl.FuncPtr)(blk);这就是简单地使用函数指针调用函数。正如我们刚才所确认的，由Block 语法转换的_main_block_ func_0 函数的指针被赋值成员变量 FuncPtr 中。另外也说明了，_main_block func. _0函数的参数__cself 指向Block值。在调用该函数的源代码中可以看出 Block 正是作为参数进行了传递。
这里我们在认识一下之前提到的&NSConcreteStackBlock
这里就是把Block的指针赋值给isa指针，这里其实就是展示出我们的Block其实是一个对象。
这里我们重新回忆一下isa指针。
下面这个代码是类的结构体
struct MyObject { Class isa; int valo; int vall; }MyObject类的实例变量val0 和val1 被直接声明为对象的结构体成员。“Objective-C 中由类生成对象”意味着，像该结构体这样“生成由该类生成的对象的结构体实例”。生成的各个对象，即由该类生成的对象的各个结构体实例，通过成员变量isa 保持该类的结构体实例指针。
其实这里就相当于我们：
struct __mian_block_impl_0 { void *isa; int Flags; int Reserved; void *FuncPtr; };这个结构体其实就是一个对象基于objc_object的对象
截获自动变量值现在我们吧我们之前截获变量的代码重新编译一下：
struct __main_block_impl_0 { struct __block_impl impl; struct __main_block_desc_0* Desc; int val; int fmt; __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _val, int _fmt, int flags=0) : val(_val), fmt(_fmt) { impl.isa = &_NSConcreteStackBlock; impl.Flags = flags; impl.FuncPtr = fp; Desc = desc; } }; static void __main_block_func_0(struct __main_block_impl_0 *__cself) { int val = __cself->val; // bound by copy int fmt = __cself->fmt; // bound by copy NSLog((NSString *)&__NSConstantStringImpl__var_folders_rb_0ts7dvhs3zg9fc6kk2nvtlr00000gn_T_main_f22e73_mi_0,val, fmt); } 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[]) { int val = 10; int fmt = 15; void (*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, val, fmt)); fmt = 20; val = 30; ((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk); return 0; } static struct IMAGE_INFO { unsigned version; unsigned flag; } _OBJC_IMAGE_INFO = { 0, 2 };这里我们可以很清楚的看到我们这里已经把对应的一个自动变量，添加到我们的block的结构体中充当一个成员变量了：
struct __main_block_impl_0 { struct __block_impl impl; struct __main_block_desc_0* Desc; int val; int fmt; };这里注意Block捕获的变量仅仅限制于我们的一个Block中需要用到的一些变量
这里注意我们这里的Block函数部分：
static void __main_block_func_0(struct __main_block_impl_0 *__cself) { int val = __cself->val; // bound by copy int fmt = __cself->fmt; // bound by copy NSLog((NSString *)&__NSConstantStringImpl__var_folders_rb_0ts7dvhs3zg9fc6kk2nvtlr00000gn_T_main_f22e73_mi_0,val, fmt); }这里我们发现一个事情，就是我们这里的一个我给使用到的成员变量，是通过Block自己这个结构体中之前保存的一个结构来赋值的，这时候我们重新看一下初始化函数：
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _val, int _fmt, int flags=0) : val(_val), fmt(_fmt) { impl.isa = &_NSConcreteStackBlock; impl.Flags = flags; impl.FuncPtr = fp; Desc = desc; }这里我们就可以发现这段代码里面我们直接给内部的变量赋值好了
这时候我们前后对比一下就可以发现下面的这个道理：
在转换后的源代码中，截获到__main_ block_impl_O结构体实例的成员变量上的自动变量，这些变量在Block语法表达式之前被声明定义。因此，原来的源代码表达式无需改动便可使用截获的自动变量值执行。
__block说明符我们之前提到了可以通过__block修饰符来修改Block中捕获的变量。
其实还有另一种解决方式：
那就是采用静态变量，静态全局变量，全局变量着三个变量，这样就可以修改了：
int global_val = 1; static int static_global_val = 2; int main() { static int static_val = 3; void (^blk)(void) = ^{ global_val *= 1; static_global_val *= 2; static_val *= 3; }; return 0; }然后重新编译一下这段代码：
int global_val = 1; static int static_global_val = 2; struct __main_block_impl_0 { struct __block_impl impl; struct __main_block_desc_0* Desc; int *static_val; __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int *_static_val, int flags=0) : static_val(_static_val) { impl.isa = &_NSConcreteStackBlock; impl.Flags = flags; impl.FuncPtr = fp; Desc = desc; } }; static void __main_block_func_0(struct __main_block_impl_0 *__cself) { int *static_val = __cself->static_val; // bound by copy global_val *= 1; static_global_val *= 2; (*static_val) *= 3; } 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() { static int static_val = 3; void (*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, &static_val)); return 0; }这里的静态全局变量和全局变量还是和之前一样，没有什么区别。但是对于静态变量是又区别的。
static void __main_block_func_0(struct __main_block_impl_0 *__cself) { int *static_val = __cself->static_val; // bound by copy global_val *= 1; static_global_val *= 2; (*static_val) *= 3; }这里我们可以发现通过静态变量的指针传递给构造函数并且保存，这种方式是最简单的超出作用于使用变量的方法
接下来我们在看有关于__block这个修饰符的内容：
__block这个说明符主要是用于指定将变量值设置到那个存储域中
先看这段比较简单的代码：
int main(int argc, const char * argv[]) { __block int val = 10; int fmt = 15; void (^blk)(void) = ^ { val = 12; NSLog(@"%ld %ld",val, fmt); }; fmt = 20; val = 30; blk(); return 0; }然后重新编译下：
struct __Block_byref_val_0 { void *__isa; __Block_byref_val_0 *__forwarding; int __flags; int __size; int val; }; struct __main_block_impl_0 { struct __block_impl impl; struct __main_block_desc_0* Desc; int fmt; __Block_byref_val_0 *val; // by ref __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _fmt, __Block_byref_val_0 *_val, int flags=0) : fmt(_fmt), val(_val->__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_val_0 *val = __cself->val; // bound by ref int fmt = __cself->fmt; // bound by copy (val->__forwarding->val) = 12; NSLog((NSString *)&__NSConstantStringImpl__var_folders_rb_0ts7dvhs3zg9fc6kk2nvtlr00000gn_T_main_de84d3_mi_0,(val->__forwarding->val), fmt); } static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->val, (void*)src->val, 8/*BLOCK_FIELD_IS_BYREF*/);} static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->val, 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[]) { __attribute__((__blocks__(byref))) __Block_byref_val_0 val = {(void*)0,(__Block_byref_val_0 *)&val, 0, sizeof(__Block_byref_val_0), 10}; int fmt = 15; void (*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, fmt, (__Block_byref_val_0 *)&val, 570425344)); fmt = 20; (val.__forwarding->val) = 30; ((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk); return 0; }这里我们来看一下由__block修饰的变量的代码在哪里：
struct __Block_byref_val_0 { void *__isa; __Block_byref_val_0 *__forwarding; int __flags; int __size; int val; };这个val变成了一个结构体，然后val成为了结构体中的某一个数值
这里我们重新看一下这段代码,这段代码是在block中给变量赋值的代码：
static void __main_block_func_0(struct __main_block_impl_0 *__cself) { __Block_byref_val_0 *val = __cself->val; // bound by ref int fmt = __cself->fmt; // bound by copy (val->__forwarding->val) = 12; NSLog((NSString *)&__NSConstantStringImpl__var_folders_rb_0ts7dvhs3zg9fc6kk2nvtlr00000gn_T_main_de84d3_mi_0,(val->__forwarding->val), fmt); } struct __main_block_impl_0 { struct __block_impl impl; struct __main_block_desc_0* Desc; int fmt; __Block_byref_val_0 *val; // by ref __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _fmt, __Block_byref_val_0 *_val, int flags=0) : fmt(_fmt), val(_val->__forwarding) { impl.isa = &_NSConcreteStackBlock; impl.Flags = flags; impl.FuncPtr = fp; Desc = desc; } };//这里是结构体刚刚在 Block 中向静态变量赋值时，使用了指向该静态变量的指针。而向_ block 变量赋值要比这个更为复杂。Block 的_ main_block_impl_0结构体实例持有指向__block 变量的 _ Block_byref_val_0结构体实例的指针。
__Block_byref _ val _0结构体实例的成员变量_forwarding 持有指向该实例自身的指针。通过成员变量 forwarding 访问成员变量val。（成员变量val是该实例自身持有的变量，它相当于原自动变量。）
这里注意我的__block的变量的结构体并不储存在我们的Block结构体中，这是为了让他多个Block中被使用，所以他只是保留一个指针。
Block的存储域我们之前提到过我们的Block的类型是：_NSConcreteStackBlock，我们会发现有一些和他类似的类：
_ NSConcreteStackBlock（分布在栈上）_NSConcreteGlobalBlock（分布在程序的数据区的位置）NSConcreteMallocBlock（分布在堆的位置）如果定义一个我们的全局变量的Block:
void (^blk)(void) = ^ { NSLog(@"Block"); };该 Block 的类为__NSConcreteGlobalBlock 类。此Block 即该 Block 用结构体实例设置在程序
的数据区域中。因为在使用全局变量的地方不能使用自动变量，所以不存在对自动变量进行截获。由此Block用结构体实例的内容不依赖于执行时的状态，所以整个程序中只需一个实例。因此将 Block 用结构体实例设置在与全局变量相同的数据区域中即可。
只在截获自动变量时，Block 用结构体实例截获的值才会根据执行时的状态变化。例如以下源代码中，虽然多次使用同一个 Block 语法，但每个 for 循环中截获的自动变量的值都不同。
typedef int (^blk_t)(int); for (int rate = 0; rate < 10; ++rate) { blk_t blk = ^(int count) { return rate * count; }; }上面这段代码需要截获自动变量：
typedef int (^blk_t)(int); for (int rate = 0; rate < 10; ++rate) { blk_t blk = ^(int count) { return count; }; }上面这段代码则不需要截获自动变量。
这里也就是说如果不需要截获自动变量的话，可以把Block用结构体实例放在程序的数据区域。
所以只有两种情况下是_NSConcreteGlobalBlock（分布在程序的数据区的位置）：
记述全局变量的地方有Block语法Block语法的表达式中不使用应截获的自动变量的初次之外，生成Block的都是_ NSConcreteStackBlock。最后我吗现在再来讨论堆上的Block
这里Block就用姜Blcok拷贝到堆上的方法来解决这个问题，解决这给__block变量被废弃的问题。
这里我们主要认识一下不同Blockcopy的一个差异：
以及注意下某些情况需要我们自己手动复制一下栈上的Block否则这个Block就会被释放掉，这里就注意一个点：在向方法和函数中传递Block的时候，要自己手动复制一下，除了以下的方法不需要我们进行手动复制：
Cocoa 框架的方法且方法名中含有 usingBlock 等时Grand Central Dispatch 的 API其他方法我们记得要去手动复制一下Block。
__block变量存储域我们在上面提到一个复制的时候，一个Block使用__block变量的代码部分，我们现在看一下这个图：
这其实就是正常的一个拷贝的过程
如果有多个Block使用这种变量的时候，那么就是看一下下面这张图
在多个 Block 中使用_block 变量时，因为最先会将所有的Block 配置在栈上，所以__block
变量也会配置在栈上。在任何一个 Block 从栈复制到堆时，_block 变量也会一并从栈复制到堆并被该 Block 所持有。当剩下的 Block 从栈复制到堆时，被复制的Block 持有_block 变量，并增加
block变量的引用计数。
如果配置在堆上的Block被释放，那么我们这里的__block变量也会被释放
其实这就和正常的引用计数一样，引用计数为0就自动释放了。
这里我们在重新认识一下我们的forwarding指针的作用，前面提到了forwording指针是为了让我们的__block变量的值可以一直被访问到
截获对象这里我们看一下这段OC代码：
int main(int argc, const char * argv[]) { NSMutableArray* ary = [NSMutableArray array]; void (^blk)(id object) = [^(id object) { [ary addObject:object]; NSLog(@"%ld", ary.count); } copy]; blk([[NSMutableArray alloc] init]); blk([[NSMutableArray alloc] init]); blk([[NSMutableArray alloc] init]); return 0; }这段代码的输出结果是：
1 Type: Notice | Timestamp: 2025-02-19 19:02:59.452110+08:00 | Process: BStudy | Library: BStudy | TID: 0x28bf361 2 Type: Notice | Timestamp: 2025-02-19 19:02:59.452182+08:00 | Process: BStudy | Library: BStudy | TID: 0x28bf361 3 Type: Notice | Timestamp: 2025-02-19 19:02:59.452235+08:00 | Process: BStudy | Library: BStudy | TID: 0x28bf361这一结果意味着这里NSmutablearray并没有被释放，说明array超出变量作用域而存活
struct __main_block_impl_0 { struct __block_impl impl; struct __main_block_desc_0* Desc; NSMutableArray *__strong ary; __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, NSMutableArray *__strong _ary, int flags=0) : ary(_ary) { impl.isa = &_NSConcreteStackBlock; impl.Flags = flags; impl.FuncPtr = fp; Desc = desc; } }; static void __main_block_func_0(struct __main_block_impl_0 *__cself, __strong id object) { NSMutableArray *__strong ary = __cself->ary; // bound by copy ((void (*)(id, SEL, ObjectType _Nonnull __strong))(void *)objc_msgSend)((id)ary, sel_registerName("addObject:"), (id)object); NSLog((NSString *)&__NSConstantStringImpl__var_folders_rb_0ts7dvhs3zg9fc6kk2nvtlr00000gn_T_main_2edec4_mi_0, ((NSUInteger (*)(id, SEL))(void *)objc_msgSend)((id)ary, sel_registerName("count"))); } static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->ary, (void*)src->ary, 3/*BLOCK_FIELD_IS_OBJECT*/);} static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->ary, 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}; int main(int argc, const char * argv[]) { NSMutableArray* ary = ((NSMutableArray * _Nonnull (*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("NSMutableArray"), sel_registerName("array")); void (*blk)(id object) = (void (*)(__strong id))((id (*)(id, SEL))(void *)objc_msgSend)((id)((void (*)(__strong id))&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, ary, 570425344)), sel_registerName("copy")); ((void (*)(__block_impl *, __strong id))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk, ((NSMutableArray *(*)(id, SEL))(void *)objc_msgSend)((id)((NSMutableArray *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("NSMutableArray"), sel_registerName("alloc")), sel_registerName("init"))); ((void (*)(__block_impl *, __strong id))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk, ((NSMutableArray *(*)(id, SEL))(void *)objc_msgSend)((id)((NSMutableArray *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("NSMutableArray"), sel_registerName("alloc")), sel_registerName("init"))); ((void (*)(__block_impl *, __strong id))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk, ((NSMutableArray *(*)(id, SEL))(void *)objc_msgSend)((id)((NSMutableArray *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("NSMutableArray"), sel_registerName("alloc")), sel_registerName("init"))); return 0; }这里我们可以看到这里的Block的结构体：
struct __main_block_impl_0 { struct __block_impl impl; struct __main_block_desc_0* Desc; NSMutableArray *__strong ary; __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, NSMutableArray *__strong _ary, int flags=0) : ary(_ary) { impl.isa = &_NSConcreteStackBlock; impl.Flags = flags; impl.FuncPtr = fp; Desc = desc; } };这里其实是采用了__strong修饰的成员变量。
按照1.3.4节，在 Objective-C 中，C语言结构体不能含有附有__strong 修饰符的变量。因为编译器不知道应何时进行C语言结构体的初始化和废弃操作，不能很好地管理内存。
但是 Objective-C 的运行时库能够准确把握Block 从栈复制到堆以及堆上的Block 被废弃的时机，因此 Block 用结构体中即使含有附有__strong 修饰符或__weak 修饰符的变量，也可以恰当地进行初始化和废弃。为此需要使用在__main_block _dese_0结构体中增加的成员变量 copy和dispose，以及作为指针赋值给该成员变量的_main_block copy_0函数和__main_block_dispose 0函数。
由于在该源代码的Block 用结构体中，含有附有__strong 修饰符的对象类型变量 array，所以需要恰当管理赋值给变量 array 的对象。因此__main_block_copy_0函数使用_Block_object_assign 函数将对象类型对象赋值给 Block 用结构体的成员变量 array 中并持有该对象。
这段代码是引言的最后一段的解释
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->ary, (void*)src->ary, 3/*BLOCK_FIELD_IS_OBJECT*/);}_Block_object_assign这个方法其实相当于调用retain方法，将对象赋值在对象类型的结构体中，同时有一个释放内存的函数：
static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->ary, 3/*BLOCK_FIELD_IS_OBJECT*/);}这个方法其实是Block在废弃后会调用的函数，用来释放内存。
这些函数分别会在Block复制到堆上被调用，和Block被废弃的时候调用
在下面这种情况下Block会被复制到堆上：
调用 Block 的 copy 实例方法时Block 作为函数返回值返回时将 Block 赋值给附有 __strong 修饰符 id 类型的类或 Block 类型成员变量时在方法名中含有 usingBlock 的Cocoa 框架方法或 Grand Central Dispatch 的API 中传递 Block在调用 Block 的copy 实例方法时，如果 Block 配置在栈上，那么该Block 会从栈复制到堆。
Block 作为函数返回值返回时、将Block 赋值给附有__strong 修饰符id类型的类或Block 类型成员变量时，编译器自动地将对象的Block作为参数并调用_Block_copy 函数，这与调用Block的 copy 实例方法的效果相同。在方法名中含有 usingBlock 的 Cocoa 框架方法或 Grand CentralDispatch 的API 中传递 Block 时，在该方法或函数内部对传递过来的Block 调用 Block 的 copy 实列方法或者_Block _copy 函数。
也就是说，虽然从源代码来看，在上面这些情况下栈上的Block 被复制到堆上，但其实可归结为_Block_copy 函数被调用时Block 从栈复制到堆。
有了这种构造，通过使用附有__strong 修饰符的自动变量，Block 中截获的对象就能够超出其变量作用域而存在。
这里注意截获变量的结构体虽然大致相同但是还是有区别的：
通过这两个不同的内容来区分捕获的是对象类型还是__block变量。
Block 中使用的赋值给附有_strong 修饰待的自动变量的对象和复制到堆上的_-block 变量由于被堆上的Block 所持有，因而可超出其变量作用域而存在。
只有调用Block_copy 函数才能持有截获的附有__strong 修饰符的对象类型的自动变量值，所以像上面源代码这样不调用_Block_copy 函数的情况下，即使截获了对象，它也会随着变量作用域的结束而被废弃。
因此，Block 中使用对象类型自动变量时，除以下情形外，推荐调用 Block 的 copy 实例方法。
Block 作为函数返回值返回时将Block赋值给类的附有__strong修饰符的id 类型或Block 类型成员变量时向方法名中含有 usingBlock 的Cocoa 框架方法或Grand Central Dispatch 的API 中传递 Block 时 __block变量和对象我们如果用__block来修饰对象的话，我们先看一下这两段代码：
int main(int argc, const char * argv[]) { __block NSMutableArray* ary = [NSMutableArray array]; void (^blk)(void) = ^ { NSLog(@"1"); }; blk(); return 0; }然后转化一下
struct __Block_byref_ary_0 { void *__isa; __Block_byref_ary_0 *__forwarding; int __flags; int __size; void (*__Block_byref_id_object_copy)(void*, void*); void (*__Block_byref_id_object_dispose)(void*); NSMutableArray *__strong ary; }; 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) { NSLog((NSString *)&__NSConstantStringImpl__var_folders_rb_0ts7dvhs3zg9fc6kk2nvtlr00000gn_T_main_a8ae80_mi_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)}; int main(int argc, const char * argv[]) { __attribute__((__blocks__(byref))) __Block_byref_ary_0 ary = {(void*)0,(__Block_byref_ary_0 *)&ary, 33554432, sizeof(__Block_byref_ary_0), __Block_byref_id_object_copy_131, __Block_byref_id_object_dispose_131, ((NSMutableArray * _Nonnull (*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("NSMutableArray"), sel_registerName("array"))}; void (*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA)); ((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk); return 0; }这里同样出现了我们之前看到的void (*__Block_byref_id_object_copy)(void*, void*); void (*__Block_byref_id_object_dispose)(void*);这两个函数来把Block拷贝到堆上，以及负责对应的一个释放的操作
在block 变量为附有strong 修饰符的id 类型或对象类型自动变量的情形下会发生同样的
过程。当__block 变量从栈复制到堆时，使用_Block_object_assign函数，持有赋值给__block变量的对象。当堆上的__block 变量被废弃时，使用_Block_object_dispose 函数，释放赋值给__block变量的对象。
由此可知，即使对象赋值复制到堆上的附有__strong 修饰符的对象类型__block 变量中，只要_block 变量在堆上继续存在，那么该对象就会继续处于被持有的状态。这与Block 中使用赋值给附有_strong 修饰符的对象类型自动变量的对象相同。
这里注意 _ _weak和 __block一起联合使用，他还是会在该作用域结束的时候被释放，
Block循环引用我们经常在Block中会写出有关于循环引用的内容：
- (id) init { self = [super init]; blk_ = ^(NSLog(@"self = 8@", self) ;): return self; }MyObject 类对象的Block 类型成员变量blk_持有赋值为 Block 的强引用。即MyObject 类对象持有 Block。ini 实例方法中执行的 Block 语法使用附有__strong 修饰符的id 类型变量 self。并且由于Block语法赋值在了成员变量blk_中，因此通过 Block 语法生成在栈上的Block 此时由栈复制到堆，并持有所使用的 self。 self持有Block，Block 持有 self。这正是循环引用。如图2-13所示。
这里我们需要用weak变量来修饰一下self。
id __weak tmp = self;在经过这个操作之后我们就可以避免了一个循环引用的问题，这里也可以使用__block变量来避免一个循环引用
typedef void (^blk_t)(void); @interface MyObject : NSObject { blk_t blk; } @end @implementation MyObject - (id)init { self = [super init]; __block id tmp = self; blk = ^{ NSLog(@"self = %@", tmp); tmp = nil; }; return self; } - (void)execBlock { blk(); } - (void)dealloc { NSLog(@"dealloc"); } @end int main() { id o = [[MyObject alloc] init]; [o execBlock]; return 0; }这里虽然有一个循环引用的问题，就是在我们不执行- (void)execBlock这个函数的前提下就会出一个循环引用的问题，只有执行了一个函数之后才可以解决循环引用的问题。下面这个图的标优点问题，Block持有__block变量
调用这个函数之后会把__block变量置为nil。
所以为了避免循环引用必须执行那个函数。
小结主要简单总结了一下之前学习的内容，但是对于Block之后还有继续学习，而且这段代码看的也比较迷茫，还需要多加整理复习
【iOS】Blocks由讯客互联IT业界栏目发布，感谢您对讯客互联的认可，以及对我们原创作品以及文章的青睐，非常欢迎各位朋友分享到个人网站或者朋友圈，但转载请说明文章出处“【iOS】Blocks”
下一篇
Mysql-------事务
