public static func of(_ elements: E ..., scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance) -> Observable<E> {
return ObservableSequence(elements: elements, scheduler: scheduler)
}
Observable.of方法接受一个不定参数，其返回一个ObservableSequence类型的Observable，该Observable默认是持有一个CurrentThreadScheduler，该类是一个当前线程任务调度器，调度器内部有一个队列类型，用来存放已提交的还没执行的任务，只要调度器执行完成当前任务，他将执行其队列内部的任务。
该方法整体的逻辑是，创建一个匿名的观察者AnonymousObserver,其持有相应事件的代码
#if DEBUG
synchronizationTracker.register(synchronizationErrorMessage: .default)
defer { synchronizationTracker.unregister() }
#endif
switch event {
case .next(let value):
onNext?(value)
case .error(let error):
if let onError = onError {
onError(error)
}
else {
Hooks.defaultErrorHandler(callStack, error)
}
disposable.dispose()
case .completed:
onCompleted?()
disposable.dispose()
}
然后调用Observable的subscribe方法，将自己(Observable与Observer)关联，此处的Observable是ObservableSequence类型，ObservableSequence是Producer的子类，ObservablerSequence的subscribe方法是直接继承Producer的。我们看一下Producer的Subscribe代码：
override func subscribe<O : ObserverType>(_ observer: O) -> Disposable where O.E == Element {
if !CurrentThreadScheduler.isScheduleRequired {
// The returned disposable needs to release all references once it was disposed.
let disposer = SinkDisposer()
let sinkAndSubscription = self.run(observer, cancel: disposer)
disposer.setSinkAndSubscription(sink: sinkAndSubscription.sink, subscription: sinkAndSubscription.subscription)
return disposer
}
else {
//开启一个当前线程任务调度器调度了一个任务，该任务启动了observable，sink，observer三个对象的关联
return CurrentThreadScheduler.instance.schedule(()) { _ in
let disposer = SinkDisposer()
let sinkAndSubscription = self.run(observer, cancel: disposer)
disposer.setSinkAndSubscription(sink: sinkAndSubscription.sink, subscription: sinkAndSubscription.subscription)
return disposer//这个disposer
}
}
}
其实subscribe方法做的事情就是调用自身的run方法实现observer与observable的绑定，至于if else，CurrentThreadScheduler是多线程相关的代码，不是我们关心的重点。接下来我们看一下ObservableSequence的run方法
override func run<O : ObserverType>(_ observer: O, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where O.E == E {
let sink = ObservableSequenceSink(parent: self, observer: observer, cancel: cancel)
let subscription = sink.run()
return (sink: sink, subscription: subscription)
}
这里我们看到，代码里用到了ObservableSequenceSink的类型，其持有了ObserverSequence与观察者还有上面代码传过来的SinkDisposer。ObservableSequenceSink是专门为ObserverSequence而服务的Sink，Sink我们可以理解为管道，将Observable的信号传递给Observer的桥梁。接下来我们看一下ObservableSequenceSink的run方法是如何执行的。
func run() -> Disposable {
//启动管道，让调度器开启一个递归调度代码块，这个代码块是发送信号的核心(为什么要递归地执行代码？)
return self._parent._scheduler.scheduleRecursive(self._parent._elements.makeIterator()) { iterator, recurse in
var mutableIterator = iterator
print("state=\(iterator)")
if let next = mutableIterator.next() {
print(next)
self.forwardOn(.next(next))//发送了一次信号
recurse(mutableIterator)
}
else {
self.forwardOn(.completed)
self.dispose()
}
}
}
这里run方法做的事情就是在CurrentThreadScheduler里递归地投递任务，如何实现递归地投递？我们看一下scheduleRecursive的代码：
public func scheduleRecursive<State>(_ state: State, action: @escaping (_ state: State, _ recurse: (State) -> Void) -> Void) -> Disposable {
let recursiveScheduler = RecursiveImmediateScheduler(action: action, scheduler: self)//此处action就是发送信号的action
recursiveScheduler.schedule(state)//提交了一个任务到CurrentScheduler
return Disposables.create(with: recursiveScheduler.dispose)
}
这里是通过RecursiveImmediateScheduler来实现递归的投递任务，从该类的名字我们很容易知道该类的作用:递归地投递立即执行的任务,他的schedule方法是投递任务的关键，我们来看一下schedule方法的实现:
func schedule(_ state: State) {
var scheduleState: ScheduleState = .initial
//这里的又启动了一个任务，但是这个任务并不能马上执行，所以该任务被封装成ScheduleItem放入Scheduler的执行队列里了
let d = self._scheduler.schedule(state) { state -> Disposable in
// best effort
if self._group.isDisposed {
return Disposables.create()
}
//这里抛开线程安全的代码不看，做的事情其实就是1，将任务从自身group中移除，将并将当前任务状态更改为完成，并将自身所持有的action返回
let action = self._lock.calculateLocked { () -> Action? in
switch scheduleState {
case let .added(removeKey):
self._group.remove(for: removeKey)
case .initial:
break
case .done:
break
}
scheduleState = .done
return self._action
}
//执行action
if let action = action {
print("state=\(state)")
action(state, self.schedule)//这里的action其实是发送信号的action，这里的self.schedule是递归的所在
}
return Disposables.create()
}
//这里将任务的执行状态设置为加入队列，任务状态一共有三种，intial added done
self._lock.performLocked {
switch scheduleState {
case .added:
rxFatalError("Invalid state")
case .initial:
if let removeKey = self._group.insert(d) {
scheduleState = .added(removeKey)
}
else {
scheduleState = .done
}
case .done:
break
}
}
}
抛开线程安全的代码不看，他就是在CurrentThreadScheduler里投递了一个任务，这个任务当前并没有执行，而是等到当前任务执行完成后才会执行，我们所执行的代码就是当前执行的任务.
public func schedule<StateType>(_ state: StateType, action: @escaping (StateType) -> Disposable) -> Disposable {
if CurrentThreadScheduler.isScheduleRequired {
CurrentThreadScheduler.isScheduleRequired = false
let disposable = action(state)
defer {
CurrentThreadScheduler.isScheduleRequired = true
CurrentThreadScheduler.queue = nil
}
guard let queue = CurrentThreadScheduler.queue else {
return disposable
}
while let latest = queue.value.dequeue() {
if latest.isDisposed {
continue
}
latest.invoke()//ScheduledItem要执行了
}
return disposable
}
let existingQueue = CurrentThreadScheduler.queue
let queue: RxMutableBox<Queue<ScheduledItemType>>
if let existingQueue = existingQueue {
queue = existingQueue
}
else {
queue = RxMutableBox(Queue<ScheduledItemType>(capacity: 1))
CurrentThreadScheduler.queue = queue
}
let scheduledItem = ScheduledItem(action: action, state: state)
queue.value.enqueue(scheduledItem)
return scheduledItem
}
上面代码是CurrentThreadScheduler的启动任务方法，以上所讲的代码其实都是在let disposable=action(state)里，都是在执行action().当RecursiveImmediateScheduler提交完递归任务后，代码就会逐级返回，最终会回到CurrentThreadScheduler的schedule方法里，继续向下执行，（defer是一个语法糖，其保证defer的block会在函数将要返回之前执行，可以在defer block里执行一些清理工作），接下来函数将保存好的ScheduleItem取出，执行，这里的ScheduleItem所持有的block是RecursiveImmediateScheduler在他的schedule方法里提交的，代码如下:
let d = self._scheduler.schedule(state) { state -> Disposable in
// best effort
if self._group.isDisposed {
return Disposables.create()
}
//这里抛开线程安全的代码不看，做的事情其实就是1，将任务从自身group中移除，将并将当前任务状态更改为完成，并将自身所持有的action返回
let action = self._lock.calculateLocked { () -> Action? in
switch scheduleState {
case let .added(removeKey):
self._group.remove(for: removeKey)
case .initial:
break
case .done:
break
}
scheduleState = .done
return self._action
}
//执行action
if let action = action {
print("state=\(state)")
action(state, self.schedule)//这里的action其实是发送信号的action，这里的self.schedule是递归的所在
}
return Disposables.create()
}
其实就是执行RecursiveScheduler所持有的代码：
var mutableIterator = iterator
print("state=\(iterator)")
if let next = mutableIterator.next() {
print(next)
self.forwardOn(.next(next))//发送了一次信号
recurse(mutableIterator)
}
else {
self.forwardOn(.completed)
self.dispose()
}
该action的两个参数，一个是由最开始调用Observable.of传的sequence参数生成的迭代器，另一个参数是RecursiveScheduler的schedule函数。我们注意观察这个action，这个action的大意是取出迭代器下一个元素，发送信号，然后再次执行RecursiveScheduler的schedule方法，其实就是再次提交一个任务到CurrentThreadScheduler，提交这个任务时，迭代器还是最开始的那个迭代器，只是他的next已经指向了下一个元素，也就能发送下一个信号了，随着迭代器持续的next(),最后迭代器的next方法将返回nil，那么action将发送完成信号，然后开始清理工作。至此，Observable.of().suscribe方法已经完成了信号发送，响应。
我们再看一下forwardOn代码:
final func forwardOn(_ event: Event<O.E>) {
#if DEBUG
self._synchronizationTracker.register(synchronizationErrorMessage: .default)
defer { self._synchronizationTracker.unregister() }
#endif
if isFlagSet(&self._disposed, 1) {
return
}
self._observer.on(event)
}
这段代码就是调用了其持有的观察者的on block，也就是匿名观察者持有的信号响应block，这个block判断信号，如果是.next的，就会调用最开始你写的响应方法，也就完成了信号的相应。
RxSwift是一个优秀的框架，本人水平有限，如有错误，请批评指正，如果转载，请附上原链接