03-iOS- OC中block底层原理

1. block的本质

block本质上也是一个OC对象，它内部也有个isa指针。
block是封装了函数调用以及函数调用环境(block函数的调用地址、参数、变量等信息)的OC对象。
block的底层结构代码如下：
1. 首先在main函数中申明一个block

//  首先在main函数中申明一个block
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        int age = 20;
        // 申明一个block
        void (^block)(int, int) =  ^(int a , int b){
            NSLog(@"this is a block! -- %d", age);
            NSLog(@"this is a block!");
            NSLog(@"this is a block!");
            NSLog(@"this is a block!");
        };
    }
    return 0;
}

2.将main函数的oc代码转成C++代码，具体看下block的底层实现结构如下：

// 将main函数的oc代码转成C++代码，具体看下block的底层实现结构如下：
// oc中申明的block代码底层实现是一个__main_block_impl_0的结构体
struct __main_block_impl_0 {
  // impl：是__block_impl类型的结构体，其内部有个isa指针，所以block的本质是一个oc对象。
  struct __block_impl impl;
  // Desc：是__main_block_desc_0类型的结构体。
  struct __main_block_desc_0* Desc;
  // age：是main函数中申明的局部变量age
  int age;
  // c++的构造方法，类似于oc的init构造方法
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _age, int flags=0) : age(_age) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
// impl的结构体内部实现：
struct __block_impl {
  void *isa;
  // 默认为0
  int Flags;
  int Reserved;
  // FuncPtr：block内部函数执行地址
  void *FuncPtr;
};
// Desc的结构体内部实现：
static struct __main_block_desc_0 {
  size_t reserved;
  // Block_size：block的内存空间大小
  size_t Block_size;
}

block的底层结构如右图所示：

底层结构.png

2. block的变量捕获（capture）

为了保证block内部能够正常访问外部的变量，block有个变量捕获机制。判断会不会被捕获的标准是：如果是全局变量不会捕获，如果是局部变量则会捕获。

捕获机制.png

代码演示如下：

  // auto：自动变量，离开作用域就销毁（平时申明的变量前面默认auto类型，auto是省略了）
        auto int age = 10;
        static int height = 10;
        void (^block)(void) = ^{
            // age的值捕获进来（capture）height的地址捕获进来
            NSLog(@"age is %d, height is %d", age, height);
        };
        // 值传递
        age = 20;
        // 指针传递
        height = 20;
        // 打印结果：age is 10, height is 20
        block();

注意：self也是一个局部变量，所以也会被捕获。所以通过self访问的变量也都会被捕获。方法调用中，c++底部所有的方法调用都会默认传递self和_cmd（方法名）两个参数，传递的参数就是局部变量。

默认方法入参.png

3. block的类型

(1) block有3种类型，可以通过调用class方法或者isa指针查看具体类型，最终都是继承自NSBlock类型。

__NSGlobalBlock__ （ _NSConcreteGlobalBlock ）存放在数据区域。没有访问auto变量时，就是该类型block。
__NSStackBlock__ （ _NSConcreteStackBlock ）存放在栈段。访问了auto变量时，就是该类型block。
__NSMallocBlock__ （ _NSConcreteMallocBlock ）存放在堆段。NSStackBlock类型block调用了copy函数时就是该类型。
存储位置示意图：

存储位置.png

PS：各存储位置存储内容：
程序区域：程序编译时，将代码相关数据存储在此区域。无需开发者管理。
数据区域：程序编译时，全局变量数据存储在此区域。无需开发者管理。
堆：程序运行时，动态分配内存,需要开发者申请内存，也需要开发者自己管理内存。
栈：系统自动分配内存，自己销毁。存放局部变量数据，离开作用域时内存销毁。

(2) 每一种类型的block调用copy后的结果如下所示:

调用copy结果.png

(3) block的copy操作：

在ARC环境下，编译器会根据情况自动将栈上的block复制到堆上（block会变成NSMallocBlock类型），比如以下情况：

1. block作为函数返回值时；
2. 将block赋值给__strong指针时；
3. block作为Cocoa API中方法名含有usingBlock的方法参数时；
4. block作为GCD API的方法参数时；

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

4. block内部访问对象类型的auto变量

当block内部访问了对象类型的auto变量时：

如果block是在栈上，将不会对auto变量产生强引用。
如果block被拷贝到堆上：1. 会调用block内部的copy函数；2. copy函数内部会调用_Block_object_assign函数；3. _Block_object_assign函数会根据auto变量的修饰符（__strong、__weak、__unsafe_unretained）做出相应的操作，形成强引用（做一次retain操作）或者弱引用；
如果block从堆上移除。1. 会调用block内部的dispose函数；2. dispose函数内部会调用_Block_object_dispose函数；3. _Block_object_dispose函数会断开对auto变量的引用（做一次release操作）；

函数调用时机.png

5. block关于__block修饰变量

