系列文章：OC底层原理系列，OC基础知识系列

本文将介绍block的类型，循环引用的解决方法以及block底层分析

Block简介

Block定义：带有自动变量的匿名函数，它是C语言的拓展功能，之所以是扩展，是因为C语言不允许存在这样的匿名函数

• 匿名函数
  • 匿名函数式指不带函数名称的函数
• 带有自定变量
  • Block拥有捕获外部变量的功能，在Block中访问一个外部的局部变量，Block会持有它的临时状态，自动捕获变量值，外部局部变量的变化不会影响它的状态（这个下面会讲到）。

Block类型

block主要有三种类型

• 1.__NSGlobalBlock__：全局block，存储在全局区
  • 在Block内部不使用外部变量，或者只使用静态变量和全局变量

此时block无参也无返回值，属于全局block

• 2.__NSMallocBlock__：堆区block，因为block既是函数，也是对象
  • 在Block内部使用局部变量或者OC属性，并且赋值给强引用或者Copy修饰的变量

此时block会访问外界变量，即底层拷贝a，所以是堆区block

• 3.__NSStackBlock__：栈区block
  • 与MallocBlock一样，可以在内部使用局部变量或者OC属性，但是不能赋值给强引用或者Copy修饰的变量

其中局部变量a在没有处理之前（即没有拷贝之前）是 栈区block， 处理后（即拷贝之后）是堆区block ，所以栈区block越来越少了 这个情况下，可以通过__weak不进行强持有，block就还是栈区block

总结

• 1.block是直接存储在全局区
• 2.block如果访问外界变量，并进行block相应copy
  • 如果此时的block是强引用，则block存储在堆区，即堆区block（堆区block在出了作用域，会执行free操作进行销毁）
  • 如果此时的block通过——weak变成了弱引用，则block存储在栈区，即栈区block（出了作用域引用计数会-1，只有引用计数为0是才会销毁）

Block循环引用

【正常释放】：当A持有B，当A调用dealloc方法，给B发送release信号，B收到release信号，如果此时B的引用计数为0时，则会调用B的dealloc方法，此时A，B都能正常释放 【循环引用】：当A持有B，B同时也持有A时，此时A销毁需要B先销毁，而B销毁同样需要A先销毁，就导致相互等待销毁，此时A，B的引用计数都不为0，所以A，B此时都无法释放。

解决循环引用

举个循环引用的例子：如下图

上面代码发生了循环引用，因为在block内部使用了self的name变量，导致block持有self，而self本来就持有block，就导致了self和block相互持有。

下面来解决循环引用

• 1.weak-strong-dance（最常用的方法）
• 2.__block修饰对象，同时置nil
• 3.传递对象self作为block的参数，提供给block内部使用
• 4.使用NSProxy

weak-strong-dance（弱强共舞）

• 1.如果block内部并未嵌套block，直接使用__weak修饰self即可

@interface ViewController ()
@property (nonatomic, copy) void (^block)(void);
@property (nonatomic, copy) NSString *name;
@end

- (void)viewDidLoad {
    [super viewDidLoad];  
    self.name = @"man";
    __weak typeof(self) weakSelf = self;
    self.block = ^(void){
        NSLog(@"%@",weakSelf.name);
    };
    self.block();
}

由于此时的weakSelf和self指向同一片内存空间，而且使用__weak不会导致self的引用计数发生变化，可以通过打印weakSelf和self的指针地址，以及self的引用计数来验证

• 2.如果block内部嵌套block，则需要同时使用__weak和__strong 如果只用weak修饰，则可能出现block内部持有的对象被提前释放，为了防止block内部变量被提前释放，使用strong对引用计数+1，防止提前释放。 其中strongSelf是一个临时变量，在block的作用域内，当block执行完就会释放strongSelf，这种方式属于打破self对block的强引用，依赖于中间者模式，属于自动置为nil，也就是自动释放。

__block修饰变量

这种方式同样依赖于中介者模式，属于手动释放，是通过__block修饰对象，主要是因为__block修饰的对象是可以改变的。

