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在使用的过程中有没有以下几个问题：

RxSwift的timer是否受runloop的影响
是否有循环引用的问题
是否需要关心线程问题

带着问题，我们进入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实例，也就指定了代码执行的线程。

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

RxSwift的timer实现

总结

推荐阅读更多精彩内容