本文主要介绍block的类型、循环引用的解决方法以及block底层的分析
block 类型
block主要有三种类型
__NSGlobalBlock__
:全局block,存储在全局区
__NSMallocBlock__
:堆区block,因为block既是函数,也是对象
__NSStackBlock__
:栈区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的block,仅仅只有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;
}