Block 底层原理总结

1. Block 本质

现在我们来实现一个最简单的BlockA

 void (^BlockA)(void) = ^{
      NSLog(@"block A");
 };
 BlockA();

通过clang命名转化成C++源码：
xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc -fobjc-arc -fobjc-runtime=ios-8.0.0 main.m

查看源码会得到 BlockA 会生成以下几个结构体：

// 函数栈里面定义的 BlockA
struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

// __main_block_impl_0 的第一个结构体成员
// 里面包含有 isa 指针
struct __block_impl {
  void *isa;
  int Flags;
  int Reserved;
  void *FuncPtr;
};

// 里面有个主要的变量 Block_size ，通过sizeof(struct __main_block_impl_0)赋值，实际上是BlockA的内存大小
static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};

// blockA {} 花括号里面的代码，需要传递 __main_block_impl_0 参数
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
       NSLog((NSString *)&__NSConstantStringImpl__var_folders_50_s42jfyxs01s8t4z0c1q2p2c00000gn_T_main_d4d224_mi_1);
 }

根据BlockA的定义可以看出，Block和对象一样拥有isa指针，且有Block_size来计算分配内存空间的大小的属性，所以Block也是一个对象，对象就能调用Class方法（通过block能够调用Class方法也能反推block是一个对象）。

接下来看 BlockA(); 转化成的源码

void (*BlockA)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
// 初始化BlockA，传入 __main_block_func_0 执行的函数地址，
// 通过 __main_block_impl_0 构造函数可知 __main_block_func_0 会通过 impl.FuncPtr = fp; 赋值给 FuncPtr

//  BlockA() 源码
((void (*)(__block_impl *))((__block_impl *)BlockA)->FuncPtr)((__block_impl *)BlockA);
// 去掉强制类型转换
BlockA->FuncPtr(BlockA);
// 其实BlockA()就是通过函数指针直接调用了函数并且传入了BlockA对象

所以Block可以简单总结：

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

由上可得Block的内存结构图如下：

image.png

2，Block类型

Block 有三种类型：
1，NSGlobalBlock 全局区的Block
2，NSStackBlock 栈区的Block
3，NSMallocBlock 堆区的Block

接下来我们通过定义几个Block来访问外部变量，看看他们有什么区别：

int G = 100;
// 全局区的block
void (^Block_G)(void) = ^{
    NSLog(@"block G %d", G);
};
int main(int argc, const char * argv[]) {
    @autoreleasepool {        
        // 不访问任何变量
        void (^BlockA)(void) = ^{
            NSLog(@"block A");
        };
        BlockA();
        
        // 访问auto 局部变量
        int b = 10;
        void (^BlockB)(void) = ^{
            NSLog(@"block B %d", b);
        };
        b = 20;
        BlockB();
        
        // weak block，让编译器不进行 copy 操作
        __weak void (^BlockC)(void) = ^{
            NSLog(@"block D %d", b);
        };
        BlockC();
        
        static int d = 25;
        // 访问全局变量
        void (^BlockD)(void) = ^{
            NSLog(@"block D %d", d);
        };
       d = 30;
        BlockD();
        
        NSLog(@"BlockA class -> %@", [BlockA class]);
        NSLog(@"BlockB class -> %@", [BlockB class]);
        NSLog(@"BlockC class -> %@", [BlockC class]);
        NSLog(@"BlockD class -> %@", [BlockD class]);
        NSLog(@"BlockG class -> %@", [Block_G class]);

    }
    return 0;
}

打印结果【注arc模式下】：

image.png

根据以上输出我们带着几个疑问来探寻下Block的实现原理：

1，为什么Block能调用class方法？
2，b，d变量被修改后，为什么Block B里面的输出值不是20？而BlockD输出的是30
3，同样在main函数里面定义的BlockA/B/C，为什么Class类型不一样？
4，同样是NSGlobalBlock类型的Block_G与BlockA定义是一样的吗？

通过前面讲的，我们知道了 BlockA的内存结构，接下来我们看下 BlockB 和BlockD的内存结构：

