Block原理探究(上篇)-Block本质及存储域问题

梧雨北辰

发布于 2019-10-08 14:47:12

9590

发布于 2019-10-08 14:47:12

文章被收录于专栏：梧雨北辰的开发录梧雨北辰的开发录

主要内容： 1.理解Block的本质 2.理解Block的存储域分类 3.理解Block的Copy原理

一、探究Block的本质

从一个最简单的Block使用示例说起，我们分析如下代码：

//main.m文件：
#import <Foundation/Foundation.h>
int main(int argc, char * argv[]) {
    int num = 10;
    void (^myBlock)(void) =^{NSLog(@"num = %d",num);};
    myBlock();
    return 0;
}

Objective-C语言是基于C、C++的，为了深入理解Block的底层结构，我们可以通过如下的编译器命令将上述代码转换成C++源码：

clang -rewrite-objc 源代码文件名(如此例中的main.m)

转化后的C++源码如下:

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;
  int num;
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _num, int flags=0) : num(_num) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  int num = __cself->num; // bound by copy
NSLog((NSString *)&__NSConstantStringImpl__var_folders_wd_fhcn9bn91v56nlzv9mt5z8ym0000gn_T_main_9e3646_mi_0,num);}

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 num = 10;
    void (*myBlock)(void) =((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, num));
    ((void (*)(__block_impl *))((__block_impl *)myBlock)->FuncPtr)((__block_impl *)myBlock);
    return 0;
}

对比OC代码与C++源码中的main函数，我们发现创建Block其实是调用了__main_block_impl_0结构体的构造函数；而Block中待执行代码也都被封装到了__main_block_func_0函数中。

另外值得注意的是，这些C++的结构体和函数的命名，是根据Block语法所属的函数名(此处为main)和Block语法在该函数出现的顺序值(此处为0)来设定的；

根据这些对应关系，我们对C++源码中的内容一一分析：

1.__main_block_imp_0结构体

__main_block_impl_0结构体对应了Block的定义，结构体内部包含了三个成员变量impl、Desc、num，num其实就是被捕获的变量(后续再讲)，另外还有一个同名的构造函数__main_block_impl_0；具体代码如下：

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

Block通过调用这里的构造函数得以创建，调用时需传入了四个参数：(void *fp, struct __main_block_desc_0 *desc, int _num, int flags=0)，前三个参数对应成员变量的初始化，而最后一个参数flags携带默认值可暂不考虑。

2.__block_impl结构体

__main_block_imp_0结构体的第一个成员变量impl，就是__block_impl结构体类型；尤其注意该结构体中包含有isa指针，从这一点就可以说明Block本质上还是一个OC对象，因为OC中只有对象才会具有isa指针的概念。而FuncPtr是一个函数指针，在__main_block_imp_0构造函数调用时被赋值；

3.__main_block_desc_0结构体

__main_block_imp_0结构体构造函数中传入参数desc，其实就是__main_block_desc_0对象。该结构体包含两个成员变量： reserved：系统保留值 Block_size：代表Block的大小

4.__main_block_func_0函数

__main_block_imp_0结构体构造函数中传入函数指针fp，其实就是__main_block_func_0函数的地址。该函数将Block中所有的代码封装为函数，以待被调用；

重要总结： 1.Block对应底层__main_block_impl_0结构体，其中包含有isa指针，这说明Block本质上还是一个OC对象； 2.Block中待执行的代码，在底层也被封装为__main_block_func_0函数，以实现调用；说明Block还携带了函数执行的环境

Block的特点： 1.Block相当于其他语言中的闭包或者匿名函数； 2.Block与函数区别在于，Block相当于函数加上函数执行的上下文环境(捕获外部变量下面会讲到)；

二、Block的存储域

1.Block的存储域分类

在之前Block结构体构造函数中，我们很容易能找到这样一句代码：

impl.isa = &_NSConcreteStackBlock;

我们已经知道Block也是一个Objective-C对象，每个OC对象都有一个isa指针指向其类对象，这里的情况也是类似的；Block的isa指针指向了_NSConcreteStackBlock类对象，即此时的Block是以_NSConcreteStackBlock类为模板创建的实例；

除此之外，其实还有两个与之类似的类_NSConcreteGlobalBlock和_NSConcreteMallocBlock，不同的Block类创建的对象用于不同的存储域，也对应了对应不同的OC类型，具体整理如下：

