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

面试题引发的思考：

Q: block的原理是怎样的？本质是什么？

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

1. 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);
        };
        age = 20;
        block(1, 2);
    }
    return 0;
}

使用命令行xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m将代码转化成C++语言：

OC代码转化为C++

将C++中强制转换代码去掉，以便阅读：

简化后代码

(1) 定义block：

代码显示：

• 定义block时调用了__main_block_impl_0函数，并将__main_block_impl_0函数地址赋值给了block。
• 即block底层就是__main_block_impl_0结构体。

通过__main_block_impl_0找到__main_block_impl_0函数：

block底层结构 - __main_block_impl_0函数

代码显示：

• __main_block_imp_0结构体的第一个成员是__block_impl结构体变量，__block_impl结构体的第一个成员是isa
  即__main_block_imp_0结构体第一个成员是isa，也就是说block的底层就是一个OC对象。
• __main_block_imp_0结构体内部有一个同名构造函数__main_block_imp_0，会对相关变量赋值并返回一个__main_block_imp_0结构体，然后将结构体的地址赋值给block。

定义block时__main_block_impl_0函数传入的3个参数：

1> _main_block_func_0参数：

_main_block_func_0

很明显，其中的NSLog(...);即我们写的NSLog(@"a = %d, b = %d, age = %d", a, b, age);语句；
即_main_block_func_0函数把Block中要执行的代码封装到其内部。

2> &_main_block_desc_0_DATA参数：

&_main_block_desc_0_DATA

__main_block_desc_0中包含两个参数：
a> reserved：赋值为0；
b> Block_size：存储__main_block_impl_0占用的空间大小。

3> age参数：

age是我们定义的局部变量。block中使用age，所以block会在声明的时候将age作为参数传入，即block会捕获age。

因为block在定义时将age值传入存储在__main_block_impl_0结构体中，并在调动block时将age取出来使用，所以在block定义结束后对局部变量进行修改是无法被block捕获的。所以文章开始的代码中输出的age值为10，而非20。

下面再看__main_block_impl_0函数：

block底层结构 - __main_block_impl_0函数

有以上分析可知：

• __block_impl结构体中isa指针存储着_NSConcreteStackBlock地址
• _main_block_func_0函数把Block中要执行的代码封装到其内部，FuncPtr则存储着__main_block_func_0函数的地址。
• Desc指向__main_block_desc_0结构体对象，其中存储__main_block_impl_0结构体所占用的内存。

(2) 调用block：

// 调用block内部的代码 
// 简化版：block->FuncPtr(block, 1, 2);
((void (*)(__block_impl *, int, int))((__block_impl *)block)->FuncPtr)((__block_impl *)block, 1, 2);

通过__main_block_impl_0函数结构可知：
FuncPtr是_main_block_impl_0第一个成员变量impl的成员变量，但是block调用时却直接通过block找到FuncPtr进行调用，这是为什么呢？

原因在于：(__block_impl *)block将block强制转化为__block_impl类型，而impl是__main_block_impl_0结构体的第一个成员，所以impl和__main_block_impl_0的首地址是一样的，因此指向_main_block_impl_0的首地址的指针也就可以被强制转换为指向impl的首地址的指针，并找到FuncPtr。

而FuncPtr则存储着__main_block_func_0函数的地址，因此通过block->FuncPtr()获取__main_block_func_0的地址，对其进行调用，进而执行block中的代码。并且_main_block_func_0函数第一个参数就是__main_block_impl_0类型的指针，也就是说将block传入__main_block_func_0函数中，进而取出block捕获的值。

(3) 总结

通过以上分析，我们对block底层结构有了基本的了解，由此可以分析出其中的结构关系：

block结构体内部之间的关系

2. block的变量捕获

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

// 全局变量c, d
int c = 30;
static int d = 40;
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // 局部变量a, b
        // auto变量是声明在函数内部的变量，离开作用域就销毁
        // int a = 10; 则a为auto变量，会自动在前面添加auto关键字
        auto int a = 10;
        static int b = 20;
        void (^block)(void) = ^{
            NSLog(@"a = %d, b = %d, c = %d, d = %d", a, b, c, d);
            // 输出 a = 10, b = 2, c = 3, d = 4
        };
        a = 1;
        b = 2;
        c = 3;
        d = 4;
        block();
    }
    return 0;
}

OC代码转化为C++查看变量调用方式：

OC代码转化为C++

(1) 局部变量

1> auto变量：

• auto变量是声明在函数内部的变量，离开作用域就销毁，局部变量前面自动添加auto关键字。
• auto变量会捕获到block内部，即block内部会专门新增加一个参数来存储变量的值。
• auto变量只存在于局部变量中，访问方式为值传递。

2> static变量：

• static变量在变量的作用域结束时并不会被系统自动回收
• static变量会捕获到block内部，即block内部会专门新增加一个参数来存储变量的值的地址。
• static变量只存在于局部变量中，访问方式为地址传递。

(2) 全局变量

全局变量在哪里都可以访问，所以block不用捕获全局变量，直接进行访问。