/* OC代码
   // 访问局部变量
   void (^BlockB)(void) = ^{
        NSLog(@"block B %d", b);
    };
*/
// BlockB 定义
struct __main_block_impl_1 {
  struct __block_impl impl;
  struct __main_block_desc_1* Desc;
  int b;
  __main_block_impl_1(void *fp, struct __main_block_desc_1 *desc, int _b, int flags=0) : b(_b) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

/* OC代码
   static int d = 30;
   // 访问全局变量
   void (^BlockD)(void) = ^{
        NSLog(@"block D %d", d);
    };
*/
// BlockD 源码定义
struct __main_block_impl_3 {
  struct __block_impl impl;
  struct __main_block_desc_3* Desc;
  int *d;
  __main_block_impl_3(void *fp, struct __main_block_desc_3 *desc, int *_d, int flags=0) : d(_d) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

从上面BlockB和BlockD的内存结构可以看出，他们比BlockA内部多一个变量，多出来的变量其实Block捕获外部的变量，捕获的变量可以得出：

1. BlockB 里面捕获的是int b 是一个值类型的int变量，所以后面b值修改后，BlockB里面的b不会变；
2. BlockD 里面捕获的是int *d 是一个指针变量，所以后面d值修改后，BlockD通过指针访问的d还是BlockD外面的变量d。

以下是Block捕获变量的规则：

Block捕获外部变量机制

再来看下Block_G 的定义如下：

struct __Block_G_block_impl_0 {
  struct __block_impl impl;
  struct __Block_G_block_desc_0* Desc;
  __Block_G_block_impl_0(void *fp, struct __Block_G_block_desc_0 *desc, int flags=0) {
    impl.isa = &_NSConcreteGlobalBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

BlockA 和 Block_G 的区别是 isa 指针定义类型不一样

BlockA：_NSConcreteStackBlock 在函数栈里面定义的block
Block_G：_NSConcreteGlobalBlock 在全局区定义的block

其实在Clang的文档中，只定义了两个Block类型: _NSConcreteGlobalBlock 和 _NSConcreteStackBlock 。而在Console中的Log我们看到的3个类型应该是处理过的显示，这些字样在苹果的文档和Clang/LLVM的文档中实难找到。

Console中输出的的class类型是根据访问外部变量来确定的，其规则如下：

image.png

根据Block类型及捕获变量规则我们就能知道为什么BlockA/B/C的类型为什么不一样了：

1. BlockA没有访问任何变量，所以它是NSGlobalBlock类型
2. BlockC访问了局部auto变量，所以它是NSStackBlock类型
3. BlockB访问了局部auto变量，arc自动给他进行了copy操作，所以它是NSMallocBlock类型

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

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

MRC下block属性的建议写法

@property (copy, nonatomic) void (^block)(void);

ARC下block属性的建议写法，ARC下stong和copy没有区别

@property (strong, nonatomic) void (^block)(void);
@property (copy, nonatomic) void (^block)(void);

3，Block内存管理

Block访问对象

  FRFruit *fruit = [[FRFruit alloc] init];
  FRFruit *fruit1 = [[FRFruit alloc] init];
  __weak FRFruit *weakfruit = fruit1;

  void (^Block_Objct)(void) = ^{
        NSLog(@"block %@", fruit);
        NSLog(@"block %@", weakfruit);
  };
        
  Block_Objct();

转化成C++源码

  struct __main_block_impl_0 {
      struct __block_impl impl;
      struct __main_block_desc_0* Desc;
      FRFruit *__strong fruit;
      FRFruit *__weak weakfruit;
      ....
  };

  static struct __main_block_desc_0 {
      size_t reserved;
      size_t Block_size;
      void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*);
      void (*dispose)(struct __main_block_impl_0*);
  } __main_block_desc_0_DATA = { 
                                    0,
                                    sizeof(struct __main_block_impl_0),
                                    __main_block_copy_0, 
                                    __main_block_dispose_0};

可以看出Block里面默认捕获外面的对象为strong属性修饰，如果外部是weak属性的，其内部也会是相应的weak属性修饰；
__main_block_desc_0 结构体里面多了copy和dispose两个函数，它们是Block用来管理内存的
来看下它们的定义：

static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {
    _Block_object_assign((void*)&dst->fruit, (void*)src->fruit, 3);
    _Block_object_assign((void*)&dst->weakfruit, (void*)src->weakfruit, 3);
}

static void __main_block_dispose_0(struct __main_block_impl_0*src) {
    _Block_object_dispose((void*)src->fruit, 3);
    _Block_object_dispose((void*)src->weakfruit, 3)
;}

里面主要有 _Block_object_assign() 和 _Block_object_dispose() 两个函数

1. 当block被copy到堆时；
   ·会调用block内部的copy函数；
   ·copy函数内部会调用 Block_object_assign 函数；
   ·Block_object_assign 当传入的参数是stong类型时会进行retain操作，如果是weak指针不会进行retain操作；
2. main_block_dispose_0 方法类似C++里面对析构函数，Block释放时会调用，Block_object_dispose 函数则是对传入参数进行release释放。

所以当block对象未释放时，它里面如果是strong修饰的对象也不会被释放，正因为如此，所以Block常常伴随着会出现循环引用问题。
比如我们下面这种用法：

FRFruit *fruit = [[FRFruit alloc] init];        
fruit.block_Objct = ^{
     NSLog(@"block %@", fruit);
};
        
fruit.block_Objct();
// fruit 对象里面有一个copy修饰的 block_Objct 属性

Block循环引用的原理：

image.png

我们根据OC的内存管理机制知道，当对象需要被释放时必须先释放所有指向它的指针。
所以如果要先释放fruit对象，需要释放block_Objct里面的变量，如果释放block_Objct里面的变量需要先释放block_Objct，而block_Objct又被fruit强引用，这样就出现了循环引用的问题。

那么如何解决这个问题呢？
通常我们ARC环境下面的解决办法是通过__weak指针来解决这个问题，通过上面讲的Block里面的变量是通过访问的外部变量是否是strong或weak指针来进行内部对象进行相应修饰的，所以如果访问的外部对象是weak指针时，他们的引用关系就会如下图：

image.png
weak指针解决循环引用代码如下：

FRFruit *fruit = [[FRFruit alloc] init];    
__weak FRFruit *weakfruit = fruit;    
fruit.block_Objct = ^{
     NSLog(@"block %@", weakfruit);
};
        
fruit.block_Objct();

其实除了weak还有__unsafe_unretain 和 __block，其实现如下：

// __unsafe_unretain 用法
FRFruit *fruit = [[FRFruit alloc] init];    
__unsafe_unretained FRFruit *weakfruit = fruit;    
fruit.block_Objct = ^{
     NSLog(@"block %@", weakfruit);
};

// __block 用法，主意ARC环境下 block中需要将变量只为nil，且必须调用block，才能打破循环
FRFruit *fruit = [[FRFruit alloc] init];    
__block FRFruit *fruit = fruit;    
fruit.block_Objct = ^{
     NSLog(@"block %@", fruit);
     fruit = nil; // MRC 不需要置为nil
};
fruit.block_Objct();

鉴于ARC环境下weak指针的底层实现原理（对象释放时会自动指针会自动置为nil），所以推荐使用weak来解决循环引用问题。
MRC环境下推荐使用__unsafe_unretained和 __block

4，__block 修改局部变量原理

我们知道block是不能直接修改局部auto变量的，比如以下代码编译时会直接报错：

int a = 10;
void (^Block)(void) = ^{
     a = 20; // 不能修改a变量
};
Block();

因为根据计算机内存分配原理可知，a变量是在栈上的，它的内存空间在函数结束时就会被回收，而Block有可能被复制到堆空间上，堆上空间的释放由开发者控制的，所以函数结束时Block有可能还会被执行，而这时变量a已经被释放了，Block就无法找到变量a的内存进行赋值，所以这种操作是被禁止的。
如果要修改局部变量，OC提供__block 修饰来修改，其用法如下：

int a = 10;
void (^Block)(void) = ^{
     a = 20; 
};
Block();

那它的实现原理又是怎样的呢？接下来我们看下源码：

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
// 不加__block 时是 int a ，
// 加上__block 变成了__Block_byref_a_0 *a
  __Block_byref_a_0 *a; // by ref
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_a_0 *_a, int flags=0) : a(_a->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

struct __Block_byref_a_0 {
  void *__isa;
__Block_byref_a_0 *__forwarding;
 int __flags;
 int __size;
 int a;
};

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  __Block_byref_a_0 *a = __cself->a; // bound by ref
// block里面的访问__block 修饰的变量时都会通过结构体中的 forwarding 指针来访问
  (a->__forwarding->a) = 20;
}

__block 实际上是将局部变量放在 __Block_byref_a_0 对象里面，该对象里面有一个 __forwarding 指针，最开始__Block_byref_a_0 在栈上时， __forwarding 属性会指向它自己，当Block复制到堆上时，__Block_byref_a_0 对象也会复制一份到堆上，此时 __forwarding 指针指向的是堆上的那块内存，所以Block实际上访问的a变量不再是栈上的变量，而是__Block_byref_a_0对象中堆内存的那个a

forwarding 指针实现原理：

image.png

全文纯手写总结，有些地方总结的不仔细，逻辑也不太清楚，等有时间会再修改梳理一下。
如有错误请指正，感谢阅读，谢谢大家！