在开发中，我们会经常用到定时器，主要是用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.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 {
return Timer(
dueTime: dueTime,
period: period,
scheduler: scheduler
)
}
我们继续跟踪到Timer类里面去看一看Timer到底是怎么实现的
final private class Timer: Producer {
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: 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 : Sink where Observer.Element : RxAbstractInteger {
typealias Parent = Timer
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(_ 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实例，也就指定了代码执行的线程。