Block本质

Block本质是 将函数及其执行上下文进行封装起来的对象。

在main.m中有如下代码

 int  multiplier = 6;
 int(^Block)(int) = ^int(int num){
       return num * multiplier;
 };
 Block(2);

在终端使用命令clang -rewrite-objc main.m 后得到main.cpp

int multiplier = 6;

 int(*Block)(int) = ((int (*)(int))&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, multiplier));

 ((int (*)(__block_impl *, int))((__block_impl *)Block)->FuncPtr)((__block_impl *)Block, 2);

Block数据结构

struct __main_block_impl_0 {
  struct __block_impl impl; 
  struct __main_block_desc_0* Desc;   //block相关描述
  int multiplier;   //外部传入的
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _multiplier, int flags=0) : multiplier(_multiplier) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;//构造时完成赋值，存储函数内容
    Desc = desc;  //构造时完成赋值
  }
};

struct __block_impl {
  void *isa;  //isa
  int Flags;
  int Reserved;
  void *FuncPtr; //函数指针
};

//关键函数
static int __main_block_func_0(struct __main_block_impl_0 *__cself, int num) {
int multiplier = __cself->multiplier; // bound by copy

     return num * multiplier;
}

Block的body中有一个成员__block_impl ，而__block_impl中包含了isa。所以说Block是一个对象。
Block在初始化的时候，调用了构造函数__main_block_impl_0，依次传入了函数指针，block相关描述，以及外部变量multiplier。

Block调用

((__block_impl *)Block)->FuncPtr)((__block_impl *)Block, 2)

可以看出，Block调用时，先通过Block结构体获取函数指针，然后调用函数。

Block本质

Block截获变量

static int var_global_static = 89;
int var_golobal = 12;

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        int  var = 6;
        static int  var_static = 4;
        NSMutableArray *array = [NSMutableArray array];
        __unsafe_unretained id unsafeObj = nil;
        __strong id strongObj = nil;
        
        void(^Block)(void) = ^void(){

            [array addObject:@"123"];
            NSLog(@"var: %d",var);
            NSLog(@"var_static: %d",var_static);
            NSLog(@"unsafeObj: %@",unsafeObj);
            NSLog(@"strongObj: %@",strongObj);
            
            NSLog(@"var_golobal: %d",var_golobal);
            NSLog(@"var_global_static: %d",var_global_static);
            
        };
        Block();
    }
    return 0;
}

经过clang编译之后

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  NSMutableArray *array;//局部对象，连同所有权修饰符一起截
  int var;               //捕获局部变量的值
  int *var_static;       //捕获静态局部变量的指针
  id unsafeObj;          //局部对象，连同所有权修饰符一起截获
  id strongObj;          //局部对象，连同所有权修饰符一起截获
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _var, int *_var_static, id _unsafeObj, id _strongObj, int flags=0) : var(_var), var_static(_var_static), unsafeObj(_unsafeObj), strongObj(_strongObj) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

得出以下结论：
1 基本数据类型的局部变量截获其值
2 对于对象类型的局部变量连同所有权修饰符一起截获
3 以指针形式截获局部静态变量
4 不截获全局变量、静态全局变量

__block

一般情况下对截取的变量赋值需要添加__block修饰符。静态局部变量，全局变量，静态全局变量。 赋值不需要使用__block。局部基本类型，局部对象赋值，需要使用__block。

用__block修饰后的变量，变成了一个对象

__block int multiplier = 9;
void(^Block)(void) = ^void(void){
    [array addObject:@"123"];
     NSLog(@"multiplier = %d",multiplier);
 };
multiplier = 10;

经过clang编译后

__Block_byref_multiplier_0 *multiplier; // Block body中捕获
struct __Block_byref_multiplier_0 {
    void *__isa;
    __Block_byref_multiplier_0 *__forwarding; //在栈中指向自己
     int __flags;
     int __size;
     int multiplier;
};
(multiplier.__forwarding->multiplier) = 10;  //真正调用

Block内存管理

栈中的NSConcreteStackBlock;
堆中的NSConcreteMallocBlock
数据区NSConcreteGlobalBlock
为什么Block需要用copy?
过成员变量去访问对应的栈上的block时,可能由于栈对应的函数退出之后，在内存中销毁掉，继续访问导致内存崩溃。

Block copy

前面介绍过，被__block修饰的变量会变成一个对象。
若果栈中的block没有被拷贝到堆中,__forwarding指针指向变量自己。

__forwarding指针

Block相关问题

什么是Block？

Block 是对函数，及其上下文进行封装的对象。

理解block截获变量特性？

基本数据类型，截获值
对象类型局部，修饰符一起
静态局部，指针
全局静态，非静态。 不截获

哪些循环引用？怎么解决?

Block循环引用，捕获变量，和block都是当前对象的成员。采用__weak断环。

MRC没有问题。添加blockSelf = nil 来进行断环操作。但是，若果你一直不调用blk(3)，那么这个环就一直没有解开。

block 断环