Block原理探究(下篇)-捕获变量分析及__block原理

主要内容：

  1. 分析Block捕获外部变量的过程
  2. 理解Block修改外部变量的限制
  3. 分析__block存储域类说明符的原理
  4. 理解__block变量的存储域
  5. 探究Block对对象的捕获过程
  6. Block的循环引用问题

一、分析Block捕获外部变量的过程

为了保证Block内部能够正常访问外部的变量，Block有一个变量捕获机制，即Block语法表达式所使用变量可以被保存到Block的结构体实例(Block自身)中。

关于捕获，Block对不同的外部变量的处理有所不同，根据OC中使用变量的分类，大概包括以下几种情况：

  1. 函数参数(这里研究Block捕获，所以此处不涉及)
  2. 局部变量(简称：自动变量)
  3. 静态局部变量(常简称，静态变量)
  4. 全局变量
  5. 静态全局变量

那么，现在对Block捕获外部变量的四种情况进行测试，相关代码如下：

#import <Foundation/Foundation.h>

//使用如下的命令，可将OC代码编译为C++代码
//clang -rewrite-objc main.m

int global_val = 1;                  //全局变量
static int static_global_val = 1;    //静态全局变量

int main(int argc, char * argv[]) {
    int val = 1;                     //自动变量
    static int static_val = 1;       //局部静态变量
    
    void (^myBlock)(void) = ^{
        global_val ++;
        static_global_val ++;
        static_val ++;
        //val++//直接修改会报错(Variable is not assignable (missing __block type specifier)
        
        NSLog(@"\nBlock内:\nglobal_val = %d,\nstatic_global_val = %d,\nval = %d,\nstatic_val= %d",global_val,static_global_val,val,static_val);
    };
    
    global_val ++;
    static_global_val ++;
    val ++;
    static_val ++;
    
    NSLog(@"\nBlock外:\nglobal_val = %d,\nstatic_global_val = %d,\nval = %d,\nstatic_val= %d",global_val,static_global_val,val,static_val);
    myBlock();
    return 0;
}

运行的结果如下：

Block外:
global_val = 2,
static_global_val = 2,
val = 2,
static_val= 2

Block内:
global_val = 3,
static_global_val = 3,
val = 1,
static_val= 3

分析运行结果，我们会发现以上四种情况中，只有静态局部变量、静态全局变量、全局变量可以在Block里被修改，而且直接修改自动变量就会报错；

此时，考虑以下两个问题：

  1. 为什么在Block里不允许更改自动变量？
  2. Block捕获不同的变量并修改时，有什么区别吗？

为了具体分析，现在将上述代码转化为C++的源码，转换后的代码如下：

int global_val = 1;
static int static_global_val = 1;

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  int *static_val;  //对应静态局部变量
  int val;          //对应自动变量
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int *_static_val, int _val, int flags=0) : static_val(_static_val), val(_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
  int val = __cself->val; // bound by copy

        global_val ++;
        static_global_val ++;
        (*static_val) ++;

        NSLog((NSString *)&__NSConstantStringImpl__var_folders_3f_crl5bnj956d806cp7d3ctqhm0000gn_T_main_78fd5a_mi_0,global_val,static_global_val,val,(*static_val));
    }

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, char * argv[]) {
    int val = 1;
    static int static_val = 1;

    void (*myBlock)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, &static_val, val));

    global_val ++;
    static_global_val ++;
    val ++;
    static_val ++;

    NSLog((NSString *)&__NSConstantStringImpl__var_folders_3f_crl5bnj956d806cp7d3ctqhm0000gn_T_main_78fd5a_mi_1,global_val,static_global_val,val,static_val);

    ((void (*)(__block_impl *))((__block_impl *)myBlock)->FuncPtr)((__block_impl *)myBlock);

    return 0;
}

在代码分析之前，我们有必要对程序中的内存区域划分有所了解，其大致的分类如下：

