iOS底层原理总结 - 探寻block的本质（一）

时间  2019-11-07
标签 ios 底层 原理 总结 探寻 block 本质 栏目 iOS 繁體版
原文   原文链接

面试题

  1. block的原理是怎样的？本质是什么？
  2. __block的做用是什么？有什么使用注意点？
  3. block的属性修饰词为何是copy？使用block有哪些使用注意？
  4. block在修改NSMutableArray，需不须要添加__block？

首先对block有一个基本的认识c++

block本质上也是一个oc对象，他内部也有一个isa指针。block是封装了函数调用以及函数调用环境的OC对象。面试

探寻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;
}
复制代码

使用命令行将代码转化为c++查看其内部结构，与OC代码进行比较sass

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

c++与oc代码对比

上图中将c++中block的声明和定义分别与oc代码中相对应显示。将c++中block的声明和调用分别取出来查看其内部实现。数据结构

定义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函数内部结构。iphone

__main_block_imp_0结构体

__main_block_imp_0结构体

__main_block_imp_0结构体内有一个同名构造函数__main_block_imp_0，构造函数中对一些变量进行了赋值最终会返回一个结构体。函数

那么也就是说最终将一个__main_block_imp_0结构体的地址赋值给了block变量post

__main_block_impl_0结构体内能够发现__main_block_impl_0构造函数中传入了四个参数。(void *)__main_block_func_0、&__main_block_desc_0_DATA、age、flags。其中flage有默认值，也就说flage参数在调用的时候能够省略不传。而最后的 age(_age)则表示传入的_age参数会自动赋值给age成员，至关于age = _age。学习

接下来着重看一下前面三个参数分别表明什么。

(void *)__main_block_func_0

__main_block_func_0

在__main_block_func_0函数中首先取出block中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的构造函数中保存在结构体内。

&__main_block_desc_0_DATA

&__main_block_desc_0_DATA

咱们能够看到__main_block_desc_0中存储着两个参数，reserved和Block_size，而且reserved赋值为0而Block_size则存储着__main_block_impl_0的占用空间大小。最终将__main_block_desc_0结构体的地址传入__main_block_func_0中赋值给Desc。

age

age也就是咱们定义的局部变量。由于在block块中使用到age局部变量，因此在block声明的时候这里才会将age做为参数传入，也就说block会捕获age，若是没有在block中使用age，这里将只会传入(void *)__main_block_func_0，&__main_block_desc_0_DATA两个参数。

这里能够根据源码思考一下为何当咱们在定义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); 
     // log: this is block,a = 3,b = 5
     //      this is block,age = 10
复制代码

由于block在定义的以后已经将age的值传入存储在__main_block_imp_0结构体中并在调用的时候将age从block中取出来使用，所以在block定义以后对局部变量进行改变是没法被block捕获的。

此时回过头来查看__main_block_impl_0结构体

__main_block_impl_0结构体

首先咱们看一下__block_impl第一个变量就是__block_impl结构体。 来到__block_impl结构体内部

__block_impl结构体内部

咱们能够发现__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结构体所占用的内存。

调用block执行内部代码

// 执行block内部的代码
((void (*)(__block_impl *, int, int))((__block_impl *)block)->FuncPtr)((__block_impl *)block, 3, 5);
复制代码

经过上述代码能够发现调用block是经过block找到FunPtr直接调用，经过上面分析咱们知道block指向的是__main_block_impl_0类型结构体，可是咱们发现__main_block_impl_0结构体中并不直接就能够找到FunPtr，而FunPtr是存储在__block_impl中的，为何block能够直接调用__block_impl中的FunPtr呢？

从新查看上述源代码能够发现，(__block_impl *)block将block强制转化为__block_impl类型的，由于__block_impl是__main_block_impl_0结构体的第一个成员，至关于将__block_impl结构体的成员直接拿出来放在__main_block_impl_0中，那么也就说明__block_impl的内存地址就是__main_block_impl_0结构体的内存地址开头。因此能够转化成功。并找到FunPtr成员。

上面咱们知道，FunPtr中存储着经过代码块封装的函数地址，那么调用此函数，也就是会执行代码块中的代码。而且回头查看__main_block_func_0函数，能够发现第一个参数就是__main_block_impl_0类型的指针。也就是说将block传入__main_block_func_0函数中，便于重中取出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;
}
复制代码

经过打断点能够看出咱们自定义的结构体能够被赋值成功，以及里面的值。

blockStruct

接下来断点来到block代码块中，看一下堆栈信息中的函数调用地址。Debuf workflow -> always show Disassembly

Debuf workflow -> always show Disassembly

经过上图能够看到地址确实和FuncPtr中的代码块地址同样。

总结

此时已经基本对block的底层结构有了基本的认识，上述代码能够经过一张图展现其中各个结构体之间的关系。

图示block结构体内部之间的关系

block底层的数据结构也能够经过一张图来展现

