1. 概述
说起计时器，很多开发人员第一时间就会想起Timer，但是随着使用的深入，慢慢就发现Timer其实不是很好用，比如说TableView滑动时候不执行,Timer循环引用。
2. DispatchSourceTimer
DispatchSourceTimer，也就是大家通常叫的GCD Timer，是依赖于GCD的一种Timer，Runloop的底层代码中也用到这种Timer，可见GCD Timer并不依赖与Runloop。
先看一下苹果的定义:
A dispatch source that submits the event handler block based on a timer.
2.1 GCD Timer 创建
使用下面的方法即可创建一个DispatchSourceTimer对象。
class func makeTimerSource(flags: DispatchSource.TimerFlags = [], queue: DispatchQueue? = nil) -> DispatchSourceTimer
// 默认在主队列中调度使用
let timer = DispatchSource.makeTimerSource()
// 指定在主队列中调度使用
let timer = DispatchSource.makeTimerSource(flags: [], queue: DispatchQueue.main)
// 指定在全局队列中调度使用
let timer = DispatchSource.makeTimerSource(flags: [], queue: DispatchQueue.global())
// 指定在自定义队列中调度使用
let customQueue = DispatchQueue(label: "customQueue")
let timer = DispatchSource.makeTimerSource(flags: [], queue: customQueue)
2.2 GCD Timer 配置
配置Timer参数，需要使用DispatchSourceTimer协议的方法。可以安排一次或多次触发的Timer。Timer每次触发的时候，都会调用已部署的任务。
// 从现在开始，每秒执行一次。
timer?.schedule(deadline: DispatchTime.now(), repeating: .seconds(1), leeway: .nanoseconds(1))
// 5秒之后执行任务，不重复。
timer?.schedule(deadline: DispatchTime.now() + 5, repeating: .never, leeway: .nanoseconds(1))
2.3 GCD Timer 部署任务
当Timer配置完参数后，使用DispatchSourceProtocol协议的方法来部署要执行的任务。
setEventHandler和setRegistrationHandler的区别：
- setEventHandler：给Timer设置要执行的任务，包括一次性任务和定时重复的任务。回调方法在子线程中执行。
- setRegistrationHandler：这个方法设置的任务只会执行一次，也就是在Timer就绪后开始运行的时候执行，类似于Timer开始的一个通知回调。回调方法在子线程中执行。
例如下面的代码：
var timer: DispatchSourceTimer?
func initTimer() {
// 默认在主队列中调度使用
timer = DispatchSource.makeTimerSource()
// 从现在开始，每秒执行一次。
timer?.schedule(deadline: DispatchTime.now(), repeating: .seconds(1), leeway: .nanoseconds(1))
// 5秒之后执行任务，不重复。
// timer?.schedule(deadline: DispatchTime.now() + 5, repeating: .never, leeway: .nanoseconds(1))
timer?.setEventHandler {
DispatchQueue.main.async {
print("执行任务")
}
}
timer?.setRegistrationHandler(handler: {
DispatchQueue.main.async {
print("Timer开始工作了")
}
})
timer?.activate()
}
执行结果如下：
2020-11-28 02:20:00 +0000 Timer开始工作了
2020-11-28 02:20:00 +0000 执行任务
2020-11-28 02:20:01 +0000 执行任务
2020-11-28 02:20:02 +0000 执行任务
2.4 GCD Timer控制方法
下面看一下Timer的一下控制方法及状态：
activate() : 当创建完一个Timer之后，其处于未激活的状态，所以要执行Timer，需要调用该方法。
suspend() : 当Timer开始运行后，调用该方法便会将Timer挂起，即暂停。
resume() : 当Timer被挂起后，调用该方法便会将Timer继续运行。
cancel() : 调用该方法后，Timer将会被取消，被取消的Timer如果想再执行任务，则需要重新创建。
上面的这些方法如果使用不当，很容易造成APP崩溃，下面来看一下具体注意事项及建议：当Timer创建完后，建议调用activate()方法开始运行。如果直接调用resume()也可以开始运行。
suspend()的时候，并不会停止当前正在执行的event事件，而是会停止下一次event事件。
当Timer处于suspend的状态时，如果销毁Timer或其所属的控制器，会导致APP奔溃。
suspend()和resume()需要成对出现，挂起一次，恢复一次，如果Timer开始运行后，在没有suspend的时候，直接调用resume()，会导致APP崩溃。
使用cancel()的时候，如果Timer处于suspend状态，APP崩溃。
另外需要注意block的循环引用问题。
2.5 双重循环 DispatchSourceTimer
比如：我们需要一定时间情况下(数组长度*4),每隔一段时间打印对应下标(每个元素隔4秒打印)，无限打印
在下面例子的双重循环中使用 DispatchSourceTimer 你会发现print只打印了 dom some = 0
这个不是我们想要的效果
var exaltedTimer: DispatchSourceTimer?
func demo {
let arr = [1,2,3,4]
self.exaltedTimer = DispatchSource.makeTimerSource()
self.exaltedTimer?.schedule(deadline: .now(), repeating: TimeInterval(arr.count*4))
self.exaltedTimer?.setEventHandler(handler: {
for (index, item) in arr.enumerated() {
let timer2 = DispatchSource.makeTimerSource()
timer2.schedule(deadline: .now()+4.0*CGFloat(index), repeating: .infinity)
timer2.setEventHandler {
DispatchQueue.main.async {
print("do some = \(index)")
}
}
timer2.activate()
}
})
self.exaltedTimer?.activate()
}
这个是因为timer2使用之后就被释放了，所以要cancel和resume配合使用，这样就实现了我们想要的效果了。
var exaltedTimer: DispatchSourceTimer?
var exaltedTimerArray: [DispatchSourceTimer] = []
func demo {
self.exaltedTimer?.cancel()
for subTimer in self.exaltedTimerArray {
subTimer.cancel()
}
let arr = [1,2,3,4]
self.exaltedTimer = DispatchSource.makeTimerSource()
self.exaltedTimer?.schedule(deadline: .now(), repeating: TimeInterval(arr.count*4))
self.exaltedTimer?.setEventHandler(handler: {
for (index, item) in arr.enumerated() {
let timer2 = DispatchSource.makeTimerSource()
timer2.schedule(deadline: .now()+4.0*CGFloat(index), repeating: .infinity)
timer2.setEventHandler {
DispatchQueue.main.async {
print("do some = \(index)")
}
}
self.exaltedTimerArray.append(timer2)
timer2.resume()
}
})
self.exaltedTimer?.resume()
3 OC GCD定时器 封装
GCDTimer.h
@interface GCDTimer : NSObject
/**
* 对象创建定时器 主线程创建
* interval 定时时间
* repeat 是否轮询
* block 返回
*/
- (instancetype)initWithTimeInterval:(NSTimeInterval)interval repeat:(BOOL)repeat block:(dispatch_block_t)block;
/**
* 对象创建定时器 主线程创建
* interval 定时时间
* repeat 是否轮询
* queue 线程
* block 返回
*/
- (instancetype)initWithTimeInterval:(NSTimeInterval)interval repeat:(BOOL)repeat queue:(dispatch_queue_t)queue block:(dispatch_block_t)block;
/**
* 类创建定时器 主线程创建
* interval 定时时间
* repeat 是否轮询
* block 返回
*/
+ (instancetype)scheduledTimerWithTimeInterval:(NSTimeInterval)interval repeat:(BOOL)repeat queue:(dispatch_queue_t)queue block:(dispatch_block_t)block;
/**
* 类创建定时器 主线程创建
* interval 定时时间
* repeat 是否轮询
* queue 线程
* block 返回
*/
+ (instancetype)scheduledTimerWithTimeInterval:(NSTimeInterval)interval repeat:(BOOL)repeat block:(dispatch_block_t)block;
/**
* 设置定时器时间
* interval 定时时间
*/
- (void)setTimeInterval:(NSTimeInterval)interval;
/**
* 停止定时器
*/
- (void)stop;
/**
* 重启定时器
*/
- (void)restart;
/**
* 释放定时器
*/
- (void)invalidate;
@end
GCDTimer.m
@interface GCDTimer() {
dispatch_source_t _timer;
BOOL _isFire;
}
@end
@implementation GCDTimer
- (instancetype)initWithTimeInterval:(NSTimeInterval)interval repeat:(BOOL)repeat block:(dispatch_block_t)block {
return [self initWithTimeInterval:interval repeat:repeat queue:dispatch_get_main_queue() block:block];
}
- (instancetype)initWithTimeInterval:(NSTimeInterval)interval repeat:(BOOL)repeat queue:(dispatch_queue_t)queue block:(dispatch_block_t)block {
NSAssert(queue != NULL, @"queue can't be NULL while create GCDTimer");
if (self = [super init]) {
// 创建线程
_timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
dispatch_source_set_timer(_timer, dispatch_time(DISPATCH_TIME_NOW, 0), interval * NSEC_PER_SEC, 0);
// 执行任务
dispatch_source_set_event_handler(_timer, ^{
if (block) {
block();
}
if (!repeat) {
self->_isFire = NO;
dispatch_source_cancel(self->_timer);
}
});
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(interval * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
dispatch_resume(self->_timer);
self->_isFire = YES;
});
}
return self;
}
+ (instancetype)scheduledTimerWithTimeInterval:(NSTimeInterval)interval repeat:(BOOL)repeat queue:(dispatch_queue_t)queue block:(dispatch_block_t)block {
return [[GCDTimer alloc] initWithTimeInterval:interval repeat:repeat queue:queue block:block];
}
+ (instancetype)scheduledTimerWithTimeInterval:(NSTimeInterval)interval repeat:(BOOL)repeat block:(dispatch_block_t)block {
return [self scheduledTimerWithTimeInterval:interval repeat:repeat queue:dispatch_get_main_queue() block:block];
}
- (void)setTimeInterval:(NSTimeInterval)interval {
if (_isFire) {
dispatch_source_set_timer(_timer, dispatch_time(DISPATCH_TIME_NOW, 0), interval * NSEC_PER_SEC, 0);
}
}
- (void)stop {
if (_isFire) {
_isFire = NO;
// 挂起定时器队列
dispatch_suspend(_timer);
}
}
- (void)restart {
if (!_isFire) {
_isFire = YES;
// 恢复定时器队列
dispatch_resume(_timer);
}
}
- (void)invalidate {
_isFire = NO;
// 取消定时器队列
dispatch_source_cancel(_timer);
}
- (void)dealloc {
_isFire = NO;
// 取消定时器队列
dispatch_source_cancel(_timer);
}
@end
4 Swift GCD定时器 封装
import Foundation
class CGDTimer: NSObject {
static let `default` = CGDTimer()
private var timer: DispatchSourceTimer?
deinit {
timer?.cancel()
}
// 暂停定时器
func stop() {
timer?.suspend()
}
// 重启定时器
func restart() {
timer?.resume()
}
// 清除定时器
func invalidate() {
timer?.cancel()
}
// 主线程设置CGD定时器
// interval 时间
// isRepeat 是否循环
// block 执行返回
func setTimeInterval(interval: Int, isRepeat: Bool = false, block: @escaping () -> Void) {
// 默认在主队列中调度使用
timer = DispatchSource.makeTimerSource()
var timeType: DispatchTimeInterval = .never
if isRepeat {
timeType = .seconds(interval)
}
timer?.schedule(deadline: DispatchTime.now(), repeating: timeType, leeway: .nanoseconds(1))
timer?.setEventHandler {
DispatchQueue.main.async {
// 执行任务
block()
}
}
timer?.setRegistrationHandler(handler: {
DispatchQueue.main.async {
// Timer开始工作了
}
})
// timer?.activate()
timer?.resume()
}
// 线程设置CGD定时器
// ztimer 对应线程
// interval 时间
// isRepeat 是否循环
// block 执行返回
func setTimeInterval(ztimer: DispatchSourceTimer, interval: Int, isRepeat: Bool = false, block: @escaping () -> Void) {
timer = ztimer
var timeType: DispatchTimeInterval = .never
if isRepeat {
timeType = .seconds(interval)
}
timer?.schedule(deadline: DispatchTime.now(), repeating: timeType, leeway: .nanoseconds(1))
timer?.setEventHandler {
DispatchQueue.main.async {
// 执行任务
block()
}
}
timer?.setRegistrationHandler(handler: {
DispatchQueue.main.async {
// Timer开始工作了
}
})
// timer?.activate()
timer?.resume()
}
}
参考文章
https://blog.csdn.net/guoyongming925/article/details/110224064
