开发过程中，遇到在某个时间或按照某个周期来执行一些方法的时候，就会用到定时器。下面就是几种开发中常见的定时器的创建方式。
1.Timer(NSTimer)
(1) target action:
func testTimer(){
let timer = Timer.init(timeInterval: 1, target: self, selector: #selector(timerAction), userInfo: nil, repeats: true)
// 需要手动加入到runLoop中
// 如果想不受scrollView页面滑动影响（滑动时不响应selector，滑动停止后恢复），需设置当前runloop的commonMode模式
RunLoop.current.add(timer, forMode: .default)
}
@objc func timerAction(){
print("timerAction")
}
(2) scheduledTimer block
// 默认添加到runLoop中，使用defaultMode模式
timer = Timer.scheduledTimer(withTimeInterval: 1, repeats: true, block: { (timer) in
print("timerAction")
})
// 可以手动设置当前runloop的commonMode模式避免页面滑动影响
RunLoop.current.add(timer, forMode: .common)
NSTimer的执行依赖runLoop，如果当前runLoop正在执行一个连续性的运算，timer就会被延时触发。当延迟超过timer的一个重复周期，会在延时结束后按照指定的周期继续执行。
2.GCD(DispatchSourceTimer)
let gcdTimer = DispatchSource.makeTimerSource()
gcdTimer.schedule(deadline: DispatchTime.now(), repeating: DispatchTimeInterval.seconds(1))
gcdTimer.setEventHandler(handler: {
print("GCD timerAction")
})
// 默认挂起状态，需手动启动
gcdTimer.resume()
// 挂起，挂起状态时不能释放（置为nil），会导致崩溃
// 可以再次resume()唤起定时器
gcdTimer.suspend()
// 取消，解释定时任务
// 取消任务后如果想再次执行Timer，只能重新创建一个 Timer
gcdTimer.cancel()
gcdTimer = nil
GCD创建的Timer不受runLoop影响，使用DispatchSource，可以实现更加精准的定时效果。
3.CADisplayLink
let cadTimer = CADisplayLink(target: self, selector: #selector(timerAction))
// 单位是帧，屏幕刷新多少帧时调用一次selector
// 默认值为0，选择使用设备的最高屏幕刷新频率（iOS为60次每秒）
// 所以执行时间间隔为：preferredFramesPerSecond * 最高屏幕刷新间隔，如iOS设备：preferredFramesPerSecond * 1/60 秒
cadTimer.preferredFramesPerSecond = 20
// 注册到runLoop中监听
cadTimer.add(to: RunLoop.current, forMode: .default)
// 挂起
// cadTimer.isPaused = true
// 终止
cadTimer?.invalidate()
cadTimer = nil
由于跟屏幕刷新同步，非常适合UI的重复绘制，如：下载进度条，自定义动画设计，视频播放渲染等。
4.RxSwift(interval/timer)
// interval方式
// period：每次发送的时间间隔，scheduler：调度者
timer = Observable<Int>.interval(1, scheduler: MainScheduler.instance)
// timer方式
//timer = Observable<Int>.timer(1, scheduler: MainScheduler.instance)
timer?.subscribe(onNext: { (time) in
print(time)
})
.disposed(by: disposeBag)
源码解析：
interval，timer创建都是使用以下初始化方式。
public static func timer(_ dueTime: RxTimeInterval, period: RxTimeInterval? = nil, scheduler: SchedulerType)
-> Observable<Element> {
return Timer(
dueTime: dueTime,
period: period,
scheduler: scheduler
)
}
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)
}
}
}
了解过RxSwift的同学，Timer类是不是很眼熟，是不是和AnonymousObservable非常相似，一样的继承Producer，一样的init方式，一样的run方法中创建sink。有兴趣的同学可以看看这两篇RxSwift（二）原理-执行流程
，RxSwift（三）原理深入探究。
原理和RxSwift核心原理差不多，只是生成了TimerSink或者TimerOneOffSink，sink调用run方法，以TimerSink为例：
跟一下源码：sink.run()
final private class TimerSink<Observer: ObserverType> : Sink<Observer> where Observer.Element : RxAbstractInteger {
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
}
}
}
public class SerialDispatchQueueScheduler : SchedulerType {
/**
Schedules a periodic piece of work.
- parameter state: State passed to the action to be executed.
- parameter startAfter: Period after which initial work should be run.
- parameter period: Period for running the work periodically.
- parameter action: Action to be executed.
- returns: The disposable object used to cancel the scheduled action (best effort).
*/
public func schedulePeriodic<StateType>(_ state: StateType, startAfter: RxTimeInterval, period: RxTimeInterval, action: @escaping (StateType) -> StateType) -> Disposable {
return self.configuration.schedulePeriodic(state, startAfter: startAfter, period: period, action: action)
}
}
extension DispatchQueueConfiguration {
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
}
}
可以看到这里其实就是初始化了一个DCD Timer，这里有一句关键代码：timerState = action(timerState)。
这里的action就是schedulePeriodic传入的闭包：
{ state in
self._lock.lock(); defer { self._lock.unlock() }
self.forwardOn(.next(state))
return state &+ 1
}
闭包里通过state的递增，重复调用self.forwardOn(.next(state))，这句代码会调用self._observer.on(event)，将event传入到subscribe()订阅方法中，订阅方法创建匿名观察者AnonymousObserver保存的闭包会根据传入的event枚举值对应到onNext()。
RxSwift的timer是封装的DispatchSource定时器的，所以也是不受runloop影响的。
