本文主要介绍block的类型、循环引用的解决方法以及block底层的分析
block 类型
block主要有三种类型
__NSGlobalBlock__
:全局block,存储在全局区
void(^block)(void) = ^{ NSLog(@"CJL"); }; NSLog(@"%@", block);
此时的block无参也无返回值,属于全局block
__NSMallocBlock__
:堆区block,因为block既是函数,也是对象
int a = 10; void(^block)(void) = ^{ NSLog(@"CJL - %d", a); }; NSLog(@"%@", block);
此时的block会访问外界变量,即底层拷贝a,所以是堆区block
__NSStackBlock__
:栈区block
int a = 10; void(^block)(void) = ^{ NSLog(@"CJL - %d", a); }; NSLog(@"%@", ^{ NSLog(@"CJL - %d", a); });
其中局部变量a在没有处理之前(即没有拷贝之前)是 栈区block
, 处理后(即拷贝之后)是堆区block
,目前的栈区block越来越少了
这个情况下,可以通过__weak
不进行强持有,block就还是栈区block
总结
- block直接存储在
全局区
- 如果
block访问外界变量
,并进行block相应拷贝,即copy
- 如果此时的
block是强引用
,则block存储在堆区
,即堆区block - 如果此时的b
lock通过__weak变成了弱引用
,则block存储在栈区
,即栈区block
Block循环引用
正常释放
:是指A持有B的引用,当A调用dealloc方法,给B发送release信号,B收到release信号,如果此时B的retainCount(即引用计数)为0时,则调用B的dealloc方法循环引用
:A、B相互持有,所以导致A无法调用dealloc方法给B发送release信号,而B也无法接收到release信号。所以A、B此时都无法释放
如下图所示
解决循环引用
请问下面两段代码有循环引用吗?
//代码一 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,不构成相互持有
解决循环引用常见的方式有以下几种;
- 【方式一】
weak-strong-dance
- 【方式二】
__block
修饰对象(需要注意的是在block内部需要置空
对象,而且block必须调用
) - 【方式三】传
递对象self
作为block的参数
,提供给block内部使用 - 【方式四】使用
NSProxy
方式一:weak-stong-dance
- 如果block内部并未嵌套block,直接使用
__weak
修饰self即可
typedef void(^CJLBlock)(void); @property(nonatomic, copy) CJLBlock cjlBlock; __weak typeof(self) weakSelf = self; self.cjlBlock = ^(void){ NSLog(@"%@",weakSelf.name); }
此时的weakSelf
和 self
指向同一片内存空间
,且使用__weak不会导致self的引用计数发生变化
,可以通过打印weakSelf和self的指针地址,以及self的引用计数来验证,如下所示
- 如果block内部嵌套block,需要同时使用
__weak
和__strong
__weak typeof(self) weakSelf = self; self.cjlBlock = ^(void){ __strong typeof(weakSelf) strongSelf = weakSelf; dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{ NSLog(@"%@",strongSelf.name); }); }; self.cjlBlock();
其中strongSelf
是一个临时变量,在cjlBlock的作用域内,即内部block执行完
就释放strongSelf
这种方式属于打破self对block的强引用
,依赖于中介者模式
,属于自动置为nil,即自动释放
方式二:__block修饰变量
这种方式同样依赖于中介者模式
,属于手动释放
,是通过__block
修饰对象,主要是因为__block修饰的对象是可以改变的
__block ViewController *vc = self; self.cjlBlock = ^(void){ dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{ NSLog(@"%@",vc.name); vc = nil;//手动释放 }); }; self.cjlBlock();
需要注意的是这里的block必须调用
,如果不调用block,vc就不会置空,那么依旧是循环引用,self和block都不会被释放
方式三:对象self作为参数
主要是将对象self作为参数,提供给block内部使用,不会有引用计数问题
typedef void(^CJLBlock)(ViewController *); @property(nonatomic, copy) CJLBlock cjlBlock; self.cjlBlock = ^(ViewController *vc){ dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{ NSLog(@"%@",vc.name); }); }; self.cjlBlock(self);
下面介绍循环引用的第4种方式,即使用NSProxy
虚拟类
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 底层分析
主要是通过clang、断点调试等方式分析Block底层
本质
- 定义
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调用执行
相当于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函数没有名称,也被称为匿名函数
block通过clang编译后的源码间的关系如下所示,以__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; }
总结:
外界变量
会生成__Block_byref_a_0
结构体- 结构体用来
保存原始变量的指针和值
- 将变量生成的
结构体对象的指针地址 传递给block
,然后在block内部就可以对外界变量进行操作了
两种拷贝对比如下
值拷贝
- 深拷贝,只是拷贝数值,且拷贝的值不可更改,指向不同的内存空间,案例中普通变量a
就是值拷贝
指针拷贝
- 浅拷贝,生成的对象指向同一片内存空间,案例中经过__block
修饰的变量a
就是指针拷贝
block底层真正类型
分析block源码所在位置
- 通过在block处打断点,分析运行时的block
加objc_retainBlock
符号断点,发现会走到_Block_copy
加_Block_copy
符号断点,运行断住,在libsystem_blocks.dylib
源码中
可以到苹果开源网站下载最新的libclosure-74源码,通过查看_Block_copy
的源码实现,发现block在底层的真正类型是Block_layout
Block真正类型
查看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 };
isa
:指向表明block类型的类
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
- 第1 位 -
BLOCK_DEALLOCATING
,释放标记,-般常用 BLOCK_NEEDS_FREE 做 位与 操作,一同传入 Flags , 告知该 block 可释放。 - 低16位 -
BLOCK_REFCOUNT_MASK
,存储引用计数的值;是一个可选用参数 - 第24位 -
BLOCK_NEEDS_FREE
,低16是否有效的标志,程序根据它来决定是否增加或是减少引用计数位的 值; - 第25位 -
BLOCK_HAS_COPY_DISPOSE
,是否拥有拷贝辅助函数(a copy helper function); - 第26位 -
BLOCK_IS_GC
,是否拥有 block 析构函数; - 第27位,标志是否有垃圾回收;//OS X
- 第28位 -
BLOCK_IS_GLOBAL
,标志是否是全局block; - 第30位 -
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 };
reserved
:保留信息,可以理解预留位置,猜测是用于存储block内部变量信息invoke
:是一个函数指针,指向block的执行代码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; }
内存变化
- 打断点运行,走到
objc_retainBlock
,block断点处读取寄存器x0,此时的block
是全局block
,即__NSGlobalBlock__
类型
- 增加外部变量a,并在block内打印
int a = 10; void (^block1)(void) = ^{ NSLog(@"CJL - %d", a); }; block1();
此时读取block断点处的x0 -- 栈block -- __NSStackBlock__
执行到符号断点objc_retainBlock
时,还是栈区block
增加_Block_copy
符号断点并断住,直接在最后的ret加断点,读取x0,发现经过_Block_copy
之后,变成了 堆block
,即__NSMallocBlock__
,主要是因为block地址
发生了改变,为堆block
调用情况
- 同样也可以通过断点来验证
- register read x0 读取x0,为堆block
- register read x9 读取x9
[站外图片上传中...(image-b14a19-1605377133592)] - register read x11 ,此时是指向一片内存空间,用于存储
_block_invoke
按住control + step into
,进入 _block_invoke
,可以得出是通过内存平移
得到的block内部实现
- 前面提到的
Block_layout
的结构体源码,从源码中可以看出,有个属性invoke
,即block的执行者,是从isa
的首地址平移16
字节取到invoke
,然后进行调用执行的
签名
- 继续操作,读取
x0
寄存器,看内存布局,通过 内存平移 3*8 就可获得Block_layout的属性descriptor
,主要是为了查看是否有Block_descriptor_2
和Block_descriptor_3
,其中3中有block的签名
register read x0
,读取寄存器x0po 0x00000002828a2160
, 打印blockx/8gx 0x00000002828a2160
,即打印block内存情况
x/8gx 0x00000001008a0010
, 查看descriptor的内存情况,其中第三个0x000000010089f395
表示签名
判断是否有Block_descriptor_2
,即flags的BLOCK_HAS_COPY_DISPOSE
(拷贝辅助函数)是否有值
p/x 1<<25
,即1左移25位,其十六进制为0x2000000
- p 0x02000000 & 0x00000000c1000002 ,即
BLOCK_HAS_COPY_DISPOSE & flags
,等于0,表示没有Block_descriptor_2
判断是否有Block_descriptor_3
p/x 1<<30
,即1左移30位p 0x40000000 & 0x00000000c1000002
,即BLOCK_HAS_SIGNATURE & flags
,有值,说明有Block_descriptor_3
p (char *)0x000000010089f395
-- 获取Block_descriptor_3
中的属性signature
签名
po [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: -------- -------- -------- -------- //encoding = (@),类型是 @? type encoding (@) '@?' //@是isObject ,?是isBlock,代表 isBlockObject flags {isObject, isBlock} modifiers {} frame {offset = 0, offset adjust = 0, size = 8, size adjust = 0} //所在偏移位置是8字节 memory {offset = 0, size = 8}
block的签名信息类似于方法的签名信息,主要是体现block的返回值,参数以及类型等信息
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
修饰的NSString
对象
__block NSString *cjl_name = [NSString stringWithFormat:@"CJL"]; void (^block1)(void) = ^{ // block_copy lg_name = @"CJL"; NSLog(@"CJL - %@",lg_name); // block 内存 }; block1();
xcrun编译结果如下,
- 编译后的
cjl_name
比普通变量多了__Block_byref_id_object_copy_131
和__Block_byref_id_object_dispose_131
__Block_byref_cjl_name_0
结构体中多了__Block_byref_id_object_copy
和__Block_byref_id_object_dispose
//********编译后的cjl_name******** __Block_byref_cjl_name_0 cjl_name = {(void*)0, (__Block_byref_cjl_name_0 *)&cjl_name, 33554432, sizeof(__Block_byref_cjl_name_0), __Block_byref_id_object_copy_131, __Block_byref_id_object_dispose_131, ((NSString * _Nonnull (*)(id, SEL, NSString * _Nonnull, ...))(void *)objc_msgSend)((id)objc_getClass("NSString"), sel_registerName("stringWithFormat:"), (NSString *)&__NSConstantStringImpl__var_folders_hr_l_56yp8j4y11491njzqx6f880000gn_T_main_9f330d_mi_0)}; //********__Block_byref_cjl_name_0结构体******** struct __Block_byref_cjl_name_0 { void *__isa; __Block_byref_cjl_name_0 *__forwarding; int __flags; int __size; void (*__Block_byref_id_object_copy)(void*, void*); void (*__Block_byref_id_object_dispose)(void*); // 5*8 = 40 NSString *cjl_name; }; //********__Block_byref_id_object_copy_131******** //block自身拷贝(_Block_copy) -- __block bref结构体拷贝(_Block_object_assign) -- _Block_object_assign中对外部变量(存储在bref)拷贝一份到内存 static void __Block_byref_id_object_copy_131(void *dst, void *src) { //dst 外部捕获的变量,即结构体 - 5*8 = 40,然后就找到了cjl_name(cjl_name在bref初始化时就赋值了) _Block_object_assign((char*)dst + 40, *(void * *) ((char*)src + 40), 131); } //********__Block_byref_id_object_dispose_131******** static void __Block_byref_id_object_dispose_131(void *src) { _Block_object_dispose(*(void * *) ((char*)src + 40), 131); }
- 通过
libclosure-74
可编译源码断点调试,关键方法的执行顺序为:_Block_copy -> _Block_byref_copy -> _Block_object_assign
,正好对应上述的三层copy
综上所述,block
是如何取到 cjl_name
的?
- 1、通过
_Block_copy
方法,将block
拷贝一份至堆区
- 2、通过
_Block_object_assign
方法正常拷贝,因为__block
修饰的外界变量在底层是Block_byref结构体
- 3、发现外部变量还存
有一个对象,从bref中取出相应对象cjl_name
,拷贝至block空间
,才能使用(相同空间才能使用,不同则不能使用)。最后通过内存平移
就得到了cjl_name,此时的cjl_name 和 外界的cjl_name是同一片内存空间(从_Block_object_assign
方法中的*dest = object;
看出)
三层copy总结
所以,综上所述,block的三层拷贝是指以下三层:
- 【第一层】通过
_Block_copy
实现对象的自身拷贝
,从栈区拷贝至堆区 - 【第二层】通过
_Block_byref_copy
方法,将对象拷贝为Block_byref
结构体类型 - 【第三层】调用
_Block_object_assign
方法,对__block
修饰的当前变量的拷贝
注:只有
__block修饰
的对象,block的copy才有三层
_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);//释放 } } }
所以,综上所述,Block的三层copy的流程如下图所示