clang类	OC类	内存区域
_NSConcreteGlobalBlock	NSGlobalBlock	静态区
_NSConcreteStackBlock	NSStackBlock	栈区
_NSConcreteMallocBlock	NSMallocBlock	堆区

下面通过打印的方式验证Block对象本质，具体代码如下：

- (void)testBlock5 {
    void(^block)(int a) = ^(int a) {
        NSLog(@"This is a block");
    };
    
    NSLog(@"%@",[block class]);
    NSLog(@"%@",[[block class] superclass]);
    NSLog(@"%@",[[[block class] superclass] superclass]);
    NSLog(@"%@",[[[[block class] superclass] superclass] superclass]);
}

//打印结果：
//__NSGlobalBlock__
//__NSGlobalBlock
//NSBlock
//NSObject

观察打印结果，我们看到Block最终继承于NSObject类型，这又一次验证了Block本质就是OC对象的结论；而打印结果中出现的__NSGlobalBlock__说明此处的Block的存储域为静态区；

2.区分Block不同存储域类型的方法

Block的不同存储域对其的使用影响巨大，而正确区分Block类型的关键在于：Block中是否引用了自动变量(需要MRC下测试)，总结起来如下：

Block类型	环境	内存区域
_NSConcreteGlobalBlock( NSGlobalBlock)	没有访问自动变量；或者只用到静态区变量	静态区
_NSConcreteStackBlock( NSStackBlock)	访问了自动变量	栈区
_NSConcreteMallocBlock( NSMallocBlock)	NSStackBlock调用了copy	堆区

我们可以使用代码对上述情况进行验证，但需要首先切换ARC到MRC环境下，因为在ARC环境下的编译器为我们做了很多优化的工作，比如自动将栈区的Block拷贝到堆区，这样我们也就不容易捕获到Block初始状态的位置了。所以需要暂时将开发环境切换至MRC下来测试。相关的测试代码如下：

- (void)testBlock7 {
    //1.Block内部没有调用外部自动变量
    void (^block1)(void) = ^{
        NSLog(@"Block");
    };
    
    //2.Block内部调用外部自动变量
    int a = 10;
    void (^block2)(void) = ^{
        NSLog(@"Block-%d",a);
    };
    
    //3.拷贝栈上的block
    void (^block3)(void) = ^{
        NSLog(@"Block-%d",a);
    };
    
    //打印Block类型
    NSLog(@"%@ %@ %@", [block1 class], [block2 class], [[block3 copy] class]);
}

//打印结果：
//__NSGlobalBlock__ __NSStackBlock__ __NSMallocBlock__

分析代码： NSGlobalBlock：Block中没有引用自动变量或者只用到静态区变量，这种Block与全局变量一样设置在程序的静态区，直到程序结束才会被回收；此类型的Block不依赖执行时的状态，所以整个程序只需一个实例，用的也较少；

NSStackBlock：Block中访问自动变量，并且存放在栈中，栈中的内存由系统自动分配和释放，作用域执行完毕之后就会被立即释放；所以我们有可能遇到Block内存销毁之后才使用它的情况，开发中遇到的很多问题也都是因此而起；

NSMallocBlock：_NSStackBlock__执行copy操作会生成__NSMallocBlock__；栈Block被拷贝后存放在堆中后，需要我们自己进行内存管理，否则还可能造成一些循环引用的问题；

三、Block的Copy的问题

Block有着不同的存储域类型，尤其是配置在栈上的Block(即__NSStackBlock__类型的Block)，如果其所属的作用域结束该Block就会被释放。此时若继续使用Block，就需要执行copy操作，将其由栈区拷贝到堆区得到__NSMallocBlock__，而__NSMallocBlock__也会在其引用计数为0的时候被释放；

关于Block的拷贝，其实还需要分为MRC和ARC两种环境来考虑，下面是具体的分析：

1.MRC下的Block拷贝

在MRC环境下，我们只能显式的通过copy来实现Block的拷贝；通常为了避免Block的释放，我们定义Block属性的时候必须使用copy修饰符也正是基于这个原因。下面是在MRC环境下测试栈Block的使用，具体代码如下：

typedef void(^PrintBlock)(void);

@interface ViewController ()
@property (nonatomic ,copy)PrintBlock block1;
@property (nonatomic ,copy)PrintBlock block2;
@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    [self createBlock];
    self.block1();
    self.block2();
    NSLog(@"block1:%@", [self.block1 class]); //报错Thread 1: EXC_BAD_ACCESS (code=1, address=0x7ffeeb90b8c0)
    NSLog(@"block2:%@", [self.block2 class]);
}

