iOS底层原理总结探寻block本质(一)

释放双眼,带上耳机,听听看~!

上一篇iOS底层原理总结探寻block本质(二):

本篇学习总结:

  • 探寻block的本质
  • 代码验证block底层实现
  • block的变量捕获
  • block的类型
  • block内存储存
  • ARC跟MRC下block的特性

好了,带着问题,我们一一开始阅读吧 ?

一.探寻block的本质

我们说到block并不陌生,先写一个简单的block代码

int main(int argc, const char * argv[]) {
@autoreleasepool {
int age = 10;
void(^block)(int ,int) = ^(int a, int b){
NSLog(@"this is block,a = %d,b = %d",a,b);
NSLog(@"this is block,age = %d",age);
};
block(3,5);
}
return 0;
}
//打印结果如下
this is block,a = 3,b = 5
this is block,age = 10

然后用命令行转化成c++文件

xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m

这些在前面的文章中都讲过了,可以回去直接查找。
我们搜索int main 可以看到如下结果

main函数转化成c++文件.png

我们可以看到一个__main_block_impl_0 ,全局搜索__main_block_impl_0,搜索如下结果:

oc跟c++代码对比.png

那么我们将c++中block的声明和调用部分分别取出来看一下内部实现是怎么样的

1.定义block变量

// 定义block变量代码
void(*block)(int ,int) = ((void (*)(int, int))&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, age));

上述定义的代码中可以发现,block定义中调用了__main_block_impl_0函数,并且将__main_block_impl_0函数的地址赋给了block,我们再来看一下__main_block_impl_0函数结构

2.__main_block_imp_0结构体

__main_block_imp_0函数内部结构.png

__main_block_impl_0函数中包含如下信息:
struct __block_impl impl :结构体封装了定义block的块内容,即^{}
struct __main_block_desc_0 Desc :结构体封装了定义block的大小
int age:这个age属性是block块中捕获的局部变量age
__main_block_impl_0():同名构造函数,构造函数中对一些变量进行了赋值最终会返回一个结构体,也就是说最终将一个__main_block_imp_0结构体的地址赋值给block变量,__main_block_imp_0结构体内可以发现传入了四个参数,(void *)__main_block_func_0、&__main_block_desc_0_DATA、age、flags*。其中flage有默认值,也就说flage参数在调用的时候可以省略不传,而最后的age(_age)则表示传入的_age参数会自动赋值给age成员,相当于age=_age。

3. (void )__main_block_func_0函数

__main_block_func_0函数.png

__main_block_func_0函数中看到局部变量age的值,紧接着可以看到两个NSLog方法,可以发现这两段代码恰恰是我们在block块中写下的代码。
__main_block_func_0函数中其实存储着我们block中写下的代码,而__main_block_impl_0函数中传入的是(void )__main_block_func_0,也就说将我们写的block块中的代码封装成__main_block_func_0函数,并将__main_block_func_0函数的地址传入了__main_block_impl_0的构造函数中保存到结构体内。

4.&__main_block_desc_0_DATA

& __main_block_desc_0_DATA结构体数据.png

我们可以看到__main_block_desc_0结构体中存储着两个参数,reservedBlock_size,其中reserved赋值为0,而Block_size则存储着__main_block_impl_0的占用空间大小,最后将__main_block_desc_0结构体的地址传入__main_block_func_0中赋值给Desc。

5.age

age是我们在最初定义的局部变量,因为在block块中使用到age局部变量,所以在block声明的时候这里才会将age作为参数传入,也就说block会捕获age,如果没有在block中使用age,这里将只会传入(void *)__main_block_func_0&__main_block_desc_0_DATA两个参数。
以上就是我们对block底层结构的分析。

这里我们再来思考一个问题,为什么我们在定义block之后修改局部变量age的值,在block调用的时候无法生效呢?

int age = 10;
void(^block)(int ,int) = ^(int a, int b){
NSLog(@"this is block,a = %d,b = %d",a,b);
NSLog(@"this is block,age = %d",age);
};
age = 20;
block(3,5);
//打印结果如下:
this is block,a = 3,b = 5
this is block,age = 10

