@[TOC](RxSwift学习之十七 （内存管理，循环引用问题）)
1. Rxswift内存管理简介
- Rxswift内存管理demo 下载点击这里：kylRxMemoryManagerDemo
2. Rxswift内存管理机制
- Rxswift 实现了自己管理资源数目的机制：
//初始化时，将引用加1
init(){
_ = Resources.incrementTotal()
}
//销毁时，引用计数减1
deinit{
_ = Resources.decrementTotal()
}
- 可以通过
RxSwift.Resources.total来打印当前的应用数目。不过要使用这个需要在pod文件开启一些设置：
Podfile文件的最后面加入下面代码后，重新
pod install
post_install do |installer|
installer.pods_project.targets.each do |target|
if target.name == 'RxSwift'
target.build_configurations.each do |config|
if config.name == 'Debug'
config.build_settings['OTHER_SWIFT_FLAGS'] ||= ['-D', 'TRACE_RESOURCES']
end
end
end
end
end
3. Rxswift循环引用问题
3.1 Rxswift循环引用问题实例
3.1.1 Swift中循环引用实例
- 如下面swift代码会导致循环引用：
self->myClosure->self 引用链发现必然会造成循环引用.
var myClosure: (() -> Void)? //vc属性
myClosure = {
print("\(self.name)")
}
myClosure?()
- 解决方法
使用weak打破循环引用
//使用 weak
myClosure = { [weak self] in
print("\(self?.name)")
}
- 使用
unowned来打破循环引用,
//使用 unowned
myClosure = { [unowned self] in
print("\(self.name)")
}
- 但是unowned是不安全的，如果对象被释放掉了，会导致野指针问题
例如：
myClosure = { [unowned self] in
DispatchQueue.global().asyncAfter(deadline: .now()+2, execute: {
print("\(self.name)")
})
}
延迟执行后，会出行崩溃，打印：
Fatal error: Attempted to read an unowned reference but the object was already deallocatedunowned类似于oc 的_unsafe_unretain 是不安全的方式，rxswift中底层使用的是这种方式，为什么rxswift要使用这种方式去打破循环引用，而不是用weak呢？
主要基于以下几点：
- 了解过weakly实现原理的童鞋应该知道，weakly实现自动将对象设置为nil,是需要做在底层很多事情的，这样避免不了要消耗牺牲一些性能。
- 作为底层框架，如果明知道无法避免内存问题，就不如让内存问题暴露的更彻底一点，如果自动规避掉了，反而会引起一些隐藏的问题。
- Rxswift自己提供了一套内存计数机制，这样可以很方便的区分是框架引起的内存问题还是其他引起的。
3.1.2 Rxswift中的循环引用问题解决
- 实例 3.1.2.1
self.textFiled.rx.text.orEmpty
.subscribe(onNext: { (text) in
self.title = text
})
.disposed(by: disposeBag)
循环引用链：
self -> textFiled -> subscribe -> self
解决方法：
self.textFiled.rx.text.orEmpty
.subscribe(onNext: { [weak self] (text) in
self?.title = text
})
.disposed(by: disposeBag)
- 实例3.1.2.2
self.observable = Observable<Any>.create({ (observer) -> Disposable in
observer.onNext("Hello")
return Disposables.create()
})
self.observable?.subscribe(onNext: { (value) in
print(self.name)
}).disposed(by: disposeBag)
循环引用链：
self 持有 observable, 在 subscribe 订阅时会创建 observer 持有 onNext 闭包。然后 observer 会被传递给 sink，sink 又会将自身封装为 AnyObserver 回传给 create 闭包，作为 observer 参数。
self -> observable -> subscribe -> observer -> onNext{} -> self通过持有链分析，也能很清晰的发现确实是循环引用的。
解决方法：
self.observable?.subscribe(onNext: { [weak self] (value) in
print(self?.name)
}).disposed(by: disposeBag)
- 实例3.1.2.3
Observable<Any>.create { (observer) -> Disposable in
self.observer = observer
observer.onNext("Hello")
return Disposables.create()
}
.subscribe(onNext: { (value) in
print(self.name)
})
.disposed(by: disposeBag)
循环引用链：
self -> observer -> onNext{} -> self
解决方法：
Observable<Any>.create { (observer) -> Disposable in
self.observer = observer
observer.onNext("Hello")
return Disposables.create()
}
.subscribe(onNext: { [weak self](value) in
print(self?.name)
})
.disposed(by: disposeBag)
- 实例3.1.2.4: 不同VC之间响应时 内存管理方案
场景: vc1 和 vc2 两个 vc . 1跳转进2 . 1订阅2 , 2发送事件.
vc1:
// 点击屏幕 push到控制器2
override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
let vc = NextViewController()
// 订阅控制器2中的可观察序列
vc.publicOB.subscribe(onNext: { (value) in
print("\(value)")
})
.disposed(by: disposeBag)
self.navigationController?.pushViewController(vc, animated: true)
}
vc2:
// 创建外部可订阅的序列
fileprivate var mySubject = PublishSubject<Any>()
var publicOB : Observable<Any>{
return mySubject.asObservable()
}
// 点击屏幕 发出信号
override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
mySubject.onNext("RxSwift")
}
deinit{
print("来了")
}
运行 , 跳转过去,点击屏幕,响应, 返回 vc2: 来了. 好像没问题?
循环引用链：
使用上述我们讲的 RxSwift 的引用计数来检查下, viewDidAppear 等生命周期函数中加入打印当前引用计数, 发现 跳转一次2 就会叠加一次, 意味着我们的订阅并没有释放.
解决方法：
方法一：
bag 在控制其中只是一个属性的角色
这个要理解, 之前写法中我们将订阅释放写入了外面的 vc 的 bag 中, 而 vc1 的 bag 并没有释放, 因此我们改为写入 vc2 的 bag 中. 当vc2 释放, bag 被销毁, bag中的序列订阅也同样被销毁.
vc.publicOB.subscribe(onNext: { (value) in
print("\(value)")
})
.disposed(by: vc.disposeBag)
方法二：
_ = vc.publicOB.takeUntil(vc.rx.deallocated).subscribe(onNext: { (value) in
print("\(value)")
})
使用 takeUntil , 意味着该序列订阅保存到 什么什么时候 会销毁.
我们传递 vc.rx.deallocated , 其实跟第一种方法 原理是相同的.
方法三：
当 vc2 作为一个 vc1 的一个属性时, 也就意味着 vc2 并不会销毁, 该如何处理内存问题呢
// vc1
override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
print("RxSwift计数: \(RxSwift.Resources.total)")
// 控制器1 持有 控制器2
self.vc.publicOB.subscribe(onNext: { (value) in
print("\(value)")
})
.disposed(by: disposeBag)
self.navigationController?.pushViewController(vc, animated: true)
}
// vc2
override func viewWillDisappear(_ animated: Bool) {
super.viewWillDisappear(animated)
// 页面即将消失时发送 `completed` 事件
mySubject.onCompleted()
}
解决方式就是在 vc2 的 viewWillDisappear 时, 调用 onCompleted ,查看源码会发现当发送 .complete 事件时, rx 内部会自动调用 disposable.dispose(). 其实本来就该如此, 序列订阅事件完毕 或者有错时 会销毁, 不再响应.
那么这样也会带来一个问题:
当再进入 vc2 , 再发送响应, 会不能响应, 因为 已经被销毁了. 这时就应该在
fileprivate var mySubject = PublishSubject<Any>()
var publicOB : Observable<Any>{
mySubject = PublishSubject<Any>()
return mySubject.asObservable()
}
也就是说 vc1 每次订阅时都产生一个新的 subject . 这样就在不会产生循环引用的前提下, 持续响应 vc2 的事件了.