这里的block必须调用，如果不调用block，vc就不会置空，那么依旧是循环引用，self和block都不会释放。

对象self作用参数

主要是将对象self作用参数，提供给block内部使用，不会有引用计数问题

使用NSProxy虚拟类

• OC是只能单继承的语言，但它是基于运行时的机制，所以可以通过NSProxy来实现伪多继承，填补多继承的空白
• NSProxy和NSObject是同级的类，是个虚拟类，只是实现了NSObject的协议
• NSProxy其实是一个消息重定向封装的一个抽象类，类似一个代理人，中间件，可以通过继承它，并重新写下面的两个方法来实现消息转发到另一个实例

使用场景

• 1.实现多继承功能
• 2.解决NSTimer&CADisplayLink创建时对self强引用问题，这个在YYKit中YYWeakProxy有所使用的

循环引用解决原理

主要是通过自定义的NSProxy类的对象来代替self，并使用方法实现消息转发，下面是NSProxy子类的实现以及使用的场景

@interface LjProxy ()

@property(nonatomic, weak, readonly) NSObject *objc;

@end

@implementation LjProxy

- (id)transformObjc:(NSObject *)objc{
   _objc = objc;
    return self;
}

+ (instancetype)proxyWithObjc:(id)objc{
    return  [[self alloc] transformObjc:objc];
}

// 有了方法签名之后就会调用方法实现
- (void)forwardInvocation:(NSInvocation *)invocation{
    SEL sel = [invocation selector];
    if ([self.objc respondsToSelector:sel]) {
        [invocation invokeWithTarget:self.objc];
    }
}

// 查询该方法的方法签名
- (NSMethodSignature *)methodSignatureForSelector:(SEL)sel{
    NSMethodSignature *signature;
    if (self.objc) {
        signature = [self.objc methodSignatureForSelector:sel];
    }else{
        signature = [super methodSignatureForSelector:sel];
    }
    return signature;
}

- (BOOL)respondsToSelector:(SEL)aSelector{
    return [self.objc respondsToSelector:aSelector];
}

@end

自定义Man和Teacher类

@implementation Man

- (void)likeFood {
    NSLog(@"%@-->牛肉", self);
}

@end

@implementation Teacher

- (void)likeWork {
    NSLog(@"%@->教书育人", self);
}

@end

通过LjProxy实现多继承功能 通过LjProxy解决定时器中self的强引用问题 运行打印：

总结

循环引用解决的根本方式：

• 1.打破self对block的强引用，这需要对block进行声明的时候使用weak修饰，但是这会导致block提前释放，所以这种方式不可行
• 2.打破block对self的强引用，主要就是self的作用域和block作用域的数据交换问题，我们可以通过代理，通知，传值等几种方式，用于解决循环，我们对上面讲的列一下
  • weak-strong-dance（弱强共舞）
  • __block修饰变量
  • 对象self作用参数使用
  • 使用NSProxy子类代替self 上面介绍了block的定义，用法以及如何解决循环引用，下面我们来探寻下block的C++实现

Block C++实现

研究底层可以先从C++，断点调试开始

本质

创建block.c文件 通过xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc block.c -o block.cpp，将block.c编译成block.cpp，其中block在底层被编译成了以下的形式 相当于block等于__main_block_impl_0，是一个函数。下面查看__main_block_impl_0

通过上图我们可以知道__main_block_impl_0是一个结构体，同时可以说明block是一个__main_block_impl_0类型的对象，这也是为什么block能够%@打印的原因

我们用一张图来说明他们之间的联系 下面我们来解释几个问题

block为什么需要调用

在底层block的类型__main_block_impl_0结构体，通过其同名构造函数创建，第一个传入的block的内部实现代码块，即__main_block_func_0，用fp表示，然后赋值给impl的FuncPtr属性，然后在main中进行了调用，这也是block为什么需要调用的原因。如果不调用，block内部实现的代码块将无法执行，可以总结为以下两点