因为block在定义的时候已经将age的值传入并存储在__main_block_imp_0结构体中,在调用的时候将age从block中取出来使用,因此在block定义后对局部变量进行修改在block捕获的局部变量中是无法更改的。

我们分析完了main函数中构造block的各个参数,我们点击__main_block_impl_0找到对应结构体,我们看__block_impl结构体。

6. __block_impl

__block_impl结构体内部.png

我们发现在__block_impl结构体内部有一个 isa指针,可以推测block本质上就是一个oc对象,而在构造函数中将函数中传入的值分别存储在__main_block_impl_0结构体实例中,最终将其结构体的地址赋值给block。
接着通过上面对__main_block_impl_0结构体构造函数三个参数的分析我们可以得出结论:

  1. __block_impl结构体中的isa指针存储着& _NSConcreteStackBlock地址,可以暂时理解为其类对象的地址,block就是_NSConcreteStackBlock类型的。
  2. block代码块中的代码被封装在__main_block_func_0函数中,FuncPtr则存储着__main_block_func_0函数的地址。
  3. Desc指向__main_block_desc_0结构体对象,其中存储__main_block_impl_0结构体所占用的内存。

7.调用block执行内部代码

((void (*)(__block_impl *, int, int))((__block_impl *)block)->FuncPtr)((__block_impl *)block, 3, 5);

通过上述代码可以发现调用block是通过block找到FunPtr直接调用。

为什么block可以直接调用FunPtr呢?

通过上面分析我们知道block指向的是__main_block_impl_0类型的结构体,但是我们发现__main_block_impl_0结构体中并不直接可以找到FunPtr,而FunPtr是存储在__block_impl中的。重新查看上述源码可以发现,(__block_impl *)block将block强制转化为__block_impl类型的,因为__block_impl__main_block_impl_0结构体第一个成员变量,相当于将__block_impl结构体的成员直接拿出来放在__main_block_impl_0中,那么也可以说明__block_impl的内存地址就是__main_block_impl_0结构体的内存地址开头,所以将block强制转化成(__block_impl *)block)是可以的,那我们通过block调用FuncPtr也是可以的。
上面我们知道,FunPtr中存储通过代码封装的函数地址,那么调用此函数,也就是会执行代码块中的代码。并且回头查看__main_block_func_0函数,可以发现第一个参数就是__main_block_impl_0类型的指针,也就说将block传入__main_block_func_0函数中,便于重新取出block捕获的值。

二.代码验证block的本质

通过代码证明一下block的本质确实是__main_block_impl_0结构体类型。
还是使用之前的方法,自定义block内部结构体,并将block内部的结构体强制转化为自定义的结构体。

先上一段代码:

struct __main_block_desc_0 {
size_t reserved;
size_t Block_size;
};
struct __block_impl {
void *isa;
int Flags;
int Reserved;
void *FuncPtr;
};
// 模仿系统__main_block_impl_0结构体
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
int age;
};
int main(int argc, const char * argv[]) {
@autoreleasepool {
int age = 10;
void(^block)(int ,int) = ^(int a, int b){
NSLog(@"this is block,a = %d,b = %d",a,b);
NSLog(@"this is block,age = %d",age);
};
// 将底层的结构体强制转化为我们自己写的结构体,通过我们自定义的结构体探寻block底层结构体
struct __main_block_impl_0 *blockStruct = (__bridge struct __main_block_impl_0 *)block;
block(3,5);
}
return 0;
}

通过打断点我们可以看出我们自定义的结构体被赋值成功,每个类型的变量都能看到数据

转化结构__main_block_impl_0.png

总结
此时已经对block的底层结构有了基本的认识,上述代码可以通过一张图展示其中各个结构体之间的关系

block底层结构关系图.png

 

block底层的数据也可以通过一张图来展示:

block底层的数据结构.png
三.block的变量捕获

为了保证block内部能够正常访问外部的变量,block有一个变量捕获的机制。

1.局部变量

auto变量

上述代码中我们已经了解过block对age变量的捕获。
auto自动变量,离开作用域就销毁,局部变量默认添加auto关键字。自动变量会被捕获到block内部,也就是说block内部结构中会自动生成一个局部变量数据,存储捕获的变量数据。auto只存在局部变量中,传递方式为值传递,通过对上述age变量在block后修改,block中的age并没有改变可以看出确实是值传递。

