阅读 196
RxSwift学习:内存管理、循环引用问题

RxSwift学习:内存管理、循环引用问题

1. RxSwift内存管理简介

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 deallocated

  • unowned类似于oc 的_unsafe_unretain 是不安全的方式,rxswift中底层使用的是这种方式,为什么rxswift要使用这种方式去打破循环引用,而不是用weak呢?

主要基于以下几点:

  1. 了解过weakly实现原理的童鞋应该知道,weakly实现自动将对象设置为nil,是需要做在底层很多事情的,这样避免不了要消耗牺牲一些性能。
  2. 作为底层框架,如果明知道无法避免内存问题,就不如让内存问题暴露的更彻底一点,如果自动规避掉了,反而会引起一些隐藏的问题。
  3. 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 的事件了.

收录自|地址

资料下载:下载地址

文章分类
iOS
文章标签