RxSwift-KVO\内存管理

函数响应编程&RxSwift核心逻辑 上
函数响应编程&RxSwift核心逻辑 下
待续...正在努力编写
RxSwift-中介者模式
RxSwift-KVO\内存管理

一、Rx - KVO

var disposeBag = DisposeBag()

observeWeakly

// 序列
        self.person.rx.observeWeakly(String.self, "name")
            .subscribe(onNext: { (change) in
                print("observeWeakly订阅到了KVO:\(String(describing: change))")
            })
            .disposed(by: disposeBag)

observe

        self.person.rx.observe(String.self, "name").subscribe(onNext: { (change) in
                print("observe订阅到了KVO:\(String(describing: change))")
            }).disposed(by: disposeBag)

// KVO一定要加入 .disposed(by: disposeBag) --- （observeWeakly多使用）（少用observe）
1、持用的没有释放，排除VC走了
2、强持用没有释放
3、循环引用 （observe）-- 跟随.disposed(by: disposeBag)释放

observe

        1、     rx.deallocating
        2、     rx.deallocated
func deallocDemo(){
        // proxy ： class
        // self.registerMessageInterceptor(deallocSelector)  -> proxy
        _ = rx.deallocating.subscribe(onNext: { () in
            print("准备走了")
        })
        
        //中间(deinit) -- deinit - dealloc - 监听 dealloc
        //怎么观察dealloc --> 交换方法 - 什么时候调用 dealloc -- 来我自己的实现的时候 deallocating - dealloc - deallocated
        // xg  dealloc -> new IMP    deallocating()    内部实现
        //@selector(dealloc) 不支持ARC --> 通过NSSelectorFromString("dealloc")
        
        _ = rx.deallocated.subscribe(onNext: { () in
            print("已经走了")
        })
    }
    
    deinit {
        print("\(self)走了 ")
    }

// 源码 - 宏- 里面OC
SWIZZLE_INFRASTRUCTURE_METHOD(
    void,
    swizzleDeallocating,
    deallocSelector,
    DEALLOCATING_BODY
)

RX-SwiftKVO的底层封装的是OC的KVO，Swift的底层封装的也是OC的KVO
【处理 - 过程慢长会有其他的影响 - OC runtime机制 (不支持提前编译-所以用到了宏)】
问题一：
self.person.rx.observerWEAKL. -> KVOObservable —/- > person — 循环引用 unowned weak
问题二：unowned =（unsafaun_unretian）直接奔溃 ---- weak会把对象为nil

unowned

【序列 - nil 进入下一步 定位不到问题 - 订阅

• unowned(在框架中常见)
• 内存管理 - 检查对象
• 1: 性能强
• 2: 安全性 】

二、RX-内存管理

循环引用

// self -> myClosure -> {}  -> self  -释放不掉 --【构成了循环引用圈】

//解决循环引用
        myClosure = {[weak self] in
            // weak - strong - dance
            guard let self = self else { return } 
            DispatchQueue.global().asyncAfter(deadline: .now()+2, execute: {
                self.name = "Cooci"
                print(self.name)
            })
        }
        self.myClosure!()

// 循环引用计数-->>是否发生循环引用
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

终端执行 pod update
-------------------------
    override func viewWillAppear(_ animated: Bool) {
        super.viewWillAppear(animated)
        print("*****首页控制器出现了show:RxSwift的引用计数: \(RxSwift.Resources.total)")
        print("****************************************")
    }

    override func viewDidDisappear(_ animated: Bool) {
        super.viewDidDisappear(animated)
        print("*****首页控制器消失了dismiss:RxSwift的引用计数: \(RxSwift.Resources.total)")
        print("****************************************")
    }

-----------------
self.accountTF.rx.text.orEmpty
            .debug() //调试
            .subscribe(onNext: { [weak self](text) in
                self?.title = text
            })
            .disposed(by: disposeBag)

======调试============
RxSwift 计数必要性: 对代码宏观调控
.debug()
deinit ： 闭包 - RxSwift
==================

注意-事例

//注意：self 只是传参数并没有发生循环引用
self.accountTF.rx.text.orEmpty
            .bind(to: self.rx.title)
            .disposed(by: disposeBag)

// 持有序列 - create
        // self -> observable -> create{} -> self
        self.observable = Observable.create { (anyObserver) -> Disposable in
            anyObserver.onNext("Hello word")
            return Disposables.create()
        }

// 持有序列 - 订阅
        // self -> observable -> subscribe onNext -> self
        self.observable?.subscribe(onNext: {
            print(self)
            print("订阅到1:\($0) --")
            })
            .disposed(by: self.disposeBag)

// 持有 《订阅本身就是循环引用》
// create -> self
        // create -> self -> anyObserver -> observer -> AnonymousObservableSink.on
        // -> AnonymousObserver.on -> onNext?(value) -> subscribe{} -> self
        
        // self -> observer -> AnyObserver 
        // subscribe -> AnonymousObserver
        
        Observable.create { (anyObserver) -> Disposable in
            self.observer = anyObserver
            anyObserver.onNext("Hello word")
            return Disposables.create()
            }
            .subscribe(onNext: { (item) in
                print(self)
                print("订阅到:\(item)")
            })
            .disposed(by: self.disposeBag)

传值计数问题的时候解决方法
1：要销毁的vc.bag
2：序列的能力伴随着我vc生命周期 ： (vc.rx.deallocated)
3： vc 持有 - 释放不掉 self -> vc -订阅 -> self
4: 没有响应了 —

UITableViewCell 解决复用情况(缓存池中)

1: 出现复用的情况下再进行销毁
    override func prepareForReuse() {
        super.prepareForReuse()
        disposeBag = DisposeBag()
    }
2: 进行扩展 解决（rx.deallocating）

总结

内存管理