内存区域 具体说明
栈区 存放局部变量的值，系统自动分配和释放;
特点：容量小，速度快，有序
堆区 存放通过malloc系列函数或new操作符分配的内存，如对象；
一般由程序员分配和释放，如果不释放，则出现内存泄露;
特点：容量大，速度慢，无序；
静态区 存放全局变量和静态变量(包括静态局部变量和静态全局变量)；
当程序结束时，系统回收；
常量区 存放常量的内存区域；
程序结束时，系统回收；
代码区 存放二进制代码的区域

了解了这些之后，我们再来具体分析代码和执行结果：

1.全局变量和静态全局变量

这两种变量都存储在静态区，在任何时候都可以访问，所以Block无所谓捕获，而是采用了直接访问的方式成功的修改了它们的值；这一点从Block对应的构造函数中就可以看出来：

__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int *_static_var, int _var, int flags=0) : static_var(_static_var), var(_var);

可以看到，Block的构造函数的参数里只使用到了静态局部变量和自动变量，并没有涉及到全局变量和静态全局变量。

而且我们也在Block的结构体中，也只发现了对应的静态变量和自动变量的属性，这进一步说明Block是直接使用全局变量和静态全局变量，而非捕获的方式；

int *static_val;  //对应静态局部变量
int val;          //对应自动变量
2.自动变量与静态局部变量

虽然自动变量与静态局部变量都被Block捕获，但是只有静态局部变量才可以被修改成功。通过Block中对应的函数__main_block_func_0，可以观察到Block对外部变量的修改过程，相关代码如下：

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  int *static_var = __cself->static_var; // bound by copy
  int var = __cself->var; // bound by copy
            global_var ++;
            static_global_var ++;
            (*static_var) ++;
            NSLog((NSString *)&__NSConstantStringImpl__var_folders_3f_crl5bnj956d806cp7d3ctqhm0000gn_T_TestBlock_b539f1_mi_0,global_var,static_global_var,var,(*static_var));
}

可以看到，Block为了访问到对应的自动变量和静态局部变量都使用了__cself，这些操作其实都是针对Block自身属性的，但不同的是：

  • 外部静态局部变量，由于是指针传递，所以修改的是同一个变量，可以修改成功；
  • 外部自动变量，由于是值传递，所以即使修改成功，也无法改变外部自动变量的值；

因此，也许是出于安全的目的，在编译阶段我们就会收到错误提示：Block不能修改其捕获的外部自动变量，即:

Variable is not assignable(missing __block type specifier)
3.静态局部变量也在静态区，为什么不可以像全局变量一样直接修改？

其实，关键原因还是"局部"两个字，我们看到C++代码中的函数__main_block_func_0被设置在了包含Block语法的main函数之外，而静态局部变量就是在main函数中定义的；

所以，__main_block_func_0和静态局部变量的作用域是不同的，当然不能像全局变量一样随时访问它。因此，还是采用了捕获和指针传递的方式来修改静态局部变量。

4.为什么自动变量不能像静态变量一样指针传递呢？

这主要还是因为自动变量和静态变量的存储域的不同。

自动变量存在栈上，其被销毁的时间不定，这很有可能导致Block执行的时候自动变量已经被销毁，那么此时访问被销毁的地址就会产生野指针错误。

二、理解Block修改外部变量的限制

通过以上的代码示例，我们可以将Block修改外部变量成功的情况分为两种：

  • 第一种：Block直接访问全局性的变量，如全局变量、静态全局变量；
  • 第二种：Block间接访问静态局部变量，捕获外部变量并使用指针传递的方式；

此时，我们把Block中不允许修改外部变量的值的问题，变成了不允许修改自动变量的问题，但这也并非最终答案，其实最根本的原因还是Block不允许修改栈中指针的内容；

下面的一段代码，可以从侧面来验证我们的想法：

