RxSwift : Disposable 예제 모음

DisposableSample.swift

   func disposablesSample() {
        //noOp
        Observable<String>.create { (observer) -> Disposable in
            observer.on(.next("observable start"))
            observer.on(.next("observable end"))
            return Disposables.create()
        }
        .subscribe().disposed(by: disposeBag)
        //op
        let timer = Observable<Int>.create { observer in
            let timer = DispatchSource.makeTimerSource(queue: DispatchQueue.global())
            timer.schedule(deadline: DispatchTime.now() + 1, repeating: 1)
            let cancel = Disposables.create {
                print("Disposed")
                timer.cancel()
            }
            var next = 0
            timer.setEventHandler {
                if cancel.isDisposed {
                    return
                }
                observer.on(.next(next))
                next += 1
            }
            timer.resume()
            return cancel
        }
        timer.take(3).subscribe(onNext: {
            print($0)
        }).disposed(by: disposeBag)
    }
    
    func booleanDisposableSample() {
        let task = Observable<String>.create { observer in
            let cancelDisposable  =  BooleanDisposable()
            let queue = OperationQueue()
            func addOperation(delay: UInt32) {
                queue.addOperation {
                    sleep(delay)
                    print(cancelDisposable.isDisposed)
                    if cancelDisposable.isDisposed {
                        queue.cancelAllOperations()
                    }
                    observer.on(.next("Do my job!!"))
                }
            }
            addOperation(delay: 1)
            addOperation(delay: 2)
            addOperation(delay: 3)
            addOperation(delay: 4)
            addOperation(delay: 5)
            return cancelDisposable
        }
        task.take(3).subscribe(onNext: {
            print($0)
        }).disposed(by: disposeBag)
    }
    
    func compositDisposableSample() {
        let rabbit = Observable<Int>.interval(1, scheduler: MainScheduler.instance).subscribe(onNext: {
            print("rabbit: \($0)")
        })
        let fox = Observable<Int>.interval(2, scheduler: MainScheduler.instance).subscribe(onNext: {
            print("fox: \($0)")
        })
        let snake = Observable<Int>.interval(4, scheduler: MainScheduler.instance).subscribe(onNext: {
            print("snake: \($0)")
        })
        let compositeDisposable = CompositeDisposable.init(disposables: [rabbit])
        let key = compositeDisposable.insert(fox)
        let _ = compositeDisposable.insert(snake)
        DispatchQueue.main.asyncAfter(deadline: DispatchTime.now()+3) {
            print("dispose fox")
            if let key = key {
                compositeDisposable.remove(for: key)
            }
        }
        DispatchQueue.main.asyncAfter(deadline: DispatchTime.now()+6) {
            print("dispose")
            compositeDisposable.dispose()
        }
    }
    
    func refCountDisposablSample() {
        let timer = Observable<Int>.interval(1, scheduler: MainScheduler.instance).subscribe(onNext: {
            print("timer: \($0)")
        })
        let refCountDisposable = RefCountDisposable(disposable: timer)
        let retainDisposable = refCountDisposable.retain()
        DispatchQueue.main.asyncAfter(deadline: DispatchTime.now()+3) {
            print("dispose")
            refCountDisposable.dispose()
        }
        DispatchQueue.main.asyncAfter(deadline: DispatchTime.now()+6) {
            print("dispose")
            retainDisposable.dispose()
        }
    }
    
    func scheduleDisposableSample() {
        let task = Observable<String>.create { observer in
            let disposable = Disposables.create {
                print("dispose: \(Thread.current)")
            }
            let queue = OperationQueue()
            func addOperation(delay: UInt32) {
                queue.addOperation {
                    sleep(delay)
                    if disposable.isDisposed {
                        queue.cancelAllOperations()
                    }
                    observer.on(.next("Do my job!!"))
                }
            }
            addOperation(delay: 1)
            addOperation(delay: 2)
            return disposable
        }.subscribe(onNext: {
            print($0)
        })
        let scheduleDisposable = ScheduledDisposable(scheduler: ConcurrentDispatchQueueScheduler(qos: .background), disposable: task)
//        let scheduleDisposable = ScheduledDisposable(scheduler: MainScheduler.instance, disposable: task)
        
        DispatchQueue.main.asyncAfter(deadline: DispatchTime.now()+3) {
            print("dispose")
            scheduleDisposable.dispose()
        }
    }
    
    func serialDisposableSample() {
        let timer = Observable<Int>.interval(1, scheduler: MainScheduler.instance).subscribe(onNext: {
            print("timer: \($0)")
        })
        let serialDisposable = SerialDisposable()
        serialDisposable.disposable = timer
        DispatchQueue.main.asyncAfter(deadline: DispatchTime.now()+3) {
            let timer2 = Observable<Int>.interval(1, scheduler: MainScheduler.instance).subscribe(onNext: {
                print("timer2: \($0)")
            })
            serialDisposable.disposable = timer2
        }
    }
    
    func singleAssignmentDisposableSample() {
        let timer = Observable<Int>.interval(1, scheduler: MainScheduler.instance).subscribe(onNext: {
            print("timer: \($0)")
        })
        let singleAssignmentDisposable = SingleAssignmentDisposable()
        singleAssignmentDisposable.setDisposable(timer)
        DispatchQueue.main.asyncAfter(deadline: DispatchTime.now()+3) {
            let timer2 = Observable<Int>.interval(1, scheduler: MainScheduler.instance).subscribe(onNext: {
                print("timer2: \($0)")
            })
            singleAssignmentDisposable.setDisposable(timer2)
        }
    }