block底层的数据结构

block的变量捕获

为了保证block内部可以正常访问外部的变量，block有一个变量捕获机制。

局部变量

auto变量

上述代码中咱们已经了解过block对age变量的捕获。 auto自动变量，离开做用域就销毁，一般局部变量前面自动添加auto关键字。自动变量会捕获到block内部，也就是说block内部会专门新增长一个参数来存储变量的值。 auto只存在于局部变量中，访问方式为值传递，经过上述对age参数的解释咱们也能够肯定确实是值传递。

static变量

static 修饰的变量为指针传递，一样会被block捕获。

接下来分别添加aotu修饰的局部变量和static修饰的局部变量，重看源码来看一下他们之间的差异。

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;
}
// log : block本质[57465:18555229] hello, a = 10, b = 2
// block中a的值没有被改变而b的值随外部变化而变化。
复制代码

从新生成c++代码看一下内部结构中两个参数的区别。

局部变量c++代码

从上述源码中能够看出，a,b两个变量都有捕获到block内部。可是a传入的是值，而b传入的则是地址。

为何两种变量会有这种差别呢，由于自动变量可能会销毁，block在执行的时候有可能自动变量已经被销毁了，那么此时若是再去访问被销毁的地址确定会发生坏内存访问，所以对于自动变量必定是值传递而不多是指针传递了。而静态变量不会被销毁，因此彻底能够传递地址。而由于传递的是值得地址，因此在block调用以前修改地址中保存的值，block中的地址是不会变得。因此值会随之改变。

全局变量

咱们一样以代码的方式看一下block是否捕获全局变量

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

一样生成c++代码查看全局变量调用方式

全局变量c++代码

经过上述代码能够发现，__main_block_imp_0并无添加任何变量，所以block不须要捕获全局变量，由于全局变量不管在哪里均可以访问。

局部变量由于跨函数访问因此须要捕获，全局变量在哪里均可以访问 ，因此不用捕获。

最后以一张图作一个总结

block的变量捕获

总结：局部变量都会被block捕获，自动变量是值捕获，静态变量为地址捕获。全局变量则不会被block捕获

疑问：如下代码中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++代码

上图中能够发现，self一样被block捕获，接着咱们找到test方法能够发现，test方法默认传递了两个参数self和_cmd。而类方法test2也一样默认传递了类对象self和方法选择器_cmd。

对象方法和类方法对比

不论对象方法仍是类方法都会默认将self做为参数传递给方法内部，既然是做为参数传入，那么self确定是局部变量。上面讲到局部变量确定会被block捕获。

接着咱们来看一下若是在block中使用成员变量或者调用实例的属性会有什么不一样的结果。

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

c++代码

上图中能够发现，即便block中使用的是实例对象的属性，block中捕获的仍然是实例对象，并经过实例对象经过不一样的方式去获取使用到的属性。

block的类型

block对象是什么类型的，以前稍微提到过，经过源码能够知道block中的isa指针指向的是_NSConcreteStackBlock类对象地址。那么block是否就是_NSConcreteStackBlock类型的呢？

咱们经过代码用class方法或者isa指针查看具体类型。

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的类型

从上述打印内容能够看出block最终都是继承自NSBlock类型，而NSBlock继承于NSObjcet。那么block其中的isa指针实际上是来自NSObject中的。这也更加印证了block的本质其实就是OC对象。

block的3种类型

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 class], [block2 class], [^{
            NSLog(@"%d",a);
        } class]);
    }
    return 0;
}
复制代码

经过打印内容确实能够发现block的三种类型

block的三种类型

可是咱们上面提到过，上述代码转化为c++代码查看源码时却发现block的类型与打印出来的类型不同，c++源码中三个block的isa指针所有都指向_NSConcreteStackBlock类型地址。

咱们能够猜想runtime运行时过程当中也许对类型进行了转变。最终类型固然以runtime运行时类型也就是咱们打印出的类型为准。

block在内存中的存储

经过下面一张图看一下不一样block的存放区域

不一样类型block的存放区域

上图中能够发现，根据block的类型不一样，block存放在不一样的区域中。 数据段中的__NSGlobalBlock__直到程序结束才会被回收，不过咱们不多使用到__NSGlobalBlock__类型的block，由于这样使用block并无什么意义。

__NSStackBlock__类型的block存放在栈中，咱们知道栈中的内存由系统自动分配和释放，做用域执行完毕以后就会被当即释放，而在相同的做用域中定义block而且调用block彷佛也画蛇添足。

__NSMallocBlock__是在平时编码过程当中最常使用到的。存放在堆中须要咱们本身进行内存管理。

block是如何定义其类型

block是如何定义其类型，依据什么来为block定义不一样的类型并分配在不一样的空间呢？首先看下面一张图

block是如何定义其类型