#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
  NSMutableString *mStr = @"mStr".mutableCopy;
    void (^myBlock)(void) = ^{
        //mStr = @"newMstr".mutableCopy; //代码1：直接修改了mStr指针内容；
        [mStr appendString:@"-ExtraStr"]; //代码2：修改mStr指向的堆中内容；
        NSLog(@"Block内：mStr:%@",mStr);
    };
    NSLog(@"Block外：%@",mStr);
    myBlock();   
    return 0;
}
//打印结果：
//Block外：mStr
//Block内：mStr:mStr-ExtraStr

上述代码是操作一个自动变量的可变字符串，经过测试mStr不可以直接赋值，却可以通过appendString修改字符串，这其中的原因是什么呢？

首先还是将代码转化为C++源码，具体如下：

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  NSMutableString *mStr;
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, NSMutableString *_mStr, int flags=0) : mStr(_mStr) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself){
  NSMutableString *mStr = __cself->mStr; // bound by copy

        ((void (*)(id, SEL, NSString * _Nonnull))(void *)objc_msgSend)((id)mStr, sel_registerName("appendString:"), (NSString *)&__NSConstantStringImpl__var_folders_3f_crl5bnj956d806cp7d3ctqhm0000gn_T_main_fe0cca_mi_1);
        NSLog((NSString *)&__NSConstantStringImpl__var_folders_3f_crl5bnj956d806cp7d3ctqhm0000gn_T_main_fe0cca_mi_2,mStr);
    }
    
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->mStr, (void*)src->mStr, 3/*BLOCK_FIELD_IS_OBJECT*/);}

static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->mStr, 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[]) {
    NSMutableString *mStr = ((id (*)(id, SEL))(void *)objc_msgSend)((id)&__NSConstantStringImpl__var_folders_3f_crl5bnj956d806cp7d3ctqhm0000gn_T_main_fe0cca_mi_0, sel_registerName("mutableCopy"));
    void (*myBlock)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, mStr, 570425344));

    NSLog((NSString *)&__NSConstantStringImpl__var_folders_3f_crl5bnj956d806cp7d3ctqhm0000gn_T_main_fe0cca_mi_3,mStr);
    ((void (*)(__block_impl *))((__block_impl *)myBlock)->FuncPtr)((__block_impl *)myBlock);
    return 0;
}

作为对象的字符串会涉及到释放的问题，所以此处转换后的源码与基本类型有所区别(但不影响此处分析，后续会讲到)。

我们发现Block捕获了mStr，而且采用了指针传递的方式，这与上面的静态局部变量被捕获的方式很相似，但是mStr依然不可以直接赋值新的字符串。

其实弄清楚问题的关键是理解下面这句代码究做了什么？

mStr = @"newMstr".mutableCopy;

这句代码的含义可以归纳为：

  1. 第一步：@"mStr".mutableCopy创建了新的字符串对象，并将新对象的地址返回；
  2. 第二步：将新对象地址赋值给了mStr；

我们知道mStr指针是在栈上的，它随时可能被释放，直接修改就有可能造成野指针错误，这刚好对应了先前自动变量不可修改的问题；

但通过appendString为什么又可以修改字符串呢？这主要因为mStr通过指针传递被Block捕获后，Block只是借助其内部的指针(和mStr同名，且指向同一个地址)，找到了可变字符串的位置，向这块内存追加新的内容，但是并未改变mStr的内存地址；

重要总结：Block修改外部变量的限制，其实是指Block不允许修改栈中指针的内容；

说白了， block内部可以修改的是堆中的内容， 但不能直接修改栈中的任何东西；

三、理解__block存储域类说明符的原理

通过以上的分析，我们可以将Block理解为"可以带有自动变量值的匿名函数"，但由于存储域的关系，Block并不能直接修改捕获的自动变量。为了解决这个问题，总结起来有两种方案：

  1. 使用存储域在静态区的变量(如全局变量、静态全局变量、静态局部变量)；
  2. 使用存储域类说明符__block；

第一种方案我们已经分析过了，现在重点来理解__block存储域说明符的用法，其实C语言中的还有许多其他存储域类说明符，如：

  • typedef
  • extern
  • static
  • auto
  • register