- (void)createBlock {
    int a = 10;
    //此处采用直接赋值的方式，不会触发setter方法
    _block1 = ^{
        NSLog(@"This is block1-%d",a);
    };
    
    self.block2 = ^{
        NSLog(@"This is block2-%d",a);
    };
    //离开此作用域，block1就会被释放
    NSLog(@"block1:%@、block2:%@", [self.block1 class],[self.block2 class]);
}
@end

打印结果及分析如下：

block1:__NSStackBlock__、block2:__NSMallocBlock__
This is block1-10
This is block2-10

由于block1采用的是直接赋值的方式，没有调用setter方法，所以block1并没有被拷贝到堆上，是一个栈上的Block，这样也就直接导致了第二次打印block1时所发生的野指针崩溃；

2.ARC下的Block拷贝

在ARC环境下，编译器会根据情况自动将栈上的Block复制到堆上，总结起来包含以下几种情况:

Block作为函数返回值时；这就类似与MRC中对返回值Block执行了[[returnedBlock copy] autorelease];
Block被强引用，如Block被赋值给__strong或者id类型；
Block作为GCD API的方法参数时；
Block作为系统方法名含有usingBlock的方法参数时;

下面的代码演示了这些情况：

typedef void(^Block)(void);
-(Block)getBlock{
    //ARC下的Block中访问了auto变量，此时block类型应为__NSStackBlock__
   int a = 10;
   return  ^{
        NSLog(@"---------%d", a);
    };
}

- (void)testBlock9 {
    //1.测试block作为函数返回值时
    NSLog(@"bock1-：%@",[[self getBlock] class]);
    
    //2.测试将block赋值给__strong指针时
    int a = 10;
    
    //2.1.block内没有访问auto变量
    Block block21 = ^{
        NSLog(@"block21");
    };
    NSLog(@"block21-%@",[block21 class]);
    
    //2.2.block内访问了auto变量，但没有赋值给__strong指针
    NSLog(@"block22-%@",[^{
        NSLog(@"block22-%d", a);
    } class]);

    //2.3.block赋值给__strong指针
    Block block23 = ^{
        NSLog(@"block23");
    };
    NSLog(@"block23-%@",[block23 class]);
    
    //3.block作为Cocoa API中方法名含有usingBlock的方法参数时
    NSArray *array = @[@"1",@"2",@"3"];
    [array enumerateObjectsUsingBlock:^(id  _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {
        
    }];
    
    //4.block作为GCD API的方法参数时
    //Block中的延时操作完成时，系统将会对Block进行释放
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        
    });
}

//打印结果如下:
//bock1-：__NSMallocBlock__
//block21-__NSGlobalBlock__
//block22-__NSStackBlock__
//block23-__NSGlobalBlock__

3.其他存储域Block的拷贝

上面讲述的重点都于对栈Blok的拷贝，若是对于已经配置在堆上或者配置在静态区的上的Block调用copy方法又将如何呢？下面是不同存储域的Block执行copy进行的总结：

Block类型	副本源的配置存储域	复制效果
_NSConcreteStackBlock	栈区	从栈复制到堆
_NSConcreteGlobalBlock	静态区	什么也不做
_NSConcreteMallocBlock	堆区	引用增加

4. 总结Block需要拷贝的原理

Block默认创建于其所在函数的函数栈上，所以当函数作用域结束时就会随之销毁；

在MRC环境下，没有编译器的优化，所以我们非常强调要使用copy将Block拷贝到堆上，从而避免Block在其作用域结束时被直接释放;

在ARC环境下，编译器会根据情况自动将栈上的Block复制到堆上，对于Block使用copy还是strong效果是一样的，所以写不写copy都行。在ARC环境下对于Block依然使用copy，更像是从MRC遗留下来的“传统”，时刻提醒我们：编译器自动对Block进行了拷贝操作。如果不写copy ，该类的调用者有可能会忘记或者根本不知道“编译器会自动对Block进行了拷贝操作”，他们有可能会在调用之前自行拷贝属性值，这种操作多余而低效。

最后，总结Block修饰符的使用：

//MRC下block属性的建议写法：
@property (copy, nonatomic) void (^block)(void);

//ARC下block属性的建议写法：
@property (strong, nonatomic) void (^block)(void);
@property (copy, nonatomic) void (^block)(void);