RxSwift源码分析(三)-timer的解析

在开发中，咱们会常常用到定时器，主要是用NSTimer实现的。但或多或少都遇到过一些问题，好比说触发UI操做时定时器失效，循环引用、线程等问题。触发UI操做时定时器失效是由于把timer加入到runloop的模式不对，关闭循环引用的问题能够看以前写的一篇文章防止NSTimer循环引用的几个方法。固然咱们也能够用GCD的定时器，CGD中的定时器计时更加精准，不受主线程runloop的影响。它会在本身所在的线程中一直执行下去，直到你suspend或者cancel掉它，并且还能够指定handler所执行的线程。GCD定时器简单实用的代码：

gcdTimer = DispatchSource.makeTimerSource(queue: DispatchQueue.main)
gcdTimer.schedule(deadline: DispatchTime.now(), repeating: DispatchTimeInterval.seconds(1))
gcdTimer.setEventHandler(handler: {
    print("gcd timer\(Thread.current)")
})
gcdTimer.resume()
复制代码

RxSwift的timer实现

提示： 由于RxSwift的核心逻辑大体相同，因此前面文章讲过的核心逻辑这里不重复，只讲不一样的地方，还不太明白的朋友能够先看这两篇文章RxSwift源码分析(一)-核心逻辑解析和RxSwift源码分析(二)-Observable和AnonymousObservableSink解析

言归正传，咱们一块儿来看看RxSwift的timer是怎样实现的。首先咱们须要探索RxSwift的timer在使用的过程当中有没有如下几个问题：

1. RxSwift的timer是否受runloop的影响
2. 是否有循环引用的问题
3. 是否须要关心线程问题

带着问题，咱们进入RxSwift Timer的源码分析

// 第一次参数:第一次响应距离如今的时间
// 第二个参数:时间间隔
// 第三个参数:线程
_ = Observable<Int>.timer(DispatchTimeInterval.seconds(0), period: DispatchTimeInterval.seconds(1), scheduler: MainScheduler.instance).subscribe { (event) in
    print(event)
}
复制代码

如上，RxSwift Timer使用起来很是简单。 先进入到Timer.swift文件找到timer方法, 这是一个ObservableType协议的的扩展方法，返回的是一个Timer对象，其类型是Observable。因此Timer也是一个可观察序列，咱们能够经过订阅来接收观察者发送的消息。

public static func timer(_ dueTime: RxTimeInterval, period: RxTimeInterval? = nil, scheduler: SchedulerType)
        -> Observable<Element> {
        return Timer(
            dueTime: dueTime,
            period: period,
            scheduler: scheduler
        )
    }
复制代码

咱们继续跟踪到Timer类里面去看一看Timer究竟是怎么实现的

final private class Timer<Element: RxAbstractInteger>: Producer<Element> {
    fileprivate let _scheduler: SchedulerType
    fileprivate let _dueTime: RxTimeInterval
    fileprivate let _period: RxTimeInterval?

    init(dueTime: RxTimeInterval, period: RxTimeInterval?, scheduler: SchedulerType) {
        self._scheduler = scheduler
        self._dueTime = dueTime
        self._period = period
    }

    override func run<Observer: ObserverType>(_ observer: Observer, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where Observer.Element == Element {
        if self._period != nil {
            let sink = TimerSink(parent: self, observer: observer, cancel: cancel)
            let subscription = sink.run()
            return (sink: sink, subscription: subscription)
        }
        else {
            let sink = TimerOneOffSink(parent: self, observer: observer, cancel: cancel)
            let subscription = sink.run()
            return (sink: sink, subscription: subscription)
        }
    }
}
复制代码

在初始化的时候，保存了外面传过来的三个参数。 在上面的示例中，先建立了timer对象，而后调用了subscribe方法进行了订阅。若是看过上两篇关于RxSwift核心逻辑分析的文章的话，咱们知道当调用了subscribe方法的以后，代码会执行到Producer类的subscribe方法，而后执行到Timer类的run方法。在run方法中建立TimerSink对象并保持了Timer对象，而后执行sink.run，这个流程跟其余序列的执行是同样的。进入到TimerSink类里面：

final private class TimerSink<Observer: ObserverType> : Sink<Observer> where Observer.Element : RxAbstractInteger  {
    typealias Parent = Timer<Observer.Element>

    private let _parent: Parent
    private let _lock = RecursiveLock()

    init(parent: Parent, observer: Observer, cancel: Cancelable) {
        self._parent = parent
        super.init(observer: observer, cancel: cancel)
    }

    func run() -> Disposable {
        return self._parent._scheduler.schedulePeriodic(0 as Observer.Element, startAfter: self._parent._dueTime, period: self._parent._period!) { state in
            self._lock.lock(); defer { self._lock.unlock() }
            self.forwardOn(.next(state))
            return state &+ 1
        }
    }
}
复制代码

_parent就是Timer对象，而后一直跟踪schedulePeriodic进入，最后会来到DispatchQueueConfiguration类的schedulePeriodic方法

func schedulePeriodic<StateType>(_ state: StateType, startAfter: RxTimeInterval, period: RxTimeInterval, action: @escaping (StateType) -> StateType) -> Disposable {
        let initial = DispatchTime.now() + startAfter

        var timerState = state

        let timer = DispatchSource.makeTimerSource(queue: self.queue)
        timer.schedule(deadline: initial, repeating: period, leeway: self.leeway)
        
        var timerReference: DispatchSourceTimer? = timer
        let cancelTimer = Disposables.create {
            timerReference?.cancel()
            timerReference = nil
        }

        timer.setEventHandler(handler: {
            if cancelTimer.isDisposed {
                return
            }
            timerState = action(timerState)
        })
        timer.resume()
        
        return cancelTimer
    }
复制代码

能够看到，RxSwift的timer实际上是封装的DispatchSource定时器。当序列销毁时会执行定时器的cancel方法取消来定时器。当定时器触发时会调用action(timerState)这个代码块并保存代码块的返回值state(初始值为0)。这个代码块就是以前调用TimerSink类的run方法时的尾随闭包。这个函数会在咱们外面设置的那个主线程scheduler中调用，为了防止多线程调用致使数据错误，这里加了线程锁。而后执行forwardOn这个方法，后面的流程又跟以前两篇文章讲过的RxSwift核心逻辑同样，这里就不讲了。state是遵循FixedWidthInteger协议的变量，state &+ 1是位操做，每执行一次+1，&+运算符这种写法能够防止溢出，能够参考文档。

总结

针对上面提出的问题总结一下：

• 由于RxSwift的timer是封装的DispatchSource定时器是不会受runloop的影响的
• DispatchSource并无直接引用self，因此不存在循环引用带来的问题
• 建立timer序列时，咱们必须指定一个MainScheduler实例，也就指定了代码执行的线程。