就问此时此刻还有谁？45度仰望天空，该死！我这无处安放的魅力！
- RxSwift（1）—— 初探
- RxSwift（2）—— 核心逻辑源码分析
- RxSwift（3）—— Observable序列的创建方式
- RxSwift（4）—— 高阶函数（上）
- RxSwift（5）—— 高阶函数（下）
- RxSwift（6）—— scheduler源码解析（上）
- RxSwift（7）—— scheduler源码解析（下）
- RxSwift（8）—— KVO底层探索（上）
- RxSwift（9）—— KVO底层探索（下）
- RxSwift（10）—— 场景序列总结
- RxSwift（11）—— 销毁者-dispose源码解析
- RxSwift（12）—— Subject即攻也守
- RxSwift（13）—— 爬过的坑
- RxSwift（14）—— MVVM双向绑定
RxSwift目录直通车--- 和谐学习，不急不躁！
RxSwift探索了几天，今天晚上会迎来同学们会疑虑比较多，平时比较好奇的模块 -RxSwift调度者 - scheduler. 这个模块相对前面的流程比较复杂，这一篇博客希望每一个同学一定耐着性子跟着我的思维锊清楚。后面总结你会发现原来也就那么一回事！在RxSwift的世界如果看得简单一点,那么只有四个东西：
- 可观察序列 -
Observable - 观察者 -
Observer - 调度者 -
Scheduler - 销毁者 -
Dispose
下面开始具体分析这个非常有意思的东西 调度者 - Scheduler
调度者的作用 - 封装了一套多线程方案
大家可以想象，多线程对我们 iOS开发 的性能影响是非常大，而对于 RxSwift 这么一套爱装逼的生态，不对线程下手，我觉得不符合它的风格！果然 RxSwift 的大神主要针对 GCD 进行了一套 scheduler 封装。
-
CurrentThreadScheduler：表示当前线程Scheduler。（默认使用这个）
public class CurrentThreadScheduler : ImmediateSchedulerType {
typealias ScheduleQueue = RxMutableBox<Queue<ScheduledItemType>>
/// The singleton instance of the current thread scheduler.
public static let instance = CurrentThreadScheduler()
static var queue : ScheduleQueue? {
get {
return Thread.getThreadLocalStorageValueForKey(CurrentThreadSchedulerQueueKey.instance)
}
set {
Thread.setThreadLocalStorageValue(newValue, forKey: CurrentThreadSchedulerQueueKey.instance)
}
}
/// Gets a value that indicates whether the caller must call a `schedule` method.
public static fileprivate(set) var isScheduleRequired: Bool {
get {
return pthread_getspecific(CurrentThreadScheduler.isScheduleRequiredKey) == nil
}
set(isScheduleRequired) {
if pthread_setspecific(CurrentThreadScheduler.isScheduleRequiredKey, isScheduleRequired ? nil : scheduleInProgressSentinel) != 0 {
rxFatalError("pthread_setspecific failed")
}
}
}
public func schedule<StateType>(_ state: StateType, action: @escaping (StateType) -> Disposable) -> Disposable {
// 篇幅原因只贴出重点
}
}
- 这个作为代表详细分析，后面相同的内容大家自己类比
- 外界获取判断当前队列的是否被关联：
isScheduleRequired - 利用对
queue的set,get方法的观察，绑定我们的当前队列与静态字符串(这种用法，也是开发比较常用的) - 下面就是对线程的拓展
extension Thread {
static func setThreadLocalStorageValue<T: AnyObject>(_ value: T?, forKey key: NSCopying) {
let currentThread = Thread.current
let threadDictionary = currentThread.threadDictionary
if let newValue = value {
threadDictionary[key] = newValue
}
else {
threadDictionary[key] = nil
}
}
static func getThreadLocalStorageValueForKey<T>(_ key: NSCopying) -> T? {
let currentThread = Thread.current
let threadDictionary = currentThread.threadDictionary
return threadDictionary[key] as? T
}
}
- MainScheduler：表示主线程。如果我们需要执行一些和 UI 相关的任务，就需要切换到该 Scheduler 运行。一看下面的源码就非常清晰，绑定了主队列
DispatchQueue.main
public final class MainScheduler : SerialDispatchQueueScheduler {
private let _mainQueue: DispatchQueue
let numberEnqueued = AtomicInt(0)
public init() {
self._mainQueue = DispatchQueue.main
super.init(serialQueue: self._mainQueue)
}
public static let instance = MainScheduler()
}
- 同是这里还有继承了
SerialDispatchQueueScheduler就是串行调度者，其实我们也是可以理解的，主队列其实就是一种串行队列。
public class SerialDispatchQueueScheduler : SchedulerType {
let configuration: DispatchQueueConfiguration
init(serialQueue: DispatchQueue, leeway:) {
self.configuration = DispatchQueueConfiguration(queue: leeway:)
}
public convenience init(internalSerialQueueName: serialQueueConfiguration: leeway: ) {
let queue = DispatchQueue(label: internalSerialQueueName, attributes: [])
serialQueueConfiguration?(queue)
self.init(serialQueue: queue, leeway: leeway)
}
}
- 从这里也可以看出就是接受串行队列
- 如果没有，自己内部创建一个串行队列
-
ConcurrentDispatchQueueScheduler的思路和SerialDispatchQueueScheduler也是一模模一样样
public class ConcurrentDispatchQueueScheduler: SchedulerType {
public typealias TimeInterval = Foundation.TimeInterval
public typealias Time = Date
public var now : Date {
return Date()
}
let configuration: DispatchQueueConfiguration
public init(queue: leeway: ) {
self.configuration = DispatchQueueConfiguration(queue: leeway:)
}
public convenience init(qos: leeway: ) {
self.init(queue: DispatchQueue(
label: "rxswift.queue.\(qos)",
qos: qos,
attributes: [DispatchQueue.Attributes.concurrent],
target: nil),
leeway: leeway
)
}
}
-
OperationQueueScheduler：封装了NSOperationQueue, 下面代码非常清晰了，典型的操作队列和操作优先级
public class OperationQueueScheduler: ImmediateSchedulerType {
public let operationQueue: OperationQueue
public let queuePriority: Operation.QueuePriority
public init(operationQueue: queuePriority: ) {
self.operationQueue = operationQueue
self.queuePriority = queuePriority
}
}
调度执行
上面我们已经大致了解了线程，队列的封装(就是换了一个马甲)，其实如果你是一个用心的开发人员，看到这里，你肯定非常关系。到底我们的调度执行是怎么样的呢？下面我们直接分析，可以说简单的让你发指，但是真正难起来，又是让你发脱~~~~~哈哈哈哈哈
我们每次初始化是不是都有个非常重要的东西就是:
let configuration: DispatchQueueConfiguration 这里保存了我们需要的队列以及leeway信息，一般我们开发能保存信息的家伙都不简单
func schedule<StateType>(_ state: action: ) -> Disposable {
return self.scheduleInternal(state, action: action)
}
func scheduleInternal<StateType>(_ state: action: ) -> Disposable {
return self.configuration.schedule(state, action: action)
}
func scheduleRelative<StateType>(_ state: dueTime: action: ) -> Disposable {
return self.configuration.scheduleRelative(state, dueTime: action:)
}
func schedulePeriodic<StateType>(state: startAfter:period: action: ) -> Disposable {
return self.configuration.schedulePeriodic(state, startAfter: period: action:)
}
- 从上面核心方法：
schedule可以非常轻松看出都是我们的self.configuration具体施行者，下面我们来分析内部流程！
func schedule<StateType>(_ state: StateType, action: ) -> Disposable {
let cancel = SingleAssignmentDisposable()
self.queue.async {
if cancel.isDisposed { return }
cancel.setDisposable(action(state))
}
return cancel
}
- 我的天啊！还要怎么明显！就是在当前队列下面，异步调度执行具体的：
action(state)
分析完了，哈哈哈！但是如果你是一个讲究的人，一定会有这样的疑问，什么时候调用
scheduler上下游流程又是怎么样的？这是目前我们不得而知的。因为还有一篇恐怖的未知领域在等着你！Ready? 请进入下一篇：RxSwift调度者-scheduler源码解析（下）
总结
调度器（Schedulers）是
RxSwift实现多线程的核心模块，它主要用于控制任务在哪个线程或队列运行。
最后附上一张调度者继承关系图，希望希望研究的小伙伴继续加油，一路坚持一路花开 一一 和谐学习，不急不躁
就问此时此刻还有谁？45度仰望天空，该死！我这无处安放的魅力！
