1、Block 的本质：

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

struct __block_impl {  // block 最底层的实现
    void *isa;
    int Flags;
    int Reserved;
    void *FuncPtr; // 函数
}

struct __xxxx_block_impl_0 { // 开发者创建的某个block
    struct __block_impl impl;
    struct __xxxx_block_desc_0 *Desc;
    ... // 其他变量
    
    // 构造函数
    __xxxx_block_impl_0(void *fp, struct __xxxx_block_desc_0 *desc, int flags = 0) {
        impl.isa = &_NSConcreateStackBlock;
        impl.Flats = flags;
        impl.FuncPtr = fp;
        Desc = desc;
    }
}

struct __xxxx_block_desc_0 { // 开发者创建的某个block的表述信息
    size_t reserved; // 预留字段，不考虑 
    size_t Block_size; // block的大小
} __xxxx_block_desc_0_DATA(0, sizeof(struct __xxxx_block_impl_0)); // 声明了变量，并计算出了block的size

Block流程：

• 程序在编译的时候会创建两个函数：
  • 封装了block执行逻辑的函数(比如：_block_func_0)
  • 封装了block描述信息的函数(比如：_block_desc_0_DATA)
• 创建结构体：
  • 将函数_block_func_0的地址赋值给内部的FuncPtr变量
  • 将变量_block_desc_0_DATA的地址复制给Desc变量
• 执行Block，通过结构体内部的impl找到函数FuncPtr，取出函数地址并执行（impl是struct的第一个变量，所以可以直接强转）

2、Block 变量捕获：

局部变量-捕获（因为跨函数执行）
全局变量-不捕获

1. 局部变量，离开作用域就销毁

   • auto 自动变量，可以不写，基本类型普通定义的变量都是 auto 的）
   • static 静态变量
   • register 高速编译器，尽量用寄存器存储数据，很少用

2. 如果在类里边，self也会被捕获到block中，因为self是局部变量

3、Block 的类型：

Block有三种类型：

• 全局Block（NSGlobalBlock）：如果这个block没有访问auto变量，那么这个block就位于全局区
• 栈Block（NSStackBlock）：
  • MRC下：如果这个block访问了auto变量，那么这个block就是栈Block，对于栈Block而言，变量的作用域结束，空间被回收
  • ARC下：如果这个block访问了auto变量且使用了weak/assign修饰，那么这个block就是栈Block
• 堆Block（NSMallocBlock）：
  • MRC下：如果这个block访问了auto变量且手动进行了copy操作，那么这个block就是堆Block
  • ARC下：如果这个block访问了auto变量且使用了copy/strong修饰，那么这个block就是堆Block

总结：
GlobalBlock: 没有访问auto变量(GlobalBlock->copy->GlobalBlock)
StackBlock: 访问了auto变量 (如果StackBlock调用了copy/strong就会变成MallocBlock)
MallocBlock: 访问了auto变量 且 strong/copy 修饰

4、Block 的 copy：

在 ARC 下某些其情况下，系统会自动对 block 进行 copy，
但是只有访问了auto对象才是MallocBloc

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

5、Block 访问对象类型的 auto 变量：

• 如果这个Block是栈Block: 不会对 auto变量 产生强引用
• 如果这个Block是堆Block: 会对 auto变量 产生强引用

原理：

当 Block 被拷贝到堆上时，会调用 block 内部的 copy 函数，内部函数会根据变量的操作符（__strong、__weak、__unsfe_unretained）做出相应的操作，类似于 retain（形成强引用、若引用）
当 Block 从堆上移除时，会调用 block 内部的 Dispose 函数，内部函数会自动释放引用的 auto 变量，类似于 release

6、Block 访问 __block 修饰的基础类型：

修改变量方式：static修饰变量、 全局变量、__block修饰变量

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

底层实现：

如果变量使用了 __block 修饰，那么在编译的时候，编译器会将这个变量封装成在一个结构体中（结构体中有isa指针，所以可以理解成对象），

struct __Block_byref_age_0 {      
    void *__isa;             
    __Block_byref_age_0 *__forwarding; // 指向__Block_byref_b_0自己本身
    int __flags;
    int __size;
    int age; // 外部的变量
};

而在 Block 的实现中会生成这个结构体的指针，并进行内存管理，类似于auto类型对象，

访问：age -> __forwarding -> age = 20;

其实根据读取age的内存地址可以发现，不管是在 Block内部，还是在 Block外部，访问的age都是生成的结构体中的age变量

为什么要使用 __forwarding 指针？
__forwarding 指针指向生成的结构体本身，通过这个指针来访问内部的变量，能保证在当Block被拷贝到堆上后，任何情况下都是访问的堆上的变量

• 当 Block 在栈上，使用栈Block 的 __forwarding 指针访问的结构体内部的变量

• 当 Block 被拷贝到在堆上时，栈上的Block中的 __forwarding 指针指向堆Block，堆上的Block中的 __forwarding 指针指向自己本身，这时可以保证不管是通过栈Block还是堆Block访问的内部变量，都是堆Block的内部变量

  
  

7、Block 内存管理：

Block会对 对象类型变量和__block 修饰的变量进行内存管理
__block 修饰的都会在编译时生成一个结构体进行包装

• 当 Block 在栈上的时候，并不会对它们产生强引用 (block 本身随时会释放)
• 当 Block 被 copy 到堆上，都会通过 Copy 函数，Copy 内部会调用_Block_object_assign函数来处理它们
  • a) __block 基础变量，Block直接对生成的结构体进行强引用
  • b) 对象类型，Block 根据对象的修饰符（__strong、__weak、__unsfe_unretained）做出相应的操作，形成强引用（retain）或弱引用（仅限于ARC时会retain，MRC下不会）
  • c) __block 对象类型，Block直接对生成的结构体进行强引用，结构体内部根据对象的修饰符（__strong、__weak、__unsfe_unretained）做出相应的操作，形成强引用（retain）或弱引用（仅限于ARC时会retain，MRC下不会）
• 当 Block 从堆上移除，就会调用 block 内部 Dispose 函数，Dispose 内部会调用_Block_object_dispose函数来释放它们

8、Block 解决循环引用：

1. ARC 下使用 __weak, __unsafe_unretained, __block

• __weak 不会产生强引用，如果内存释放，指针会自动置为 nil(推荐使用)
• __unsafe_unretained 不会产生强引用，不安全，如果内存释放，指针会变成野指针
  另：
• 使用 __block 也解决循环引用，但是必须调用 block，并且在 block 中必须将变量置 nil

2. MRC 下使用 __unsafe_unretained, __block (MRC 下不支持 __weak)

• __unsafe_unretained 不会产生强引用，不安全，如果内存释放，指针会变成野指针
• __block 它在 MRC 下不会强引用(推荐使用)

面试题：

1、 block 的原理是怎么样的？本质是什么？

封装了函数调用以及调用环境的 OC 对象
Block 的调用即是函数的调用

2、 __block 的作用是什么？有什么使用注意点？

__block 可以解决 block 内部无法修改 auto 变量值的问题  
注意点：__block 内存管理

3、 block 的属性修饰词为什么是 copy？使用 block 有哪些使用注意点？

block 一旦没有 copy，就会不在堆上，在堆上方便进行内存管理  
使用注意：循环引用

4、 block 在修改 NSMutableArray，需不需要添加__block？

不需要

5、 适应strong和copy修饰block有什么区别？

没区别，不管是strong还是copy，在ARC下都会将block拷贝到堆上