__block说明符就类似于static、auto、register，它们可以用于指定变量值设置到哪个存储域中。例如，auto表示自动变量存储在栈中(默认)，static表示静态变量存储在数据区中。

下面我们来实际使用__block，使用它来修改被Block捕获的自动变量，具体的代码如下：

//__block存储域修饰符
int main(int argc, const char * argv[]) {
    __block int val = 10;
    void (^myBlock)(void) = ^{ val = 20;};

    val = 30;
    myBlock();
    NSLog(@"val: %@",val);
    return 0;
}

可以看到，Block中修改自动变量却没有像之前那样报错，这说明__block说明符是有效的，为了探究其中原理，现在我们再次把上述代码转换C++代码，具体如下：

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;
  __Block_byref_val_0 *val; // by ref
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_val_0 *_val, int flags=0) : 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
 (val->__forwarding->val) = 20;}
 
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};
    void (*myBlock)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_val_0 *)&val, 570425344));

    (val.__forwarding->val) = 30;
    ((void (*)(__block_impl *))((__block_impl *)myBlock)->FuncPtr)((__block_impl *)myBlock);
    NSLog((NSString *)&__NSConstantStringImpl__var_folders_wd_fhcn9bn91v56nlzv9mt5z8ym0000gn_T_main_a9f88e_mi_0,(val.__forwarding->val));
    return 0;
}

分析代码，我们会发现__block变量的初始化已经发生了根本的变化，此时的自动变量val对应的是C++源码中的__Block_byref_val_0结构体。该结构体包含了五个成员变量，具体定义如下：

struct __Block_byref_val_0 {
  void *__isa;                      //isa指针
__Block_byref_val_0 *__forwarding;  //初始化传递的是自身结构体实例的指针
 int __flags;                       //标记flag
 int __size;                        //大小
 int val;                           //对应原自动变量val的值
};

我们看到__block变量val的初始值为10，而这个值也出现在了调用__Block_byref_val_0结构体构造方法的时候，总结__block变量被捕获的过程如下：

  1. 自动变量__block int varl被封装为__Block_byref_val_0结构体，保存原始变量的指针和值；
  2. __Block_byref_val_0结构体包含一个与__block变量同名的成员变量val，对应外部自动变量的值；
  3. __Block_byref_val_0结构体包含一个__forwarding指针，初始化传递的是自己的地址;
  4. 在Block初始化的过程中，调用__main_block_impl_0结构体构造函数时，会将__block变量的__Block_byref_val_0结构体实例的指针作为参数；

接下来分析给__block变量赋值的代码，转换后的源码如下：

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  __Block_byref_val_0 *val = __cself->val; // bound by ref
 (val->__forwarding->val) = 20;
}

在这里，我们看到函数首先通过cself->val拿到了对应__block变量的结构体实例，然后又通过__Block_byref_val_0结构体实例的成员变量__forwarding，最终访问到了结构体成员变量val；

具体的过程，如下图所示：


分析当前情况，我就会发现这里有两个很关键问题：

  1. 为什么要使用多余的__forwarding指针来间接访问变量？
  2. 当前__block说明符的作用仅仅体现在：将__block变量封装为__Block_byref_val_0结构体，这并未从根本上改变自动变量的性质，自动变量究竟是如何被修改的呢？

为了理解上述问题，我们首先应该对下面的代码有一个更加清晰的了解：

void (^myBlock)(void) = ^{ val = 10;};

代码中创建后的Block直接赋值给了强指针，这其实满足了ARC环境下编辑器对Block的优化：

编译器会自动将Block从栈拷贝到堆上，而Block中的用到的__block变量也会被一并拷贝，并且被堆上的Block持有。

所以，即使是Block语法所在的作用域结束，堆上的Block和__block变量依然继续存在，自然也就不存在自动变量创建在栈上被释放的问题了。

借助图示，理解如下：


另外，当__block变量结构体实例在从栈上被拷贝到堆上时，会将成员变量的__forwarding的值替换为复制目标堆上的__block变量结构体实例的地址。