接着咱们使用代码验证上述问题，首先关闭ARC回到MRC环境下，由于ARC会帮助咱们作不少事情，可能会影响咱们的观察。

// MRC环境！！！
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // Global：没有访问auto变量：__NSGlobalBlock__
        void (^block1)(void) = ^{
            NSLog(@"block1---------");
        };   
        // Stack：访问了auto变量： __NSStackBlock__
        int a = 10;
        void (^block2)(void) = ^{
            NSLog(@"block2---------%d", a);
        };
        NSLog(@"%@ %@", [block1 class], [block2 class]);
        // __NSStackBlock__调用copy ： __NSMallocBlock__
        NSLog(@"%@", [[block2 copy] class]);
    }
    return 0;
}
复制代码

查看打印内容

block类型

经过打印的内容能够发现正如上图中所示。 没有访问auto变量的block是__NSGlobalBlock__类型的，存放在数据段中。 访问了auto变量的block是__NSStackBlock__类型的，存放在栈中。 __NSStackBlock__类型的block调用copy成为__NSMallocBlock__类型并被复制存放在堆中。

上面提到过__NSGlobalBlock__类型的咱们不多使用到，由于若是不须要访问外界的变量，直接经过函数实现就能够了，不须要使用block。

可是__NSStackBlock__访问了aotu变量，而且是存放在栈中的，上面提到过，栈中的代码在做用域结束以后内存就会被销毁，那么咱们颇有可能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;
}
复制代码

此时查看打印内容

打印内容

能够发现a的值变为了避免可控的一个数字。为何会发生这种状况呢？由于上述代码中建立的block是__NSStackBlock__类型的，所以block是存储在栈中的，那么当test函数执行完毕以后，栈内存中block所占用的内存已经被系统回收，所以就有可能出现乱得数据。查看其c++代码能够更清楚的理解。

c++代码

为了不这种状况发生，能够经过copy将__NSStackBlock__类型的block转化为__NSMallocBlock__类型的block，将block存储在堆中，如下是修改后的代码。

void (^block)(void);
void test()
{
    // __NSStackBlock__ 调用copy 转化为__NSMallocBlock__
    int age = 10;
    block = [^{
        NSLog(@"block---------%d", age);
    } copy];
    [block release];
}
复制代码

此时在打印就会发现数据正确

打印内容

那么其余类型的block调用copy会改变block类型吗？下面表格已经展现的很清晰了。

不一样类型调用copy效果

因此在平时开发过程当中MRC环境下常常须要使用copy来保存block，将栈上的block拷贝到堆中，即便栈上的block被销毁，堆上的block也不会被销毁，须要咱们本身调用release操做来销毁。而在ARC环境下系统会自动调用copy操做，使block不会被销毁。

ARC帮咱们作了什么

在ARC环境下，编译器会根据状况自动将栈上的block进行一次copy操做，将block复制到堆上。

什么状况下ARC会自动将block进行一次copy操做？ 如下代码都在RAC环境下执行。

1. block做为函数返回值时

typedef void (^Block)(void);
Block myblock()
{
    int a = 10;
    // 上文提到过，block中访问了auto变量，此时block类型应为__NSStackBlock__
    Block block = ^{
        NSLog(@"---------%d", a);
    };
    return block;
}
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Block block = myblock();
        block();
       // 打印block类型为 __NSMallocBlock__
        NSLog(@"%@",[block class]);
    }
    return 0;
}
复制代码

看一下打印的内容

打印内容

上文提到过，若是在block中访问了auto变量时，block的类型为__NSStackBlock__，上面打印内容发现blcok为__NSMallocBlock__类型的，而且能够正常打印出a的值，说明block内存并无被销毁。

上面提到过，block进行copy操做会转化为__NSMallocBlock__类型，来说block复制到堆中，那么说明RAC在 block做为函数返回值时会自动帮助咱们对block进行copy操做，以保存block，并在适当的地方进行release操做。

2. 将block赋值给__strong指针时

block被强指针引用时，RAC也会自动对block进行一次copy操做。

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // block内没有访问auto变量
        Block block = ^{
            NSLog(@"block---------");
        };
        NSLog(@"%@",[block class]);
        int a = 10;
        // block内访问了auto变量，但没有赋值给__strong指针
        NSLog(@"%@",[^{
            NSLog(@"block1---------%d", a);
        } class]);
        // block赋值给__strong指针
        Block block2 = ^{
          NSLog(@"block2---------%d", a);
        };
        NSLog(@"%@",[block1 class]);
    }
    return 0;
}
复制代码

查看打印内容能够看出，当block被赋值给__strong指针时，RAC会自动进行一次copy操做。

打印内容

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(), ^{
            
});
复制代码

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);

底层原理文章专栏

底层原理文章专栏

文中若是有不对的地方欢迎指出。我是xx_cc，一只长大好久但尚未二够的家伙。须要视频一块儿探讨学习的coder能够加我Q：2336684744

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程