@[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 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 的事件了.