• 1.函数声明：即block内部实现声明成了一个函数__main_block_func_0
• 2.执行具体的函数实现：通过调用block的FuncPtr指针，调用block执行

block是如何获取外界变量的

我们将上面的代码当中调用block 再将它编译成.cpp文件

__main_block_func_0中的a是值拷贝，如果此时在block内部实现中作 a++操作，是有问题的，会造成编译器的代码歧义，即此时的a是只读的。

【总结】：block捕获外界变量时，在内部会自动生成同一个属性来保存

__block原理

将上面代码的局部变量a使用__block修饰 再将它编译成.cpp文件 通过上面的截图我们可以得出以下结论：

• 1.main中的a是以__Block_byref_a_0结构体的形式出现的，是封装的对象
• 2.在结构体__Block_byref_a_0中，a的值存在int a中
• 3.在__main_block_impl_0中，将对象a的地址&a给构造函数
• 4.在__main_block_func_0内部对a的处理时指针拷贝，此时创建的对象a与传入对象的a指向的是同一片内存空间

总结

• 1.外界变量通过__block生成__Block_byref_a_0结构体
• 2.结构体用来保存原始变量的指针和值
• 3.将变量生成的结构体对象的指针地址传递给block，然后在block内部就可以对外界变量进行操作了 上面__block和非__block修饰局部变量产生两种不同的拷贝
• 非__block修饰：值拷贝 - 浅拷贝，只是拷贝数值，且拷贝的值不可更改，指向不同的内存空间，非__block修饰的变量a就是值拷贝
• __block修饰：指针拷贝 - 深拷贝，生成的对象指向同一片内存空间，通过__block修饰的变量a就是指针拷贝

Block底层原理

确定block源码位置

在main函数中写如下代码 通过在block处打断点，运行block 我们发现走到了objc_retainBlock，我们加符号断点objc_retainBlock 打印符号断点后，我们发现执行了_Block_copy，我们再加符号断点_Block_copy 此时我们需要看_Block_copy实现，它在libsystem_blocks.dylib源码中，我们去苹果官方下载下源码libclosure-74，在源码中搜索_Block_copy 通过查看_Block_copy的源码实现，发现block在底层的真正类型是Block_layout

Block真正类型Block_layout

我们查看下Block_layout底层实现 说明：

• 1.isa：指向的是block类型的类
• 2.flags：标识符，按bit位表示一些block的附加信息，类似于isa中的位域，其中flags的种类有以下几种，主要重点关注BLOCK_HAS_COPY_DISPOSE 和 BLOCK_HAS_SIGNATURE。 BLOCK_HAS_COPY_DISPOSE 决定是否有Block_descriptor_2。BLOCK_HAS_SIGNATURE 决定是否有Block_descriptor_3
  • 第一位：BLOCK_DEALLOCATING，释放标记，一般常用 BLOCK_NEEDS_FREE做位与操作，一同传入Flags，告知该block可释放
  • 第十六位：BLOCK_REFCOUNT_MASK，存储引用计数的值;是一个可选用参数
  • 第二十四位：BLOCK_NEEDS_FREE，第16是否有有效的标志，程序根据它来决定是否增加或是减少引用计数位的
  • 第二十五位：BLOCK_HAS_COPY_DISPOSE，是否拥有拷贝辅助函数(a copy helper function)
  • 第二十六位：BLOCK_HAS_CTOR，是否拥有block析构函数
  • 第二十七位：BLOCK_IS_GC，标志是否有垃圾回收 //OS X
  • 第二十八位：BLOCK_IS_GLOBAL，标志是否是全局block
  • 第三十位位：BLOCK_HAS_SIGNATURE，与BLOCK_USE_STRET相对，判断当前block是否拥有一个签名。用于runtime时动态调用
• 3.reserved：保留信息，可以理解预留位置，猜测是用于存储block内部变量信息
• 4.invoke：是一个函数指针，指向block的执行代码
• 5.descriptor：block的附加信息，比如保留变量数、block的大小、进行copy或dispose的辅助函数指针。有三类
  • Block_descriptor_1是必选
  • Block_descriptor_2和Block_descriptor_3是可选的 我们再看下他们底层实现