通过这种功能，无论是在Block语法中、Block语法外使用__block变量，还是__block变量配置在栈上或堆上，都可以顺利访问同__block变量。这就是__forwarding指针存在的意义。

使用图示，理解如下：


重要总结：

  1. __block修饰的自动变量被封装为结构体，作为一个对象随着Block被拷贝到了堆上，解决了自动变量容易因作用域结束而释放的问题。
  2. 而__block变量结构体中的__forwarding则保证了无论在栈上还是堆上访问的都是同一个__block变量；
  3. 我们能够成功修改__block变量的值，其实是修改了堆上被Block持有的__block变量的内部成员变量val；

其他问题：

  1. ARC存在编译器的自动优化，自动拷贝Block的情况还包含了很多种，这里只是其中一种情况，上篇已分析过；
  2. 上述代码中，__block说明符将基本类型的数据封装为结构体类型(其中包含了isa指针)，这其实就说明__block变量已经是作为了一个对象在使用；
  3. 而对象类型被Block捕获之后都会涉及一些释放的问题，所以源码也出现了许多与对象释放相关的函数如：__main_block_copy_0、__main_block_dispose_0等。这个问题后续会详细分析；

四、__block变量的存储域

Block的存储域通常涉及到拷贝的操作，那么对于__block变量又是如何处理的呢？使用__block变量的Block从栈上拷贝到堆上时，__block变量也会受到影响；

1.单个Block中使用__block变量

若一个Block中使用__block变量，则当该Block从栈拷贝到堆上时，使用的所有__block变量也全部被从栈上拷贝到堆上。使用图示理解如下：
<img src="Pictures/Block原理探究/Block原理-在一个Block中使用__block变量.png" width="500" hegiht="313" align=center/>

2.多个Block使用__block变量

多个Block使用__block变量时，任何一个Block从栈上拷贝到堆上，__block变量就会一并从栈上拷贝到堆上并被该Block所持有。当剩下的Block从栈拷贝到堆上时，被拷贝的Block持有__block变量，并增加__block变量的引用计数。使用图示理解如下：

3.__block变量的释放

如果拷贝到堆上的Block被释放，那么它使用的__block变量的引用计数会减一，如果引用计数为0就会被释放。使用图示理解如下：

重要总结：无论是对基本类型还是对象使用__block修饰符，从转化后的源码来看，它们都会被转化为对应的结构体实例来使用，具有引用类型数据的特性。因此__block变量随着Block被拷贝到堆上后，它们的内存管理与普通的OC对象引用计数内存管理模式完全相同。

五、理解Block对对象的捕获

仔细观察之前的源码我们就会发现，Block捕获对象类型和__block类型的变量(在底层被封装为结构体，也属于对象)明显比基本类型要复杂多，其实这里主要是因为对象类型还要涉及到释放的问题。下面的代码演示了Block对对象的捕获的过程，具体如下：

typedef void(^AddBlock)(NSString *); //定义一种携带字符串参数的Block
int main(int argc, const char * argv[]) {
    AddBlock blk = nil;
    {
        NSMutableArray *mArr = @[].mutableCopy;
        blk = ^(NSString *string){
            [mArr addObject:string];
            NSLog(@"mArr count = %ld",[mArr count]);
        };
    }//NSMutableArray所在的作用域结束
    
    blk(@"A");
    blk(@"B");
    blk(@"C");
    return 0;
}

//打印结果：
mArr count = 1
mArr count = 2
mArr count = 3

分析代码：当前为ARC环境下，编译器自动对访问了自动变量的mArr的blk进行了拷贝；所以mArr离开其所在的作用域结束时并没有被释放。虽然mArr指针已经不能使用，但是blk依然保留有对mArr的引用可以找到这块内存。所以代码也是运行正常的；

现在查看编译器转换后的源码如下：

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  NSMutableArray *mArr;
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, NSMutableArray *_mArr, int flags=0) : mArr(_mArr) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->mArr, (void*)src->mArr, 3/*BLOCK_FIELD_IS_OBJECT*/);}