(3) 总结

block的变量捕获

• block处理方式不同是由变量的声明周期决定的；
• 局部变量都会被block捕获，auto变量值传递，static变量指针传递；
• 全局变量不会被block捕获，直接访问。

Q: 那么以下情况block是否会捕获变量呢？

#import "Person.h"

@implementation Person
- (void)test {
    void (^block)(void) = ^{
        NSLog(@"-------- %p", self);
    };
    block();
}
@end

OC代码转化为C++查看变量调用方式：

OC代码转化为C++

由图可知：self会被block捕获。

因为OC方法会默认传递两个参数self和_cmd，两者都是局部变量，与我们的结论：局部变量会被block捕获符合。

3. block类型

前文可知：block的本质就是一个OC对象，所以block有类型。

下面我们探寻一下block的类型，首先关闭ARC：

关闭ARC

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最终继承自NSBlock，而NSBlock继承自NSObject，所以block的isa指针是来自于NSObject。也印证了block的本质就是OC对象。

(1) block的类型及存放区域：

block的存放区域

• block有三种类型：__NSGlobalBlock__、__NSMallocBlock__、__NSStackBlock__
• 数据段中的__NSGlobalBlock__直到程序结束才会被回收；
• 堆中的__NSMallocBlock__需要手动内存管理;
• 栈中的__NSStackBlock__作用域执行完毕被回收。

(2) block类型总结：

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // 1. __NSGlobalBlock__：没有访问auto变量
        void (^block1)(void) = ^{
            NSLog(@"block1");
        };
        NSLog(@"%@", [block1 class]);
        // 2. __NSStackBlock__：访问了auto变量
        int age = 10;
        void (^block2)(void) = ^{
            NSLog(@"block2 - %d", age);
        };
        NSLog(@"%@", [block2 class]);
        // 3. __NSMallocBlock__：__NSStackBlock__调用了copy
        NSLog(@"%@", [[block2 copy] class]);
    }
    return 0;
}

输出打印结果可知block的三种类型：

打印结果

上述代码转化为C++去查看源码发现三个block的isa指针全部都指向_NSConcreteStackBlock类型地址。原因是runtime会对其类型进行了转变，所以以runtime运行时类型即打印出的类型为准。

总结可得：

block类型	内存区域	环境	复制效果copy
NSGlobalStack	数据段	没有访问auto变量	什么也不做，类型不变
NSStackBlock	栈	访问了auto变量	从栈复制到堆，类型改变为__ NSMallocBlock__
NSMallocBlock	堆	__ NSStackBlock__调用copy	引用计数增加，类型不变

栈中的__NSStackBlock__访问auto变量，作用域执行完毕被回收，如果调用block时已经销毁其内存，就会出现问题：

void (^block)(void);
void test() {
    // __NSStackBlock__：访问了auto变量
    int age = 10;
    block = ^{
        NSLog(@"age = %d", age);
    };
}
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        test();
        block();
    }
    return 0;
}

打印结果

由打印结果可知：
age没有打印出正确结果，这是因为__NSStackBlock__类型的block存储在栈中，test函数执行完毕后，栈内存中block所占用的内存被系统回收。

我们可以通过copy将NSStackBlock类型的block转化为NSMallocBlock类型的block

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

打印结果

• MRC环境下，经常使用copy将栈上的block拷贝到堆中，然后手动调用release操作将其销毁即可；
• ARC环境下，编译器会自动将栈上的block进行copy操作，将block复制到堆上。

4. ARC帮我们做了什么？

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

• block作为函数返回值时；
• block赋值给__strong指针时；
• block作为Cocoa API中方法名含有usingBlock的方法参数时；
• block作为GCD API的方法参数时。

(1) block作为函数返回值时：

typedef void(^MyBlock)(void);
MyBlock myblock() {
    int age = 10;
    return ^{
        NSLog(@"-------- %d", age);
    };
}

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // block作为函数返回值
        MyBlock block = myblock();
        block();

        // MRC打印：__NSStackBlock__  (访问了auto变量)
        // ARC打印：__NSMallocBlock__
        NSLog(@"%@", [block class]);
    }
    return 0;
}

block访问auto变量时，block的类型为__NSStackBlock__；
ARC将栈上的block进行一次copy操作，将block复制到堆上，并在适当的地方进行release操作，所以ARC打印block为__NSMallocBlock__类型。

(2) 将block赋值给__strong指针时：

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // block内没有访问auto变量
        MyBlock block = ^{
            NSLog(@"block---------");
        };
        NSLog(@"%@", [block class]);

        // block内访问了auto变量，但没有赋值给__strong指针
        int age = 10;
        NSLog(@"%@", [^{
            NSLog(@"block1--------- %d", age);
        } class]);

        // block赋值给__strong指针
        MyBlock block2 = ^{
            NSLog(@"block2--------- %d", age);
        };
        NSLog(@"%@", [block2 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的方法参数时：

例如：GCD的一次性函数或延迟执行的函数

        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(), ^{

        });

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

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