iOS DispatchSourceTimer 定时器

作者: Hahn_z | 来源:发表于2022-05-09 10:03 被阅读0次

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

iOS DispatchSourceTimer 定时器

1. 概述

2. DispatchSourceTimer

2.1 GCD Timer 创建

2.2 GCD Timer 配置

2.3 GCD Timer 部署任务

2.4 GCD Timer控制方法

2.5 双重循环 DispatchSourceTimer

3 OC GCD定时器封装

4 Swift GCD定时器封装

参考文章

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

iOS DispatchSourceTimer 定时器

1. 概述

2. DispatchSourceTimer

2.1 GCD Timer 创建

2.2 GCD Timer 配置

2.3 GCD Timer 部署任务

2.4 GCD Timer控制方法

2.5 双重循环 DispatchSourceTimer

3 OC GCD定时器 封装

4 Swift GCD定时器 封装

参考文章

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

3 OC GCD定时器封装

4 Swift GCD定时器封装