本篇主要是对小码哥底层视频学习的总结。方便日后复习。
上一篇《iOS底层原理总结 - 探寻关联对象本质》：
//www.greatytc.com/p/2f0626c76c81

本篇学习总结:

• 探寻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

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结构体中存储着两个参数，reserved和Block_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底层结构关系图.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

切换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内容有点多，面试题总结在下一篇。
本篇学习先记录到此，感谢阅读，如有错误，不吝赐教。