static变量
static修饰的变量为指针传递,同样会被block捕获
我们通过代码看一下这两者的区别:

int main(int argc, const char * argv[]) {
@autoreleasepool {
auto int a = 10;
static int b = 11;
void(^block)(void) = ^{
NSLog(@"hello, a = %d, b = %d", a,b);
};
a = 1;
b = 2;
block();
}
return 0;
}

重新生成main.cpp文件,可以看到两个参数的区别

 

两个参数转化代码.png

从上述代码中可以看出,a,b两个基本数据类型的变量都捕获到block内部了,但是a传入的是值,b传入的是b变量的地址。

说明局部变量不管用auto修饰还是static修饰,都能被捕获到block底层结构体中,只不过auto是值传递,block中不能修改捕获变量数据,static是指针传递,block中修改捕获变量数据

修改block内捕获变量的数值.png

同样是局部变量,为啥会有差异呢?

因为自动变量离开作用域就会自动销毁,系统自动管理内存,block在执行的时候刚要用这个局部变量时发现局部变量已经销毁了,那么此时如果再去访问被销毁的地址肯定会发生坏内存访问,所以出于此考虑,block对于auto自动变量的捕获也得是值传递而不能是指针传递。而static修饰的局部变量超出作用域也不会销毁,会继续在内存中保存,所以完全可以是值传递,方便后期block及时调用内部捕获变量的数据。

2.全局变量

还是先上代码

int a = 0;
static int b = 0;
int main(int argc, const char * argv[]) {
@autoreleasepool {
void(^block)(void) = ^{
NSLog(@"hello, a = %d, b = %d", a,b);
};
a = 10;
b = 20;
block();
}
return 0;
}
//打印结果如下:
hello, a = 10, b = 20

转化成c++文件

 

全局变量c++代码.png

通过上述代码可以发现,__main_block_imp_0结构体中并没有添加任何变量,而是添加到__main_block_imp_0结构体的上面了,因此block不需要捕获全局变量,因为全局变量无论在哪里都可以访问。

局部变量以为跨函数访问所以需要捕获,全局变量在哪里都可以访问,所以不需要捕获。

最后用一张图总结上述结论,方便记忆:

 

block的变量捕获总结.png

如果我们在实例方法或者类方法中添加block,会捕获变量吗?
还是上代码吧

#import "Person.h"
@implementation Person
- (void)test
{
void(^block)(void) = ^{
NSLog(@"%@",self);
};
block();
}
- (instancetype)initWithName:(NSString *)name
{
if (self = [super init]) {
self.name = name;
}
return self;
}
+ (void) test2
{
NSLog(@"类方法test2");
}
@end

同样转化为c++代码查看其内部结构

 

c++转化代码.png

上图中可以发现,self同样被block捕获,接着我们找到test方法可以发现,test方法默认传递了两个参数self_cmd,而类方法test2也同样默认传递了类对象self和方法选择器_cmd

对象方法和类方法对比.png

不论对象方法还是类方法都会默认将self作为参数传递给方法内部,既然是作为参数传入,那么self肯定是局部变量,上面讲到了局部变量肯定会被block捕获。
接着我们来看一下如果在block中使用成员变量或者调用实例的属性会有什么不同的结果。

- (void)test
{
void(^block)(void) = ^{
NSLog(@"%@",self.name);
NSLog(@"%@",_name);
};
block();
}
c++ 代码.png

上图中可以发现,即使block中使用的是实例对象的属性,block中捕获的仍然是实例对象,并通过实例对象通过不同的方式去获取使用到的属性。

四.block的类型

block对象是什么类型,之前稍微提到过,通过源码可以知道block中的isa指针指向的是_NSConcreteStackBlock类对象地址。那么block是否就是_NSConcreteStackBlock类型的呢?
还是先上代码

int main(int argc, const char * argv[]) {
@autoreleasepool {
// __NSGlobalBlock__ : __NSGlobalBlock : NSBlock : NSObject
void (^block)(void) = ^{
NSLog(@"Hello");
};
NSLog(@"%@", [block class]);
NSLog(@"%@", [[block class] superclass]);
NSLog(@"%@", [[[block class] superclass] superclass]);
NSLog(@"%@", [[[[block class] superclass] superclass] superclass]);
}
return 0;
}

