所有文章

RxSwift 探索之旅 · 09

Schedulers:subscribeOn 與 observeOn

Scheduler 與多執行緒,以及 subscribeOn、observeOn 分別決定哪一段在哪個執行緒執行。

本篇目錄 · 7 個章節

Scheduler

如果要將多執行緒的概念放到Observable當中,那就會用到Scheduler,如果有用過GCD的話,Scheduler的實作方式就是基於GCD然後再封裝,可以在各種operator在串接時,切換到不同的Scheduler,Scheduler可以較常使用有以下四種:

MainScheduler 封裝GCD的MainQueue,任務會執行在MainThread,通常用於更新UI的程式

SerialDispatchQueueScheduler 封装GCD的SerialQueue,任務會依序執行,可用於將任務放置在背景依序執行,在使用observeOn時,Rx對此進行多項優化。

ConcurrentDispatchQueueScheduler 封裝GCD的ConcurrentQueue,任務會同時被執行,可用於任務需要較長時間執行的狀況。

OperationQueueScheduler 封裝NSOperationQueue,跟ConcurrentDispatchQueueScheduler類似,但可以控制最大Concurrent的任務數量。

值得注意的是,Scheduler 不等於Thread,它們不是一對一的關係,除了MainScheduler是在Main Thread被處理之外,你不會知道你的Scheduler在哪個Thread被處理。

SubscribeOn

前面講過,Observable 只有在被訂閱的時候,才會開始發送元素給他的訂閱者,無論他串了多少個 map, filter, flatMap … 等多個 operator 也一樣,那他發出元素的那個起點,要在哪個 Scheduler 執行,這個就是 subscribeOn。

ObserveOn

因為 Functional programming 的特性就是可以串很多個 operator,在串的過程中,我也可以決定要在哪個 Scheduler 執行,這時候就用 observeOn。

用範例來解釋

我們先寫一個 func,它能告訴我現在運行的 Thread 是哪個。

func getThreadName() -> String {
if Thread.current.isMainThread {
return "Main Thread"
} else if let name = Thread.current.name {
if name == "" {"
return "Anonymous Thread"
}
return name
} else {
return "Unknown Thread"
}
}

接著,我們建立一個 Observable,並且經過一次 map operator,接著訂閱它,我們看看在一般的狀況下,執行結果會是如何

Observable<Int>.create { observer in
print("subscription code: \(self.getThreadName())")
observer.onNext(1)
observer.onCompleted()
return Disposables.create()
}
.map { number -> Int in
print("1: \(self.getThreadName()) / \(number)")
return number * 2
}
.subscribe(onNext: { number in
print("2: \(self.getThreadName()) / \(number)")
})
.disposed(by: disposeBag)

執行結果

subscription code: Main Thread
1: Main Thread / 1
2: Main Thread / 2

使用 subscribeOn

Observable<Int>.create { observer in
print("subscription code: \(self.getThreadName())")
observer.onNext(1)
observer.onCompleted()
return Disposables.create()
}
.subscribeOn(ConcurrentDispatchQueueScheduler.init(qos: .background))
.map { number -> Int in
print("1: \(self.getThreadName()) / \(number)")
return number * 2
}
.subscribe(onNext: { number in
print("2: \(self.getThreadName()) / \(number)")
})
.disposed(by: disposeBag)

執行結果

subscription code: Anonymous Thread
1: Anonymous Thread / 1
2: Anonymous Thread / 2

subscribeOn 個人覺得有幾個重點

  1. 它受用範圍就在 create Observable 的部分,也就是在生產元素的部分
  2. subscribeOn() 不限擺放順序,你也可以放在 map 之後,或是 observeOn 之後,但通常會放在 create Observable 之後,畢竟這比較直觀
  3. subscribeOn() 可以寫多次,但只有第一次設定有用,因為在訂閱的那一刻已經決定好了

使用 observeOn

Observable<Int>.create { observer in
print("subscription code: \(self.getThreadName())")
observer.onNext(1)
observer.onCompleted()
return Disposables.create()
}
.subscribeOn(ConcurrentDispatchQueueScheduler.init(qos: .background))
.observeOn(MainScheduler.instance)
.map { number -> Int in
print("1: \(self.getThreadName()) / \(number)")
return number * 2
}
.observeOn(SerialDispatchQueueScheduler.init(qos: .background))
.subscribe(onNext: { number in
print("2: \(self.getThreadName()) / \(number)")
})
.disposed(by: disposeBag)

observeOn 個人覺得有一個重點

  1. 它受用為執行 observeOn() 之後的範圍,如果之後再次遇到 observeOn() ,也就是切換到下一個所設置的 Scheduler,所以可以切來切去,因為每一個 operator 之後的 Observable 都是新的,你要在哪個 Scheduler 處理就在哪處理的概念

如果沒指定 subscribeOn 或 observeOn 的話 …?

如果沒指定 subscribeOn,就看當前 Observable create 的產生元素的 Scheduler 在哪就在哪

Observable<Int>.create { observer in
print("subscription code: \(self.getThreadName())")
observer.onNext(1)
observer.onCompleted()
return Disposables.create()
}
.observeOn(ConcurrentDispatchQueueScheduler.init(qos: .background))
.map { number -> Int in
print("1: \(self.getThreadName()) / \(number)")
return number * 2
}
.observeOn(MainScheduler.instance)
.subscribe(onNext: { number in
print("2: \(self.getThreadName()) / \(number)")
})
.disposed(by: disposeBag)

執行結果

subscription code: Main Thread
1: Anonymous Thread / 1
2: Main Thread / 2

如果沒指定observeOn,就看當前subscribeOn的Scheduler在哪就在哪,也就是說,只要控制subscribeOn的 Scheduler,後續沒特別切換Scheduler,後續的stream都會是在同一個Scheduler處理。