从上图可以知道：Block_descriptor_2和Block_descriptor_3都是通过Block_descriptor_1的地址，经过内存平移得到的

Block内存变化

根据符号断点

我们打断点运行，走到objc_retainBlock，我们打印寄存器x0

我们发现此时的block是全局block，即__NSGlobalBlock__类型

我们增加外部变量a，再次运行，在相同的位置再次打印x0

此时读取block发现是栈block即__NSStackBlock__ 执行到符号断点objc_retainBlock时，我们发现还是栈区block

我们在增加符号断点_Block_copy，继续往下走，来到_Block_copy断点，此时打印

此时的x0地址不变，说明此时的block还是栈区block，我们在_Block_copy尾部ret处打断点，执行到断点处，再次打印 发现经过_Block_copy之后，x0的地址发生了变化，我们打印x0地址后发现block由栈区block变为堆区block，即__NSMallocBlock__

同样上面的结论我们也可以通过读寄存器地址来得出

根据寄存器地址

我们重新运行项目，继续前面的断点，运行前面的断点，打印x0，x8，x9

此时我们看到x0和x8指向的是同一块内存空间，用于存储__NSStackBlock__，此时的x9存储的是_block_invoke 我们将代码运行到41行，在次打印上面的地址 此时的x8是_block_invoke，blr就是跳转进入的意思，也就是要进入_block_invoke里 当我们进入_block_invoke中，可以得出是通过内存平移得到block内部实现的

前面提到的Block_layout的结构体源码中知道其有个属性invoke，即block的执行者，是从isa首地址平移16字节得到invoke，然后进行调用执行的。

Block签名

最开始我们拿到了block的地址，前面底层我们知道block底层是Block_layout的结构体 通过上图我们知道descriptor是附加信息，我们打印下它的内容

找到block地址，通过内存平移找到descriptor，然后x/8gx查看descriptor内存情况，我们前面说了descriptor会有_Block_descriptor_2或者_Block_descriptor_3，只有_Block_descriptor_3存在签名。 判断是否存在_Block_descriptor_2，即flags的BLOCK_HAS_COPY_DISPOSE（拷贝辅助函数）是否有值

• 1.先通过p/x 1<<25，即1左移25位得到BLOCK_HAS_COPY_DISPOSE
• 2.再拿flags与上BLOCK_HAS_COPY_DISPOSE（flags是block首地址平移8字节，即：0x00000000c1000002 看到打印结果为0，表示没有Block_descriptor_2。

判断是否存在Block_descriptor_3，即flags的BLOCK_HAS_SIGNATURE（是否有签名）是否有值

• 1.先通过p/x 1<<30，即1左移30位得到BLOCK_HAS_SIGNATURE
• 2.再拿flags与上BLOCK_HAS_SIGNATURE（flags是block首地址平移8字节，还是：0x00000000c1000002 看到打印的结果不为0，说明有值，说明是Block_descriptor_3，存在签名，看descriptor，其中第三个0x0000000104d63e87表示签名。我们将签名打印出来了 下面我们通过[NSMethodSignature signatureWithObjCTypes:"v8@?0"]看下签名具体内容 下面我们具体来看下签名：

return value: -------- -------- -------- --------
        type encoding (v) 'v'
        flags {}
        modifiers {}
        frame {offset = 0, offset adjust = 0, size = 0, size adjust = 0}
        memory {offset = 0, size = 0}
    argument 0: -------- -------- -------- --------
        type encoding (@) '@?' // 类型是否是@
        flags {isObject, isBlock} // @是isObject ，？是isBlock，代表 isBlockObject
        modifiers {}
        frame {offset = 0, offset adjust = 0, size = 8, size adjust = 0}
        memory {offset = 0, size = 8} // 所在偏移位置是8字节

block的签名信息类似于方法的签名信息，主要体现在block返回值，参数以及类型等信息上。