打印结果如下:

 

block类型打印.png

从上述打印内容可以看出block最终都是继承自NSBlock类型,而NSBlock继承于NSObject,那么block其实都是继承NSObject,这也更加印证了block的本质就是OC对象。

block的3种类型

  • NSGlobalBlock ( _NSConcreteGlobalBlock )
  • NSStackBlock ( _NSConcreteStackBlock )
  • NSMallocBlock ( _NSConcreteMallocBlock )

通过代码查看一下block在什么情况下会是什么类型呢?

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 = %@ block2 = %@ 直接调用 = %@", [block1 class], [block2 class], [^{
NSLog(@"%d",a);
} class]);
}
return 0;
}
//打印结果如下:
block1 = __NSGlobalBlock__
block2 = __NSMallocBlock__
直接调用 = __NSStackBlock__

但是我们上面提到过,上述代码转化为c++代码查看源码时发现block的类型与打印出来的类型不一样,c++源码中三个block的isa指针全部都指向_NSConcreteStackBlock类型地址。
我们可以猜测runtime运行时也许对类型进行了转变。最终类型当然以runtime运行时类型即我们打印出来的类型为准。

五.block内存储存

1.block内存分配地址

不同类型的block存放区域.png

从上图可以看出,__NSGlobalBlock__存放在数据段中,数据段信息中存储的变量生命周期跟随应用程序的生命周期存在,程序结束时变量内存地址被回收,不过我们一般很少使用__NSGlobalBlock__类型的block,因为这样的block并没有什么意义。

__NSStackBlock__类型的block存放在栈中,我们知道栈中的内存由系统自动分配和释放,作用域结束后被立刻释放,而在相同的作用域中定义block并且调用block似乎也多此一举。

__NSMallocBlock__类型的block存放在堆上,内存需要我们自己内存管理。

2.block类型定义依据

block定义类型的依据.png

接着我们使用代码验证上述问题,首先从ARC回到MRC环境,因为ARC会帮助我们做很多事情,有些问题我们检验不出来。

切换MRC环境.png

还是刚才的代码
MRC 环境!!!

MRC 环境!!!
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 = %@ block2 = %@ 直接调用 = %@", [block1 class], [block2 class], [^{
NSLog(@"%d",a);
} class]);
}
return 0;
}
//打印结果如下:
block1 = __NSGlobalBlock__
block2 = __NSStackBlock__
直接调用 = __NSStackBlock

通过上述代码发现,

在MRC环境下,
没有访问auto变量的block是__NSGlobalBlock__类型的,存放在数据段中。
访问了auto变量的block是__NSStackBlock__类型的,存放在栈中。

栈中的内存管理是系统自动管理,栈中的代码在作用域结束之后就会被销毁,那么我们很有可能在block内存销毁以后去调用它,那么就会发现问题,代码验证访问坏内存问题。

void (^block)(void);
void test()
{
// __NSStackBlock__
int a = 10;
block = ^{
NSLog(@"block---------%d", a);
};
}
int main(int argc, const char * argv[]) {
@autoreleasepool {
test();
block();
}
return 0;
}
//打印结果:
block----------272632792

可以发现block中的a数据变成了不可控数据,因为在MRC环境下,test()方法中声明的block是在栈中创建,当test()方法调用完毕,block所占内存空间会自动被系统回收,因此当我们在调用block()时,访问被释放内存区域,数据就会不可控。

通过查看c++转化代码也能看出来

 

c++代码.png

为了避免这种情况,在MRC环境下我们手动给NSStackBlock类型添加copy方法会转化成NSMallocBlock类型的block,NSMallocBlock类型的block存储在堆上,block内存系统是手动释放
先上代码

void (^block)(void);
void test()
{
// __NSStackBlock__ 调用copy 转化为__NSMallocBlock__
int age = 10;
block = [^{
NSLog(@"block---------%d", age);
} copy];
[block release];
}
int main(int argc, const char * argv[]) {
@autoreleasepool {
test();
block();
}
return 0;
}
//打印结果:
block---------10

