024＊：Block的原理 （Block_layout、__main_block_impl_0、__Block_byref_a_0）（_Block_copy、_block_invoke）（_Block_copy、_Block_byref_copy、_Block_object_assign、_Block_object_dispose）
问题
1：block的本质是对象、函数、结构体，由于block函数没有名称，也被称为匿名函数
2: __weak __strong __block
3：（NSGlobalBlock NSMallocBlock NSStackBlock）
4：（_Block_copy、_block_invoke）
5：（_Block_copy、_Block_byref_copy、_Block_object_assign、_Block_object_dispose）
三层copy
【第一层】通过_Block_copy实现对象的自身拷贝,从栈区拷贝至堆区
【第二层】通过_Block_byref_copy方法，将对象拷贝为Block_byref结构体类型
【第三层】调用_Block_object_assign方法，对__block修饰的当前变量的拷贝
目录
1：Block简介
2：Block类型
3：Block循环引用
4：Block C++实现
5：Block底层原理
预备
正文
一：Block简介
Block定义：带有自动变量的匿名函数，它是C语言的拓展功能，之所以是扩展，是因为C语言不允许存在这样的匿名函数
- 匿名函数
- 匿名函数式指不带函数名称的函数
- 带有自定变量
- Block拥有捕获外部变量的功能,只读属性，在Block中访问一个外部的局部变量，Block会持有它的临时状态，自动捕获变量值，外部局部变量的变化不会影响它的状态（这个下面会讲到）并且把值截取到响应的作用域中
二：Block类型
block主要有三种类型：__NSGlobalBlock__ __NSMallocBlock__ __NSStackBlock__
__NSGlobalBlock__：无入参时，是全局Block__NSMallocBlock__：有外部变量时，变成堆区Block__NSStackBlock__：有外部变量，使用__weak修饰时，变成栈区Block
| 类别 | 存储域 | 详情 |
|---|---|---|
| _NSConcreteStackBlock | 栈区 | 自动截获变量并且在该变量作用域内 |
| _NSConcreteGlobalBlock | 静态全局区域（.data区） | 在定义全局变量的地方定义Block；Block语法的表达式中不截获任何变量时，或只截获了全局变量、静态变量 |
| _NSConcreteMallocBlock | 堆区 | 当_NSConcreteStackBlock超出变量作用域，ARC大多数情况下，编译器进行适当判断后调用_Block_copy拷贝到堆上 |
- (void)demo { // 【3种block类型】 // 1. __NSGlobalBlock__ (无入参时，是全局Block) void(^block1)(void) = ^{ NSLog(@"HT_Block"); }; NSLog(@"%@",block1); // 打印： <__NSGlobalBlock__: 0x102239040> // 2. __NSMallocBlock__ (有外部变量时，变成堆区Block) int a = 10; void(^block2)(void) = ^{ NSLog(@"HT_Block %d",a); }; NSLog(@"%@",block2); // 打印： <__NSMallocBlock__: 0x600000f970c0> //3. __NSStackBlock__ (有外部变量，使用__weak修饰，变成栈区Block) int b = 20; void(^__weak block3)(void) = ^{ NSLog(@"HT_Block %d",b); }; NSLog(@"%@",block3); // 打印 <__NSStackBlock__: 0x7ffeedae8240> }
1：__NSGlobalBlock__：全局block，存储在全局区，没有访问外部变量
2：__NSMallocBlock__：堆区block，因为block既是函数，也是对象。访问外部变量3.__NSStackBlock__：栈区block。
3.1：没有copy之前
其中局部变量a在没有处理之前（即没有拷贝之前）是 栈区block， 处理后（即拷贝之后）是堆区block ，目前的栈区block越来越少了
当block出栈就会销毁的时候为 __NSStackBlock__，block为函数参数是也是 __NSStackBlock__。
int a = 10; void (^ malloBlock)(void) = ^{ NSLog(@"Cooci - %d",a); }; NSLog(@"%@",malloBlock); ....................... <__NSStackBlock__: 0x7ffee6c473f8>
3.2：可以通过__weak不进行强持有，block就还是栈区block
三：Block循环引用
1：dealloc正常释放和循环引用
-
正常释放：是指A持有B的引用，当A调用dealloc方法，给B发送release信号，B收到release信号，如果此时B的retainCount（即引用计数）为0时，则调用B的dealloc方法 -
循环引用：A、B相互持有，所以导致A无法调用dealloc方法给B发送release信号，而B也无法接收到release信号。所以A、B此时都无法释放
2：解决循环引用
2.1：请问下面两段代码有循环引用吗？
//代码一 NSString *name = @"CJL"; self.block = ^(void){ NSLog(@"%@",self.name); }; self.block(); //代码二 UIView animateWithDuration:1 animations:^{ NSLog(@"%@",self.name); };
代码一种发生了循环引用，因为在block内部使用了外部变量name，导致block持有了self，而self原本是持有block的，所以导致了self和block的相互持有。
代码二中无循环引用，虽然也使用了外部变量，但是self并没有持有animation的bblock，仅仅只有animation持有self，不构成相互持有
2.2：解决循环引用常见的方式有以下几种
-
【方式一】
weak-strong-dance -
【方式二】
__block修饰对象（需要注意的是在block内部需要置空对象，而且block必须调用） -
【方式三】传
递对象self作为block的参数，提供给block内部使用 -
【方式四】使用
NSProxy
typedef void(^HTBlock)(void); typedef void(^HTBlock2)(ViewController *); @interface ViewController () @property (nonatomic, copy) NSString *name; @property (nonatomic, copy) HTBlock block; @property (nonatomic, copy) HTBlock2 block2; @end @implementation ViewController - (void)viewDidLoad { [super viewDidLoad]; self.name = @"ht"; // // 循环引用 [self持有block，block持有self] // self.block = ^(void){ // NSLog(@"%@",self.name); // }; // self.block(); // // // 没有循环引用 （UIView的block持有self，self与UIView的block无关） // [UIView animateWithDuration:1 animations:^{ // NSLog(@"%@",self.name); // }]; // 方法1： `weakSelf`弱引用`self`，搭配`strongSelf` // weak不会让self的引用计数+1，所以不影响self的释放。 而strongSelf持有的是weakSelf。 // 当self释放时，如果block执行完了，strongSelf局部变量就会被释放，此时weakSelf也被释放。所以不会造成循环引用 // __weak typeof(self) weakSelf = self; // self.block = ^{ // __strong typeof(self) strongSelf = weakSelf; // NSLog(@"%@",strongSelf.name); // }; // self.block(); // // 方法2：使用`__block`修饰对象（`必须`在block中`置空对象`，且block必须`被调用`） // __block ViewController * vc = self; // self.block = ^(void){ // NSLog(@"%@",vc.name); // vc = nil; // 必须手动释放。 因为vc持有了self,vc不释放，self永远不可能释放。 // }; // self.block(); // 必须调用block。 因为vc持有了self,不过不执行block，vc永远没有nil，self永远不会释放 // 方法3：`传`对象`self`作`参数`，提供`给代码块使用` // 最佳的使用方式，因为不会影响self的正常释放。（调用时，引用计数会+1，但是调用完后，就会-1，不影响self的生命周期） self.block2 = ^(ViewController * vc) { NSLog(@"%@",vc.name); }; self.block2(self); } @end
方式一：weak-stong-dance 弱强共舞
__weak typeof(self) weakSelf = self;
__strong typeof(self) strongSelf = weakSelf;
- 此时的
weakSelf和self指向同一片内存空间，且使用__weak不会导致self的引用计数发生变化，可以通过打印weakSelf和self的指针地址，以及self的引用计数来验证
- 其中
strongSelf是一个临时变量，在cjlBlock的作用域内，即内部block执行完就释放strongSelf
这种方式属于打破self对block的强引用，依赖于中介者模式，属于自动置为nil，即自动释放
方式二：__block修饰变量
是变量作用域 在被 Block 和 __block修饰符作用后生命周期发生的变化
__block变量存储域
捕获了__block修饰符的外部变量的Block，__block变量的存储域也会受到影响。
| __block变量的配置存储域 | Block从栈复制到堆时的影响 |
|---|---|
| 栈 | 从栈复制到堆并被Block持有 |
| 堆 | 被Block持有 |
当block释放的时候，__block修饰的变量，需要自己手动释放。
需要注意的是这里的
block必须调用，如果不调用block，vc就不会置空，那么依旧是循环引用，self和block都不会被释放方式三：对象self作为参数
主要是将对象self作为参数，提供给block内部使用，不会有引用计数问题
2.3：NSProxy 虚拟类
-
OC是只能单继承的语言，但是它是基于运行时的机制，所以可以通过NSProxy来实现伪多继承，填补了多继承的空白 -
NSProxy和NSObject是同级的一个类，也可以说是一个虚拟类，只是实现了NSObject的协议 -
NSProxy其实是一个消息重定向封装的一个抽象类，类似一个代理人，中间件，可以通过继承它，并重写下面两个方法来实现消息转发到另一个实例
- (void)forwardInvocation:(NSInvocation *)invocation; - (nullable NSMethodSignature *)methodSignatureForSelector:(SEL)sel
使用场景
NSProxy的使用场景主要有两种
- 实现
多继承功能 - 解决了
NSTimer&CADisplayLink创建时对self强引用问题，参考YYKit的YYWeakProxy。
循环引用解决原理
主要是通过自定义的NSProxy类的对象来代替self，并使用方法实现消息转发
下面是NSProxy子类的实现以及使用的场景
- 自定义一个
NSProxy的子类CJLProxy
@interface CJLProxy : NSProxy - (id)transformObjc:(NSObject *)objc; + (instancetype)proxyWithObjc:(id)objc; @end @interface CJLProxy () @property(nonatomic, weak, readonly) NSObject *objc; @end @implementation CJLProxy - (id)transformObjc:(NSObject *)objc{ _objc = objc; return self; } + (instancetype)proxyWithObjc:(id)objc{ return [[self alloc] transformObjc:objc]; } //2.有了方法签名之后就会调用方法实现 - (void)forwardInvocation:(NSInvocation *)invocation{ SEL sel = [invocation selector]; if ([self.objc respondsToSelector:sel]) { [invocation invokeWithTarget:self.objc]; } } //1、查询该方法的方法签名 - (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
- 自定义
Cat类和Dog类
//********Cat类******** @interface Cat : NSObject @end @implementation Cat - (void)eat{ NSLog(@"猫吃鱼"); } @end //********Dog类******** @interface Dog : NSObject @end @implementation Dog - (void)shut{ NSLog(@"狗叫"); } @end
- 通过CJLProxy实现
多继承功能
- (void)cjl_proxyTest{ Dog *dog = [[Dog alloc] init]; Cat *cat = [[Cat alloc] init]; CJLProxy *proxy = [CJLProxy alloc]; [proxy transformObjc:cat]; [proxy performSelector:@selector(eat)]; [proxy transformObjc:dog]; [proxy performSelector:@selector(shut)]; }
- 通过CJLProxy解决
定时器中self的强引用问题
self.timer = [NSTimer timerWithTimeInterval:1 target:[CJLProxy proxyWithObjc:self] selector:@selector(print) userInfo:nil repeats:YES]; [[NSRunLoop currentRunLoop] addTimer:self.timer forMode:NSRunLoopCommonModes];
总结
循环应用的解决方式从根本上来说就两种，以self -> block -> self为例
-
打破
self 对 block的强引用，可以block属性修饰符使用weak，但是这样会导致block还每创建完就释放了，所以从这里打破强引用行不通 -
打破
block对self的强引用，主要就是self的作用域和block作用域的通讯，通讯有代理、传值、通知、传参等几种方式，用于解决循环，常见的解决方式如下：-
weak-strong-dance -
__block(block内对象置空，且调用block) -
将对象
self作为block的参数 -
通过
NSProxy的子类代替self
-
四：Block C++实现,Block 底层分析
1:定义block.c文件
#include "stdio.h" int main(){ void(^block)(void) = ^{ printf("CJL"); }; return 0; }
通过xcrun -sdk iphonesimulator clang -arch x86_64 -rewrite-objc block.c，将block.c 编译成 block.cpp，其中block在底层被编译成了以下的形式
int main(){ void(*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA)); ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block); return 0; } static void __main_block_func_0(struct __main_block_impl_0 *__cself) { printf("CJL"); } //******简化****** void(*block)(void) = __main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA));//构造函数 block->FuncPtr(block);//block调用执行
2: 相当于block等于__main_block_impl_0，是一个函数
查看__main_block_impl_0，是一个结构体，同时可以说明block是一个__main_block_impl_0类型的对象，这也是为什么block能够%@打印的原因
//**block代码块的结构体类型** 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; } }; //**block的结构体类型** struct __block_impl { void *isa; int Flags; int Reserved; void *FuncPtr; };
总结：block的本质是对象、函数、结构体，由于block函数没有名称，也被称为匿名函数
1、block为什么需要调用
在底层block的类型__main_block_impl_0结构体，通过其同名构造函数创建，第一个传入的block的内部实现代码块，即__main_block_func_0，用fp表示，然后赋值给impl的FuncPtr属性，然后在main中进行了调用，这也是block为什么需要调用的原因。如果不调用，block内部实现的代码块将无法执行，可以总结为以下两点
-
函数声明：即block内部实现声明成了一个函数__main_block_func_0 -
执行具体的函数实现：通过调用block的FuncPtr指针，调用block执行
2、block是如何获取外界变量的
- 定义一个变量，并在block中调用
int main(){ int a = 11; void(^block)(void) = ^{ printf("CJL - %d", a); }; block(); return 0; }
- 底层编译成下面这样
struct __main_block_impl_0 { struct __block_impl impl; struct __main_block_desc_0* Desc; int a;//编译时就自动生成了相应的变量 __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _a, int flags=0) : a(_a) { impl.isa = &_NSConcreteStackBlock;//block的isa默认是stackBlock impl.Flags = flags; impl.FuncPtr = fp; Desc = desc; } }; static void __main_block_func_0(struct __main_block_impl_0 *__cself) { int a = __cself->a; // bound by copy 值拷贝，即 a = 10，此时的a与传入的__cself的a并不是同一个 printf("CJL - %d", a); } int main(){ int a = 11; void(*block)(void) = __main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA, a)); block)->FuncPtr(block); return 0; }
__main_block_func_0中的a是值拷贝，如果此时在block内部实现中作 a++操作，是有问题的，会造成编译器的代码歧义，即此时的a是只读的
总结：block捕获外界变量时，在内部会自动生成同一个属性来保存
__block的原理
- 对
a加一个__block，然后在block中对a进行++操作
int main(){ __block int a = 11; void(^block)(void) = ^{ a++; printf("CJL - %d", a); }; block(); return 0; }
底层编译为如下
-
main中的
a是通过外界变量封装的对象 -
__main_block_impl_0中，将对象a的地址&a给构造函数 -
在
__main_block_func_0内部对a的处理是指针拷贝，此时创建的对象a与传入对象的a指向同一片内存空间
struct __Block_byref_a_0 {//__block修饰的外界变量的结构体 void *__isa; __Block_byref_a_0 *__forwarding; int __flags; int __size; int a; }; struct __main_block_impl_0 {//block的结构体类型 struct __block_impl impl; struct __main_block_desc_0* Desc; __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; } }; static void __main_block_func_0(struct __main_block_impl_0 *__cself) {//block内部实现 __Block_byref_a_0 *a = __cself->a; // bound by ref 指针拷贝，此时的对象a 与 __cself对象的a 指向同一片地址空间 //等同于 外界的 a++ (a->__forwarding->a)++; printf("CJL - %d", (a->__forwarding->a)); } static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->a, (void*)src->a, 8/*BLOCK_FIELD_IS_BYREF*/);} static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->a, 8/*BLOCK_FIELD_IS_BYREF*/);} int main(){ //__Block_byref_a_0 是结构体，a 等于 结构体的赋值，即将外界变量a 封装成对象 //&a 是外界变量a的地址 __attribute__((__blocks__(byref))) __Block_byref_a_0 a = {(void*)0,(__Block_byref_a_0 *)&a, 0, sizeof(__Block_byref_a_0), 11}; //__main_block_impl_0中的第三个参数&a，是封装的对象a的地址 void(*block)(void) = __main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_a_0 *)&a, 570425344)); ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block); return 0; }
- 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指向的是同一片内存空间
总结：
-
外界变量会生成__Block_byref_a_0结构体 -
结构体用来
保存原始变量的指针和值 -
将变量生成的
结构体对象的指针地址 传递给block，然后在block内部就可以对外界变量进行操作了
两种拷贝对比如下
-
值拷贝- 浅拷贝，只是拷贝数值，且拷贝的值不可更改，指向不同的内存空间，案例中普通变量a就是值拷贝 -
指针拷贝- 深拷贝，生成的对象指向同一片内存空间，案例中经过__block修饰的变量a就是指针拷贝
五：Block底层原理：block底层真正类型
1：分析block源码所在位置
1：在main函数中写如下代码
2：会走objc_retainBlock
3：加objc_retainBlock 符号断点，发现会走到_Block_copy
4：加_Block_copy符号断点，运行断住，在libsystem_blocks.dylib源码中
5：查看源码，可以关注到block的结构类型为Block_layout：（后面会明白为什么是Block_layout）
源码地址 ，搜索libclosure-74
2：Block真正类型 Block_layout
查看Block_layout类型的定义，是一个结构体
// CJL注释:Block 结构体 struct Block_layout { //指向表明block类型的类 void *isa;//8字节 //用来作标识符的，类似于isa中的位域,按bit位表示一些block的附加信息 volatile int32_t flags; // contains ref count 4字节 //保留信息，可以理解预留位置，用于存储block内部变量信息 int32_t reserved;//4字节 //函数指针，指向具体的block实现的调用地址 BlockInvokeFunction invoke; //block的附加信息 struct Block_descriptor_1 *descriptor; // imported variables };
说明：
- 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时动态调用
- 第一位：
// CJL注释: flags 标识 // Values for Block_layout->flags to describe block objects enum { //释放标记，一般常用于BLOCK_BYREF_NEEDS_FREE做位与运算，一同传入flags，告知该block可释放 BLOCK_DEALLOCATING = (0x0001), // runtime //存储引用引用计数的 值，是一个可选用参数 BLOCK_REFCOUNT_MASK = (0xfffe), // runtime //低16位是否有效的标志，程序根据它来决定是否增加或者减少引用计数位的值 BLOCK_NEEDS_FREE = (1 << 24), // runtime //是否拥有拷贝辅助函数，（a copy helper function）决定block_description_2 BLOCK_HAS_COPY_DISPOSE = (1 << 25), // compiler //是否拥有block C++析构函数 BLOCK_HAS_CTOR = (1 << 26), // compiler: helpers have C++ code //标志是否有垃圾回收，OSX BLOCK_IS_GC = (1 << 27), // runtime //标志是否是全局block BLOCK_IS_GLOBAL = (1 << 28), // compiler //与BLOCK_HAS_SIGNATURE相对，判断是否当前block拥有一个签名，用于runtime时动态调用 BLOCK_USE_STRET = (1 << 29), // compiler: undefined if !BLOCK_HAS_SIGNATURE //是否有签名 BLOCK_HAS_SIGNATURE = (1 << 30), // compiler //使用有拓展，决定block_description_3 BLOCK_HAS_EXTENDED_LAYOUT=(1 << 31) // compiler };
- 3.
reserved：保留信息，可以理解预留位置，猜测是用于存储block内部变量信息 - 4.
invoke：是一个函数指针，指向block的执行代码 - 5.
descriptor：block的附加信息，比如保留变量数、block的大小、进行copy或dispose的辅助函数指针。有三类Block_descriptor_1是必选Block_descriptor_2和Block_descriptor_3是可选的
#define BLOCK_DESCRIPTOR_1 1 struct Block_descriptor_1 { uintptr_t reserved;//保留信息 uintptr_t size;//block大小 }; #define BLOCK_DESCRIPTOR_2 1 struct Block_descriptor_2 { // requires BLOCK_HAS_COPY_DISPOSE BlockCopyFunction copy;//拷贝函数指针 BlockDisposeFunction dispose; }; #define BLOCK_DESCRIPTOR_3 1 struct Block_descriptor_3 { // requires BLOCK_HAS_SIGNATURE const char *signature;//签名 const char *layout; // contents depend on BLOCK_HAS_EXTENDED_LAYOUT 布局 };
以上关于descriptor的可以从其构造函数中体现，其中
Block_descriptor_2和Block_descriptor_3都是通过Block_descriptor_1的地址，经过内存平移得到的static struct Block_descriptor_1 * _Block_descriptor_1(struct Block_layout *aBlock) { return aBlock->descriptor;//默认打印 } #endif // CJL注释:Block 的描述 : copy 和 dispose 函数 static struct Block_descriptor_2 * _Block_descriptor_2(struct Block_layout *aBlock) { if (! (aBlock->flags & BLOCK_HAS_COPY_DISPOSE)) return NULL; uint8_t *desc = (uint8_t *)aBlock->descriptor;//descriptor_1的地址 desc += sizeof(struct Block_descriptor_1);//通过内存平移获取 return (struct Block_descriptor_2 *)desc; } // CJL注释: Block 的描述 : 签名相关 static struct Block_descriptor_3 * _Block_descriptor_3(struct Block_layout *aBlock) { if (! (aBlock->flags & BLOCK_HAS_SIGNATURE)) return NULL; uint8_t *desc = (uint8_t *)aBlock->descriptor; desc += sizeof(struct Block_descriptor_1); if (aBlock->flags & BLOCK_HAS_COPY_DISPOSE) { desc += sizeof(struct Block_descriptor_2); } return (struct Block_descriptor_3 *)desc; }
3：Block内存变化
1：objc_retainBlock 我们发现此时的block是全局block，即__NSGlobalBlock__类型 或者 __NSStackBlock__2：增加
_Block_copy符号断点并断住，直接在最后的ret加断点，读取x0，发现经过_Block_copy之后，变成了 堆block，即__NSMallocBlock__，主要是因为block地址发生了改变，为堆block
3：
_block_invoke中，可以得出是通过内存平移得到block内部实现的，前面提到的Block_layout的结构体源码中知道其有个属性invoke，即block的执行者，是从isa首地址平移16字节得到invoke，然后进行调用执行的。4：找到
block地址，通过内存平移找到descriptor，然后x/8gx查看descriptor内存情况，我们前面说了descriptor会有_Block_descriptor_2或者_Block_descriptor_3，只有_Block_descriptor_3存在签名。
4：Block的三次copy分析
_Block_copy源码分析
- 进入
_Block_copy源码，将block 从栈区拷贝至堆区-
如果需要释放，如果需要则直接释放
-
如果是
globalBlock-- 不需要copy，直接返回 -
反之，只有两种情况：栈区block or 堆区block，由于堆区block需要申请空间，前面并没有申请空间的相关代码，所以只能是
栈区block，-
通过
malloc申请内存空间用于接收block -
通过
memmove将block拷贝至新申请的内存中 -
设置block对象的类型为堆区block，即
result->isa = _NSConcreteMallocBlock
-
-
// Copy, or bump refcount, of a block. If really copying, call the copy helper if present. // CJL重点提示: 这里是核心重点 block的拷贝操作: 栈Block -> 堆Block void *_Block_copy(const void *arg) { struct Block_layout *aBlock; if (!arg) return NULL; // The following would be better done as a switch statement aBlock = (struct Block_layout *)arg;//强转为Block_layout类型对象，防止对外界造成影响 if (aBlock->flags & BLOCK_NEEDS_FREE) {//是否需要释放 // latches on high latching_incr_int(&aBlock->flags); return aBlock; } else if (aBlock->flags & BLOCK_IS_GLOBAL) {//如果是全局block，直接返回 return aBlock; } else {//为栈block 或者 堆block，由于堆区需要申请内存，所以只可能是栈区 // Its a stack block. Make a copy. 它是一个堆栈块block，拷贝。 struct Block_layout *result = (struct Block_layout *)malloc(aBlock->descriptor->size);//申请空间并接收 if (!result) return NULL; //通过memmove内存拷贝，将 aBlock 拷贝至result memmove(result, aBlock, aBlock->descriptor->size); // bitcopy first #if __has_feature(ptrauth_calls) // Resign the invoke pointer as it uses address authentication. result->invoke = aBlock->invoke;//可以直接调起invoke #endif // reset refcount result->flags &= ~(BLOCK_REFCOUNT_MASK|BLOCK_DEALLOCATING); // XXX not needed 告知可释放 result->flags |= BLOCK_NEEDS_FREE | 2; // logical refcount 1 _Block_call_copy_helper(result, aBlock); // Set isa last so memory analysis tools see a fully-initialized object. result->isa = _NSConcreteMallocBlock;//设置block对象类型为堆区block return result; } }
_Block_object_assign 分析
想要分析block的三层copy，首先需要知道外部变量的种类有哪些，其中用的最多的是BLOCK_FIELD_IS_OBJECT和BLOCK_FIELD_IS_BYREF
// CJL注释: Block 捕获的外界变量的种类 // Runtime support functions used by compiler when generating copy/dispose helpers // Values for _Block_object_assign() and _Block_object_dispose() parameters enum { // see function implementation for a more complete description of these fields and combinations //普通对象，即没有其他的引用类型 BLOCK_FIELD_IS_OBJECT = 3, // id, NSObject, __attribute__((NSObject)), block, ... //block类型作为变量 BLOCK_FIELD_IS_BLOCK = 7, // a block variable //经过__block修饰的变量 BLOCK_FIELD_IS_BYREF = 8, // the on stack structure holding the __block variable //weak 弱引用变量 BLOCK_FIELD_IS_WEAK = 16, // declared __weak, only used in byref copy helpers //返回的调用对象 - 处理block_byref内部对象内存会加的一个额外标记，配合flags一起使用 BLOCK_BYREF_CALLER = 128, // called from __block (byref) copy/dispose support routines. };
而_Block_object_assign是在底层编译代码中，外部变量拷贝时调用的方法就是它
- 进入
_Block_object_assign源码-
如果是普通对象，则交给
系统arc处理，并拷贝对象指针，即引用计数+1，所以外界变量不能释放 -
如果是
block类型的变量，则通过_Block_copy操作，将block从栈区拷贝到堆区 -
如果是
__block修饰的变量，调用_Block_byref_copy函数 进行内存拷贝以及常规处理
-
static struct Block_byref *_Block_byref_copy(const void *arg) { //强转为Block_byref结构体类型，保存一份 struct Block_byref *src = (struct Block_byref *)arg; if ((src->forwarding->flags & BLOCK_REFCOUNT_MASK) == 0) { // src points to stack 申请内存 struct Block_byref *copy = (struct Block_byref *)malloc(src->size); copy->isa = NULL; // byref value 4 is logical refcount of 2: one for caller, one for stack copy->flags = src->flags | BLOCK_BYREF_NEEDS_FREE | 4; //block内部持有的Block_byref 和 外界的Block_byref 所持有的对象是同一个，这也是为什么__block修饰的变量具有修改能力 //copy 和 scr 的地址指针达到了完美的同一份拷贝，目前只有持有能力 copy->forwarding = copy; // patch heap copy to point to itself src->forwarding = copy; // patch stack to point to heap copy copy->size = src->size; //如果有copy能力 if (src->flags & BLOCK_BYREF_HAS_COPY_DISPOSE) { // Trust copy helper to copy everything of interest // If more than one field shows up in a byref block this is wrong XXX //Block_byref_2是结构体，__block修饰的可能是对象，对象通过byref_keep保存，在合适的时机进行调用 struct Block_byref_2 *src2 = (struct Block_byref_2 *)(src+1); struct Block_byref_2 *copy2 = (struct Block_byref_2 *)(copy+1); copy2->byref_keep = src2->byref_keep; copy2->byref_destroy = src2->byref_destroy; if (src->flags & BLOCK_BYREF_LAYOUT_EXTENDED) { struct Block_byref_3 *src3 = (struct Block_byref_3 *)(src2+1); struct Block_byref_3 *copy3 = (struct Block_byref_3*)(copy2+1); copy3->layout = src3->layout; } //等价于 __Block_byref_id_object_copy (*src2->byref_keep)(copy, src); } else { // Bitwise copy. // This copy includes Block_byref_3, if any. memmove(copy+1, src+1, src->size - sizeof(*src)); } } // already copied to heap else if ((src->forwarding->flags & BLOCK_BYREF_NEEDS_FREE) == BLOCK_BYREF_NEEDS_FREE) { latching_incr_int(&src->forwarding->flags); } return src->forwarding; }
进入
_Block_byref_copy源码
-
将传入的对象，强转为
Block_byref结构体类型对象，保存一份 -
没有将外界变量拷贝到堆，需要申请内存，其进行拷贝
-
如果已经拷贝过了，则进行处理并返回
-
其中copy 和 src的forwarding指针都指向同一片内存，这也是为什么__block修饰的对象具有修改能力的原因
static struct Block_byref *_Block_byref_copy(const void *arg) { //强转为Block_byref结构体类型，保存一份 struct Block_byref *src = (struct Block_byref *)arg; if ((src->forwarding->flags & BLOCK_REFCOUNT_MASK) == 0) { // src points to stack 申请内存 struct Block_byref *copy = (struct Block_byref *)malloc(src->size); copy->isa = NULL; // byref value 4 is logical refcount of 2: one for caller, one for stack copy->flags = src->flags | BLOCK_BYREF_NEEDS_FREE | 4; //block内部持有的Block_byref 和 外界的Block_byref 所持有的对象是同一个，这也是为什么__block修饰的变量具有修改能力 //copy 和 scr 的地址指针达到了完美的同一份拷贝，目前只有持有能力 copy->forwarding = copy; // patch heap copy to point to itself src->forwarding = copy; // patch stack to point to heap copy copy->size = src->size; //如果有copy能力 if (src->flags & BLOCK_BYREF_HAS_COPY_DISPOSE) { // Trust copy helper to copy everything of interest // If more than one field shows up in a byref block this is wrong XXX //Block_byref_2是结构体，__block修饰的可能是对象，对象通过byref_keep保存，在合适的时机进行调用 struct Block_byref_2 *src2 = (struct Block_byref_2 *)(src+1); struct Block_byref_2 *copy2 = (struct Block_byref_2 *)(copy+1); copy2->byref_keep = src2->byref_keep; copy2->byref_destroy = src2->byref_destroy; if (src->flags & BLOCK_BYREF_LAYOUT_EXTENDED) { struct Block_byref_3 *src3 = (struct Block_byref_3 *)(src2+1); struct Block_byref_3 *copy3 = (struct Block_byref_3*)(copy2+1); copy3->layout = src3->layout; } //等价于 __Block_byref_id_object_copy (*src2->byref_keep)(copy, src); } else { // Bitwise copy. // This copy includes Block_byref_3, if any. memmove(copy+1, src+1, src->size - sizeof(*src)); } } // already copied to heap else if ((src->forwarding->flags & BLOCK_BYREF_NEEDS_FREE) == BLOCK_BYREF_NEEDS_FREE) { latching_incr_int(&src->forwarding->flags); } return src->forwarding; }
通过上面的分析，我们可以知道这些方法的执行顺序_Block_copy->_Block_byref_copy->_Block_object_assign,正好对应上述的三层copy 综上所述，那么block是如何拿到lj_name的呢？
- 1.通过
__block_copy方法，将block拷贝至堆区 - 2.通过
_Block_object_assign方法正常拷贝，因为__block修饰的外界变量在底层_Block_byref_copy是Block_byref结构体 - 3.发现
外部变量还存在一个对象，从bref中取出相应的对象lj_name，拷贝至block控件，才能使用（相同空间才能使用，不同则不能使用）。最后通过内存平移得到lj_name，此时的lj_name和外界lj_name是同一片内存空间（从
三层copy总结
通过上面我们看出，block的三层拷贝指的是以下三层：
- 【第一层】通过
_Block_copy实现对象的自身拷贝,从栈区拷贝至堆区 - 【第二层】通过
_Block_byref_copy方法，将对象拷贝为Block_byref结构体类型 - 【第三层】调用
_Block_object_assign方法，对__block修饰的当前变量的拷贝
5：_Block_object_dispose 分析
同一般的retain和release一样，_Block_object_object其本质主要是retain，所以对应的还有一个release，即_Block_object_dispose方法，其源码实现如下，也是通过区分block种类，进行不同释放操作
// When Blocks or Block_byrefs hold objects their destroy helper routines call this entry point // to help dispose of the contents 当Blocks或Block_byrefs持有对象时，其销毁助手例程将调用此入口点以帮助处置内容 void _Block_object_dispose(const void *object, const int flags) { switch (os_assumes(flags & BLOCK_ALL_COPY_DISPOSE_FLAGS)) { case BLOCK_FIELD_IS_BYREF | BLOCK_FIELD_IS_WEAK: case BLOCK_FIELD_IS_BYREF://__block修饰的变量，即bref类型的 // get rid of the __block data structure held in a Block _Block_byref_release(object); break; case BLOCK_FIELD_IS_BLOCK://block类型的变量 _Block_release(object) ; break; case BLOCK_FIELD_IS_OBJECT://普通对象 _Block_release_object(object); break; case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_OBJECT: case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_BLOCK: case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_OBJECT | BLOCK_FIELD_IS_WEAK: case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_BLOCK | BLOCK_FIELD_IS_WEAK: break; default: break; } }
- 进入
_Block_byref_release源码，主要就是对象、变量的释放销毁
static void _Block_byref_release(const void *arg) { //对象强转为Block_byref类型结构体 struct Block_byref *byref = (struct Block_byref *)arg; // dereference the forwarding pointer since the compiler isn't doing this anymore (ever?) byref = byref->forwarding;//取消指针引用 if (byref->flags & BLOCK_BYREF_NEEDS_FREE) { int32_t refcount = byref->flags & BLOCK_REFCOUNT_MASK; os_assert(refcount); if (latching_decr_int_should_deallocate(&byref->flags)) { if (byref->flags & BLOCK_BYREF_HAS_COPY_DISPOSE) {//是否有拷贝辅助函数 struct Block_byref_2 *byref2 = (struct Block_byref_2 *)(byref+1); (*byref2->byref_destroy)(byref);//销毁拷贝对象 } free(byref);//释放 } } }
注意
