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环境下,编译器自动对访问了自动变量的mArrblk进行了拷贝;所以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结构体中多了copydispose两个成员变量;
  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;
}

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

现在就来总结类似情况下的Block循环引用的处理方法,可分为ARCMRC两种情况:

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. __weakiOS4之后才提供使用,而且比__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说明符在ARCMRC环境下的用途有很大区别,因此在编写代码时我们必须区分好这两种环境;

最后编辑于
©著作权归作者所有,转载或内容合作请联系作者
禁止转载,如需转载请通过简信或评论联系作者。
  • 序言:七十年代末,一起剥皮案震惊了整个滨河市,随后出现的几起案子,更是在滨河造成了极大的恐慌,老刑警刘岩,带你破解...
    沈念sama阅读 203,271评论 5 476
  • 序言:滨河连续发生了三起死亡事件,死亡现场离奇诡异,居然都是意外死亡,警方通过查阅死者的电脑和手机,发现死者居然都...
    沈念sama阅读 85,275评论 2 380
  • 文/潘晓璐 我一进店门,熙熙楼的掌柜王于贵愁眉苦脸地迎上来,“玉大人,你说我怎么就摊上这事。” “怎么了?”我有些...
    开封第一讲书人阅读 150,151评论 0 336
  • 文/不坏的土叔 我叫张陵,是天一观的道长。 经常有香客问我,道长,这世上最难降的妖魔是什么? 我笑而不...
    开封第一讲书人阅读 54,550评论 1 273
  • 正文 为了忘掉前任,我火速办了婚礼,结果婚礼上,老公的妹妹穿的比我还像新娘。我一直安慰自己,他们只是感情好,可当我...
    茶点故事阅读 63,553评论 5 365
  • 文/花漫 我一把揭开白布。 她就那样静静地躺着,像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上,一...
    开封第一讲书人阅读 48,559评论 1 281
  • 那天,我揣着相机与录音,去河边找鬼。 笑死,一个胖子当着我的面吹牛,可吹牛的内容都是我干的。 我是一名探鬼主播,决...
    沈念sama阅读 37,924评论 3 395
  • 文/苍兰香墨 我猛地睁开眼,长吁一口气:“原来是场噩梦啊……” “哼!你这毒妇竟也来了?” 一声冷哼从身侧响起,我...
    开封第一讲书人阅读 36,580评论 0 257
  • 序言:老挝万荣一对情侣失踪,失踪者是张志新(化名)和其女友刘颖,没想到半个月后,有当地人在树林里发现了一具尸体,经...
    沈念sama阅读 40,826评论 1 297
  • 正文 独居荒郊野岭守林人离奇死亡,尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,578评论 2 320
  • 正文 我和宋清朗相恋三年,在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,661评论 1 329
  • 序言:一个原本活蹦乱跳的男人离奇死亡,死状恐怖,灵堂内的尸体忽然破棺而出,到底是诈尸还是另有隐情,我是刑警宁泽,带...
    沈念sama阅读 33,363评论 4 318
  • 正文 年R本政府宣布,位于F岛的核电站,受9级特大地震影响,放射性物质发生泄漏。R本人自食恶果不足惜,却给世界环境...
    茶点故事阅读 38,940评论 3 307
  • 文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹,春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,926评论 0 19
  • 文/苍兰香墨 我抬头看了看天上的太阳。三九已至,却和暖如春,着一层夹袄步出监牢的瞬间,已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,156评论 1 259
  • 我被黑心中介骗来泰国打工, 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留,地道东北人。 一个月前我还...
    沈念sama阅读 42,872评论 2 349
  • 正文 我出身青楼,却偏偏与公主长得像,于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子,可洞房花烛夜当晚...
    茶点故事阅读 42,391评论 2 342