您现在的位置是:首页 >其他 >【iOS底层探索- Block原理分析-循环引用】网站首页其他
【iOS底层探索- Block原理分析-循环引用】
文章目录
前言
本来打算这周看看源码的,因为某些原因进度耽误了,另外强调了 GCD多线程,Runtime RunLoop,BLock都是面试必问必考的点,想起之前看的比较简略,就借着Block的循环引用顺带复习一下Block的整个流程。
在学习之前 对于ARC以及涉及到的属性关键字都要有了解还是要有了解的基础,尤其是weak。
准备工作
weak的实现原理
iOS ARC实现
iOS Block基础再探究
1. Block的分类
简单复习
block的分类主要分为以下三种
__NSGlobalBlock__
全局block__NSStackBlock__
栈区block__NSMallocBlock__
堆区block
他们的分类原因和block的定义有关系 block是一个带有自动变量值的匿名函数。
- 什么是带有自动变量?
- 带有自动变量值”在Block中表现为“截取自动变量值
例如如下blk即截取了外部变量。
- (void)mallocBlock {
NSString* str = @"mallocBlk";
void (^glbBlk)(void) = ^{
NSLog(@"%@", str);
};
NSLog(@"%@", glbBlk);
}
Block分类简单总结如下
- A、没有引用外部变量 — block存放在全局区
- B、引用了外部变量----显式声明为
weak
类型的block则存放在栈
区,反之则是存在在堆区的,也就是说block是strong类型的。
2. Block的内存分析
捕获外部变量引用计数的变化
ARC环境,案例中定义了两个block,跟踪objc的引用计数变化。
#pragma mark- Blk内存分析
- (void)blkMemory {
NSObject *objc = [NSObject new];
NSLog(@"%ld",CFGetRetainCount((__bridge CFTypeRef)(objc))); // 1
void(^strongBlock)(void) = ^{
NSLog(@"---%ld",CFGetRetainCount((__bridge CFTypeRef)(objc)));
};
strongBlock();
void(^__weak weakBlock)(void) = ^{
NSLog(@"---%ld",CFGetRetainCount((__bridge CFTypeRef)(objc)));
};
weakBlock();
void(^mallocBlock)(void) = [weakBlock copy];
mallocBlock();
}
运行结果如下:
- 第一个打印为1就是简单创建引用计数+1
- 第二个为3:
strongBlock
是一个堆区的block
,这里捕获了objc这个外部变量会进行加一,这里会把栈区的objc拷贝到堆区又进行了加一,所以打印结果为 3。 - 打印 4是因为这里
weakBlock
是栈block,没有进行拷贝只是捕获+1,所以为4。 - 最后打印5是因为
[weakBlock copy]
进行了拷贝操作,再赋值给mallocBlock
也是+1操作,所以打印结果为 5。
如何区分堆栈Blk 这个需要了解blk的实现过程,在之前已作学习。
堆栈释放的差异
差异1
#pragma mark -堆栈释放差异
- (void)blockDemo1 {
int a = 777;
void(^__weak weakBlock)(void) = nil;
{
void(^__weak strongBlock)(void) = ^{
NSLog(@"%d", a);
};
weakBlock = strongBlock;
NSLog(@"1 - %@ - %@", weakBlock,strongBlock);
}
weakBlock();
}
该段代码的运行并无任何问题:
- 声明了一个
weakBlock
,该block为NSStackBlock;
- 在代码块中,定义了
strongBlock
,其也为NSStackBlock
; - 对weakBlock进行了赋值,此时两个
block
均指向同一个NSStackBlock
; - 因为这两个栈
block
的生命周期到blockDemo
方法运行结束,并不会被提前释放;(特地查了它的生命周期当创建 NSStackBlock 的函数返回时,栈上分配的内存将被释放,NSStackBlock 对象也将被销毁。) - 所以调用
weakBlock
()可以正常运行,并能够输出a的值。 差异2
对上面的案例strongBlock
修改成了NSMallocBlock
,取消了__weak修饰符。
- (void)blockDemo2 {
int a = 0;
void(^__weak weakBlock)(void) = nil;
{
void(^strongBlock)(void) = ^{
NSLog(@"---%d", a);
};
weakBlock = strongBlock;
NSLog(@"1 - %@ - %@", weakBlock,strongBlock);
}
weakBlock();
}
案例崩溃 ,lldb调试发现在代码块{}结束之前 调用p weakBlock都是有地址的,但是出了代码块{}发现就没有了。
结合lldb调试结果分析:
strongBlock
为NSMallocBlock
,其生命周期范围在代码块{}内,也就是出了代码块其就会被释放;- 在代码块中对
weakBlock
进行了赋值,指针拷贝,指向了对应的NSMallocBlock
,但是并没有强引用指向这个block
(__weak修饰符不会带有强引用,创建暨被释放); -
- 这里的指针拷贝可以从下图看到,二者指向相同的一片内存地址,
- 这里的指针拷贝可以从下图看到,二者指向相同的一片内存地址,
- 代码块执行完毕后,该
NSMallocBlock
就会被释放,此时weakBlock
指向的对象已经被释放,形成野指针,所以无法正常执行。
最后把两个block的__weak
都去掉,则能够正常运行并打印结果
- (void)blockDemo3 {
int a = 0;
void(^weakBlock)(void) = nil;
{
void(^strongBlock)(void) = ^{
NSLog(@"---%d", a);
};
weakBlock = strongBlock;
NSLog(@"1 - %@ - %@", weakBlock, strongBlock);
}
weakBlock();
}
上面的例子崩溃了,是因为堆区的 block
出了作用域,被释放了。
此时的赋值,weakBlock
对堆中的block
进行了强引用,代码块运行结束后不会释放掉,也就不存在野指针的问题了。
总结
block
分为全局block
、堆block
、栈block
block
可以捕获外部变量- 堆区的
block
捕获外部变量会拷贝到堆区引计数+1 block
在使用的时候,堆block
注意作用域的问题,弱引用指针赋值,出了作用域就释放了,可以通过强引用解决
3. Block的循环引用
- 参考自:iOS_Block循环引用
3.1 什么是循环引用?
- 正常情况对于对象的持有和释放是如下逻辑
- 循环引用就是对面持有导致对象不能及时的正常释放,容易造成内存泄漏。
案例引入
如下代码可能造成循环引用
#import "ViewController.h"
typedef void (^TBlock)(void);
@interface ViewController ()
@property (nonatomic, strong) TBlock block;
@property (nonatomic, strong) NSString *name;
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
// Do any additional setup after loading the view.
// 循环引用
self.name = @"ViewController";
self.block = ^() {
NSLog(@"%@", self.name);
};
self.block();
}
self持有了block,block持有了self,导致循环引用。 编译器也会提示:Capturing 'self' strongly in this block is likely to lead to a retain cycle
- 如果我们取消某一方的持有即可取消循环引用,恢复到正常的逻辑里面去。
// 不会引起循环引用
void(^blk1)(void);
blk1 = ^() {
NSLog(@"%@", self.name);
};
blk1();
这个案例就没有出现循环引用是因为当前self
,也就是ViewController
并没有对block
进行强持有,block
的生命周期只在viewDidLoad
方法内,viewDidLoad
方法执行完,block就会释放。
循环引用解决方法
在开始也提到过weak是基础,weak也是最为熟知的解决循环引用的方法,__weak不会进行引用计数的操作
weak
的使用
__weak typeof(self) weakSelf = self;
typeof(self)
:typeof
是一个运算符,用于获取表达式的类型。在这种情况下,表达式是 self,它代表当前对象的引用
避免循环引用方法:
__weak typeof(self) weakSelf = self;
self.block = ^(){
NSLog(@"%@", weakSelf.name);
} ;
self.block();
此时self持有block
,block
弱引用self
,弱引用会自动变为nil
,强持有中断,所以不会引起循环引用。
- 反面案例
之前在学习GCD的时候学到过将其他线程的麻烦的方法执行完之后再次回到主线程,但是万一在其他线程执行的过程里面ViewController被销毁的话是什么情况,由于ARC不能显式调用dealloc 我们模拟一下延时。
。。。。。。。
__weak typeof(self) weakSelf = self;
self.block = ^(){
// 延迟2秒钟
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)( 2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
NSLog(@"%@", weakSelf.name);
});
};
self.block();
[self fakeDealloc];
}
- (void)fakeDealloc {
NSLog(@"调用了dealloc 模拟ViewController模拟销毁");
// 模拟viewController被销毁
self.name = nil;
}
dealloc方法调用了,VC 已经销毁了,block 也就释放了,内部的延时函数里面的打印还来不及打印,所以 name为 null.
虽然没有引起循环引用,但是block
中延迟2秒钟执行任务,如果此时ViewController
被销毁,此时block
已经无法获取ViewController
的属性name,很不合理。
1. 强弱共舞
为了解决上面的问题 由此引出了强弱共舞
则一切就会正常打印。
原理:因为__weak
会自动置为nil,所以这里使用__strong(strong-weak-dance)
暂时延长 self的生命周期,使得可以正常打印。
为什么强弱共舞能够避免循环引用,不是也调用了self? 因为这里strongSelf
是一个临时的变量,出了作用域也跟着释放了,所以不会出现循环引用?
简单分析:
- 在完成block中的操作之后,才调用了
dealloc
方法。添加strongWeak
之后,持有关系为:self
->block
->strongWeak
->weakSelf
->self
。 weakSelf
被强引用了就不会自动释放,因为strongWeak
只是一个临时变量,它的声明周期只在block
内部,block
执行完毕后,strongWeak
就会释放,而弱引用weakSelf
也会自动释放
2. 手动中断循环引用
self.name = @"ViewController";
__block ViewController * VC = self;
self.block = ^(){
__strong __typeof(weakSelf)strongWeak = weakSelf;
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
NSLog(@"%@", ctrl.name);
VC = nil;
});
};
self.block();
这里使用一个临时的VC变量之后,持有关系为: self
--> block
--> VC
–> self
,VC
在block
使用完成后就被置为nil
,block
不构成对self
的持有关系了,因此这里就不构成循环引用问题。
用__block
是因为需要对外部变量,进行赋值操作
3. 参数形式解决循环引用(block传参)
- (void)parameterMethod {
self.name = @"ViewController";
// blk传参解决循环引用
// 循环引用
self.block = ^(ViewController * ctrl){
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
NSLog(@"%@", ctrl.name);
});
};
self.block(self);
将self
作为参数参入block
中,进行指针拷贝,并没有对self
进行持有。
Block循环引用案例
- 静态变量持有
// staticSelf_定义:
static ViewController *staticSelf_;
- (void)blockWeak_static {
__weak typeof(self) weakSelf = self;
staticSelf_ = weakSelf;
}
weakSelf
虽然是弱引用,但是staticSelf_
静态变量,并对weakSelf
进行了持有,staticSelf_
释放不掉,所以weakSelf
也释放不掉!导致循环引用!
__strong
持有问题
- (void)block_weak_strong {
__weak typeof(self) weakSelf = self;
self.doWork = ^{
__strong typeof(self) strongSelf = weakSelf;
NSLog(@"B objc -----retainCount : %lu", CFGetRetainCount(((__bridge CFTypeRef)strongSelf)));
weakSelf.doStudent = ^{
NSLog(@"%@", strongSelf);
NSLog(@"B objc -----retainCount : %lu", CFGetRetainCount(((__bridge CFTypeRef)strongSelf)));
};
weakSelf.doStudent();
};
self.doWork();
}
- 在
doWork
内部,__strong typeof(self) strongSelf = weakSelf;
- 用强引用持有了
weakSelf
,和前的情况类似,strongSelf
的生命周期也就在doWork
方法内; - 这里需要注意的是,doStudent这个内部block调用了外部变量,所以他会从栈
block copy
到堆中,从而导致strongSelf的引用计数增加,无法释放掉,进而导致循环引用!
总结
通过今天对Block
的再学习,也算是复习了block
的小知识点,同时学习了几种循环引用出现的场景和如何解决循环引用的方法,记录并复习。