同样的代码,我们切换到ARC环境
ARC环境!!

ARC环境!!
void (^block)(void);
void test()
{
// __NSStackBlock__
int a = 10;
block = ^{
NSLog(@"block---------%d", a);
};
}
int main(int argc, const char * argv[]) {
@autoreleasepool {
test();
block();
}
return 0;
//打印结果:
block---------10
}

总结:在MRC环境下经常使用copy来保存__NSStackBlock__,将栈上的block拷贝到堆上,即使栈上的block被销毁,堆上的block不会被销毁,需要我们自己调用release操作来销毁,而在ARC环境下编译器会自动copy,堆上的block也不会被销毁。

那么其他类型的block调用copy会改变block类型吗?下面的表格已经展示很清晰了

不同类型调用copy结果.png
六.ARC跟MRC下block的特性

在ARC环境下,编译器会根据情况自动将栈上的block进行一次copy操作,将block复制到堆上。
什么情况下ARC会自动将block进行一次copy操作呢?(下面代码都在ARC环境下进行)

1.block作为函数返回值时

typedef void(^MyBlock)();
MyBlock test (){
int a = 10;
MyBlock myblock = ^{
NSLog(@"a ==== %d",a);
};
return myblock;
}
int main(int argc, const char * argv[]) {
@autoreleasepool {
MyBlock block = test();
block();
// 打印block类型为 __NSMallocBlock__
NSLog(@"%@",[block class]);
}
return 0;
//打印结果:
a ==== 10
__NSMallocBlock__
}

上文提到过,如果在block中访问了auto变量时,block的类型为__NSStackBlock__,上面打印内容发现blcok为__NSMallocBlock__类型的,并且可以正常打印出a的值,说明block内存并没有被销毁。
上面提到过,block进行copy操作会转化为__NSMallocBlock__类型,来讲block复制到堆中,那么说明RAC在 block作为函数返回值时会自动帮助我们对block进行copy操作,以保存block,并在适当的地方进行release操作。

2.将block赋值给__strong指针时
block被强指针引用时,ARC也会自动对block进行一次copy操作。

int main(int argc, const char * argv[]) {
@autoreleasepool {
// 1.block内没有访问auto变量,赋值给__strong指针
Block block = ^{
NSLog(@"block---------");
};
NSLog(@"block--------%@",[block class]);
int a = 10;
// 2.block内访问了auto变量,但没有赋值给__strong指针
NSLog(@"block1--------%@",[^{
NSLog(@"block1---------%d", a);
} class]);
// 3.block内访问auto变量,赋值给__strong指针
Block block2 = ^{
NSLog(@"block2---------%d", a);
};
NSLog(@"block2-------%@",[block2 class]);
}
return 0;
}
//打印结果如下:
block--------__NSGlobalBlock__
block1--------__NSStackBlock__
block2-------__NSMallocBlock__

可以看出,__NSGlobalBlock__变量即使赋值给__strong指针也是__NSGlobalBlock__变量类型,__NSStackBlock__变量不赋值给__strong指针还是__NSStackBlock__类型,赋值给__strong指针时会变成__NSMallocBlock__类型

3.block作为Cocoa API中方法名含有usingBlock的方法参数时
例如:遍历数组的block方法,将block作为参数的时候

NSArray *array = @[];
[array enumerateObjectsUsingBlock:^(id  _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {
}];

4.block作为GCD API的方法参数时
例如:GDC的一次性函数或延迟执行的函数,执行完block操作之后系统才会对block进行release操作

static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
});
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
});

5.block声明建议写法
通过上面对MRC及ARC环境下block的不同类型的分析,总结出不同环境下block属性建议写法。

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

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

因为block内容有点多,面试题总结在下一篇。
本篇学习先记录到此,感谢阅读,如有错误,不吝赐教。

人已赞赏
iOS文章

iOS底层原理总结 - 探寻Runtime本质(一)

2020-5-11 4:33:40

iOS文章

iOS底层原理总结探寻block本质(二)

2020-5-11 5:48:13

0 条回复 A文章作者 M管理员
    暂无讨论,说说你的看法吧
个人中心
购物车
优惠劵
今日签到
有新私信 私信列表
搜索