__block可以用于解决block内部无法修改auto变量值的问题。
__block不能修饰全局变量、静态变量（static）。
编译器会将__block修饰符的变量包装成一个对象。底层掩饰如下

// 申明一个__block修饰符变量
typedef void (^MJBlock)(void);
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        __block int age = 10;
        MJBlock block1 = ^{
            age = 20;
            NSLog(@"age is %d", age);
        };
        block1();
    }
    return 0;
}

// 上述oc代码转成c++底层代码，__block int age的结构
struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  /* __block int age变量被包装成__Block_byref_age_0类型的结构体，结构体里 
    有isa指针，实质是oc对象。
    block修改age的值是通过*age ->forwarding->age来修改的
 */  
  __Block_byref_age_0 *age; 
};
// __Block_byref_age_0结构体：
struct __Block_byref_age_0 {
  void *__isa;
// 存放指向自己的内存地址
__Block_byref_age_0 *__forwarding;
 int __flags;
 int __size;
// __block int age变量 age的值
 int age;
};

__block修饰变量的内存管理
- 当block在栈上时，并不会对__block变量产生强引用
- 当block被copy到堆时:1. 会调用block内部的copy函数；2. copy函数内部会调用_Block_object_assign函数；3._Block_object_assign函数会对__block变量形成强引用（做一次retain操作）;
  
  引用流程图.png
- 当block从堆中移除时: 1. 会调用block内部的dispose函数；2. dispose函数内部会调用_Block_object_dispose函数；3. _Block_object_dispose函数会断开对__block变量的引用（做一次release操作）；
  
  移除流程图.png
__block修饰的对象变量内存管理
- 当block在栈上时，并不会对__block变量产生强引用；
- 当block被copy到堆时:1. 会调用block内部的copy函数；2. _Block_object_assign函数会根据所指向对象的修饰符（__strong、__weak、__unsafe_unretained）做出相应的操作，形成强引用（retain）或者弱引用（注意：这里仅限于ARC时会retain，MRC时不会retain）；3._Block_object_assign函数会对__block变量形成强引用（做一次retain操作）；
- 当block从堆中移除时: 1. 会调用block内部的dispose函数；2. dispose函数内部会调用_Block_object_dispose函数；3. _Block_object_dispose函数会断开对__block对象变量的引用（做一次release操作）；
__block修饰变量的__forwarding指针。
上面提到，__block修饰符变量的底层是包装成一个oc对象，其内部有一个指向自己的__forwarding指针，访问__block变量是通过__forwarding访问自己内部的__block变量。

这样做的原因是：如果block在栈上时， __forwarding指针指向是栈上的block，如果block copy到堆上时， __forwarding指针指向的是堆上的block，通过__forwarding指针来访问变量，就可以保证访问的变量是堆上的变量。流程图如下：

访问流程.png

6. block循环引用问题

什么是block循环引
循环引用是指对象之间的强引用链形成了环就创造了一个循环引用。最简单的情况，两个对象之间强引用，你引用我，我引用你，导致内存无法释放，就形成了循环引用。
block 的循环引用情况是，block 会捕获内部使用的对象，形成隐式的强引用，一般有以下两种常见的情况：
1. 引用 self：直接写 self：
```
self.callback = ^{
  NSLog(@"callback: %@", self);}
```
2.成员变量：不写 self，但实际上还是对 self 的强引用：
```
  self.callback = ^{
  NSLog(@"callback: %@", _name);
  // 等价于
  NSLog(@"callback: %@", self->_name); 
   }
```
ARC-解决循环引用问题
1. 用__weak解决,不会产生强引用，指向的对象销毁时，会自动让指针置为nil。
```
      MJPerson *person = [[MJPerson alloc] init];
      __weak typeof(person) weakSelf = person;
      person.block = ^{
          NSLog(@"age is %d", weakSelf.age);
      }
```
1. 用__unsafe_unretained解决,不会产生强引用，不安全，指向的对象销毁时，指针存储的地址值不变，所以一般不常用。
```
     MJPerson *person = [[MJPerson alloc] init];
      __unsafe_unretained typeof(person) weakPerson = person;
      person.block = ^{
          NSLog(@"age is %d", weakPerson.age);
      };
```
1. 用__block解决（必须要调用block）,缺点：1. 必须要将block强引用的对象置空，且block一定要调用；2. 一定要等到block执行完，对象才能被释放。如果这个block一直没有被调用，对象就一直不会被释放，就会存在内存泄露。
  
  block解决循环引用示意图.png
  
  代码演示：
```
      __block MJPerson *person = [[MJPerson alloc] init];
      person.block = ^{
          person.age = 20;
          NSLog(@"age is %d", person.age);
          person = nil
      };
      person.block();
```
MRC-解决循环引用问题（不支持__weak）
1. 用__unsafe_unretained解决
  
  image.png
2. 用__block解决
  
  image.png