Block的三次copy分析

Block_copy源码分析

• 进入_Block_copy源码，将block从栈区拷贝至堆区
  • 如果需要释放，如果需要则直接释放
  • 如果是globalBlock，则不需要copy，直接返回
  • 反之，只有两种情况：栈区blockor堆区block，由于堆区block需要申请空间，前面并没有申请空间的相关代码，所以只能是栈区block
    • 通过malloc申请内存空间用于接收block
    • 通过memmove将block拷贝至新申请的内存中
    • 设置block对象的类型为堆区block，即result->isa = _NSConcreteMallocBlock

_Block_object_assign分析

要分析block的三层copy，首先需要知道外部变量的种类有哪些，在__block的cpp文件中，对block修饰__main_block_desc_0_DATA，而__main_block_desc_0_DATA用的__main_block_copy_0，最后对a的修饰_Block_object_assign。对block修饰其中用的最多的是BLOCK_FIELD_IS_OBJECT和BLOCK_FIELD_IS_BYREF 而_Block_object_assign是在底层编译代码中，外部变量拷贝是调用的方法就是它。看下_Block_object_assign的源码

• 1.如果是普通对象，则交给ARC处理，并拷贝对象指针，即引用计数+1，所以外界变量不能释放
• 2.如果是block类型的，则通过_Block_copy操作，将block从栈区拷贝到堆区
• 3.如果是__block修饰的变量，调用_Block_byref_copy函数，进行内存拷贝以及常规处理 我们看下_Block_byref_copy源码实现
• 1.将传入对象，强转为Block_byref结构体类型对象，保存一份
• 2.没有将外界变量拷贝到堆，需要申请内存，进行拷贝
• 3.如果已经拷贝过了，则进行处理并返回
• 4.其中copy和src的forwarding指针都指向同一片内存，这也是为什么__block修饰的对象具有修改能力的原因

代码验证

写如下代码： 进行clang编译结果如下

• 1.编译后lj_name比普通变量多了__Block_byref_id_object_copy_131和__Block_byref_id_object_dispose_131
• 2.__Block_byref_lj_name_0结构体中多了__Block_byref_id_object_copy和__Block_byref_id_object_dispose

通过上面的分析，我们可以知道这些方法的执行顺序_Block_copy->_Block_byref_copy->_Block_object_assign,正好对应上述的三层copy 综上所述，那么block是如何拿到lj_name的呢？

• 1.通过__block_copy方法，将block拷贝至堆区
• 2.通过_Block_object_assign方法正常拷贝，因为__block修饰的外界变量在底层是Block_byref结构体
• 3.发现外部变量还存在一个对象，从bref中取出相应的对象lj_name，拷贝至block控件，才能使用（相同空间才能使用，不同则不能使用）。最后通过内存平移得到lj_name，此时的lj_name和外界lj_name是同一片内存空间（从_Block_object_assign方法中的*dest = object;看出）

三层copy总结

通过上面我们看出，block的三层拷贝指的是以下三层：

• 【第一层】通过_Block_copy实现对象的自身拷贝,从栈区拷贝至堆区
• 【第二层】通过_Block_byref_copy方法，将对象拷贝为Block_byref结构体类型
• 【第三层】调用_Block_object_assign方法，对__block修饰的当前变量的拷贝 【注意】只有__block修饰的对象才三层copy

拓展

_Block_object_dispose 分析

在__Block_byref_id_object_dispose_131实现中调用的就是_Block_object_dispose，下面我们看下_Block_object_dispose的底层实现：

通过源码我们可以知道_Block_object_dispose是进行release操作，通过不同分区的block，进行不同的释放操作。而_Block_object_assign是进行retain操作的，

下面看看_Block_byref_release实现 下面我们画图来更容易的了解Block的三层copy的流程

写到最后

写的内容比较多，由于本人能力有限，有些地方可能解释的有问题，请各位能够指出，同时对Block有关的疑问，欢迎大家留言。希望大家能够相互交流、探索，一起进步！