static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->mArr, 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};

由于代码量较大，这里只提供了与捕获基本类型不同的部分；我们发现：

  1. 当Block捕获对象类型的变量时，此处的__main_block_desc_0结构体中多了copy与dispose两个成员变量；
  2. 而且它们的初始化分别使用了__main_block_copy_0和__main_block_dispose_0的函数指针；

这里主要的原因是：

  1. 在Objective-C中，C语言结构体不能含有__strong、__weak修饰符的变量，因为编译器不知道应该如何进行C语言结构的初始化和废弃操作，不能很好地管理内存；
  2. 但是OC的运行时库能够准确把握Block从栈复制到堆以及堆上Block被废弃的时机，所以这里才会增加与内存管理相关的变量和函数。
1.__main_block_copy_0函数

结构体__main_block_desc_0中的copy成员变量对应了__main_block_copy_0函数。

当Block从栈上拷贝到堆上时，__main_block_copy_0函数会被调用，然后再调用其内部的_Block_object_assign函数。_Block_object_assign函数就相当于retain操作，会自动根据__main_block_impl_0结构体内部的mArr是什么类型的指针，对mArr对象产生强引用或者弱引用。如果mArr指针是__strong类型，则为强引用，引用计数+1，如果mArr指针是__weak类型，则为弱引用，引用计数不变。

2.__main_block_dispose_0函数

结构体__main_block_desc_0中的dispose成员变量对应了__main_block_dispose_0函数。
当Block被废弃时，__main_block_dispose_0函数会被调用，__main_block_dispose_0函数就相当于release操作，将mArr对象的引用计数减1，如果此时引用计数为0，那么遵循引用计数的规则mArr也就被释放了。

3.Block捕获对象与__block变量的区别

其实Block捕获对象与__block变量后，对于它们的内存管理的方式相同，也都是使用copy函数持有和disposde函数释放；两者体现在源码上的不同，我们可以观察下面的函数：

static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->mArr, (void*)src->mArr, 3/*BLOCK_FIELD_IS_OBJECT*/);}

_Block_object_assign函数中的最后一个参数用于区分Block捕获的是对象还是__block变量。

对象变量 __block变量
BLOCK_FIELD_IS_OBJECT BLOCK_FIELD_IS_BYREF

六、Block的循环引用问题

Block在从栈拷贝到堆上时，如果其中捕获了强类型的对象，该对象就会被Block所持有。这样很容易就会引起循环引用，我们来看下面的代码：

typedef void(^MyBlock)(void);

@interface MyObject : NSObject
@property(nonatomic,copy) MyBlock block;
@end

@implementation MyObject
- (instancetype)init {
    self = [super init];
    return self;
}

- (void)dealloc {
    NSLog(@"MyObject dealloc!");
}
@end

int main(int argc, char * argv[]) {
    @autoreleasepool {
        MyObject *myObject = [[MyObject alloc] init];
        myObject.block = ^{
            //Capturing 'myObject' strongly in this block is likely to lead to a retain cycle
            NSLog(@"捕获对象:%@", myObject );
        };
    }
    NSLog(@"myObject的作用域结束了");
    return 0;
}

不仅编译器给出了内存泄漏的警告，而且测试结果也证实了MyObject的dealloc实例方法并没有执行，这里发生了循环引用。原因就在与myObject的block在被自动拷贝到堆上的过程中持有了myObject，而myObject本身就持有了block，所以两者相互持有就产生了问题。

现在就来总结类似情况下的Block循环引用的处理方法，可分为ARC和MRC两种情况：

1.解决ARC环境下的循环引用问题

方法1：使用弱引用修饰符__weak、和__unsafe_unretained修饰符；
使用__weak解决上述问题，需要改进的代码如下：

int main(int argc, char * argv[]) {
    @autoreleasepool {
        MyObject *myObject = [[MyObject alloc] init];
        __weak typeof(myObject) weakObject = myObject;
        myObject.block = ^{
            NSLog(@"捕获对象:%@", weakObject );
        };
    }
    NSLog(@"myObject的作用域结束了");
    return 0;
}

上述代码使用弱引用修饰符__weak ，在block内部对 myObject设置为弱引用，弱引用不会导致Block捕获对象的引用计数增加(这在上述分析中已经讲过)。

注意__weak和__unsafe_unretained的区别：

  1. __weak：iOS4之后才提供使用，而且比__unsafe_unretained更加安全，因为当它指向的对象销毁时，会自动将指针置为nil；推荐使用。
  2. __unsafe_unretained：在__weak出现以前常用修饰符，其指向的对象销毁时，指针存储的地址值不变，所以没有__weak安全。

方法2：使用__block说明符
回忆__block修饰基本类型的C++源码，我们可以知道__block修饰对象时其实也会封装一个结构体类型，而这个结构体中会持有自动变量对象，这样就会造成下图的情况：

使用__block解决上述问题，需要改进的代码如下：

int main(int argc, char * argv[]) {
    @autoreleasepool {
        MyObject *myObject = [[MyObject alloc] init];
        __block MyObject *tempObject = myObject;
        myObject.block = ^{
            NSLog(@"捕获对象:%@", tempObject );
            tempObject = nil;  //关键代码1
        };
        myObject.block();      //关键代码2：执行持有的block；
    }
    NSLog(@"myObject的作用域结束了");
    return 0;
}

上述代码有两句关键，已经通过注释标注；在block中通过tempObject = nil这句代码，__block变量tempObject对于MyObject类对象的强引用失效了，而这句代码生效的前提又是block被调用了(关键代码2)；这种方式避免了循环引用的产生的过程如下图：

特别注意：如果关键代码2没有被调用，同样会造成循环引用。

使用__block变量相比弱引用修饰符的优缺点:
优点：

  1. 通过执行block的方式，可动态决定__block变量可以控制对象的持有时间；
  2. 在不能使用__weak修饰符的环境下，避免使用__unsafe_unretained(因为要考虑野指针问题)；

缺点：为了避免循环引用，必须执行Block;

2.解决MRC环境下的循环引用问题

方法1：使用弱引用修饰符__unsafe_unretained修饰符；
在MRC环境下不支持使用__weak，所以只能使用__unsafe_unretained；使用原理同ARC环境下相同，这里不再赘述。

方法2：使用__block说明符
MRC环境下，__block说明符被用来避免循环引用。这是因为当Block从栈拷贝到堆时，若Block使用的变量是附有__block说明符的id类型或者对象类型的自动变量，不会被retain，否则就会被retain。这一点和ARC环境是不同的。现在我们在MRC环境下改进代码，具体如下:

int main(int argc, char * argv[]) {
    MyObject *myObject = [[MyObject alloc] init];
    __unsafe_unretained MyObject *tempObject = myObject;
    myObject.block = ^{
        NSLog(@"捕获对象:%@", tempObject );
    };
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
    [myObject autorelease];
    [pool drain];  //等同于[myObject release];
    return 0;
}
//打印结果：
//MyObject dealloc!

上述操作将代码改为了MRC下的自动释放池，相比之前在ARC中使用__block，这里没有在Block内部置nil的操作，也没有调用block，但同样解决了循环引用的问题；

重要总结：__block说明符在ARC与MRC环境下的用途有很大区别，因此在编写代码时我们必须区分好这两种环境；

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
禁止转载，如需转载请通过简信或评论联系作者。
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 206,839评论 6赞 482
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 88,543评论 2赞 382
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 153,116评论 0赞 344
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 55,371评论 1赞 279
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 64,384评论 5赞 374
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 49,111评论 1赞 285
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 38,416评论 3赞 400
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 37,053评论 0赞 259
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 43,558评论 1赞 300
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 36,007评论 2赞 325
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,117评论 1赞 334
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,756评论 4赞 324
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,324评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,315评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,539评论 1赞 262
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 45,578评论 2赞 355
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,877评论 2赞 345