iOS中三种定时器CADisplayLink、NSTimer和GCD定时器,我们就详尽的讲解一下三种定时器.
在讲解CADisplayLink、NSTimer的时候我们需要对于runloop有一部分的了解:iOS RunLoop(1)-底层解析.
1. NSTimer
NSTimer我相信在大家开发的过程中肯定都用过,但是NSTimer还是有一些需要注意的地方:iOS RunLoop(2)-应用.下面我们再来简单的介绍一下NSTimer的使用.
下面这两种形式不需要添加runloop,因为是scheduledTimerWithTimeInterval方式创建的.
\\NSTimer的创建方式
\\普通的创建方式
NSTimer* timer = [NSTimer scheduledTimerWithTimeInterval:1.0 target:self selector:@selector(timerAction:) userInfo:nil repeats:YES];
/**
NSTimer
@param NSTimeInterval 等待时间（单位是秒，即就是每个几秒执行一次）
@param target 执行对象
@param selector 执行方法(定时器执行的方法)
@param userInfo 标识信息(一般不用)
@param repeats 是否重复执行
@return NSTimer对象（定时器）
*/
\\block的方式创建
NSTimer* timer = [NSTimer scheduledTimerWithTimeInterval:1.0 repeats:YES block:^(NSTimer * _Nonnull timer) {
//重复执行的代码
}];
/**
NSTimer block的创建方式
@param TimerInterval 等待时间
@param repeats 是否重复执行
@param block 执行的代码
@return NSTimer对象
*/
下面这几种创建的方式是需要添加runloop的
\\第一种创建方式
NSTimer* timer = [NSTimer timerWithTimeInterval:1.0 target:self selector:@selector(timerAction:) userInfo:nil repeats:YES];
[[NSRunLoop mainRunLoop] addTimer:timer forMode:NSDefaultRunLoopMode];
\\第二种创建方式
NSTimer* timer = [NSTimer timerWithTimeInterval:1.0 repeats:YES block:^(NSTimer * _Nonnull timer) {
NSLog(@"-----");
}];
[[NSRunLoop mainRunLoop] addTimer:timer forMode:NSDefaultRunLoopMode];
\\第三种创建方式
NSTimer* timer = [[NSTimer alloc] initWithFireDate:[NSDate date] interval:1.0 target:self selector:@selector(timerAction:) userInfo:nil repeats:YES];
[[NSRunLoop mainRunLoop] addTimer:timer forMode:NSDefaultRunLoopMode];
\\第四种创建方式
NSTimer* timer = [[NSTimer alloc] initWithFireDate:[NSDate date] interval:1.0 repeats:YES block:^(NSTimer * _Nonnull timer) {
NSLog(@"----");
}];
[[NSRunLoop mainRunLoop] addTimer:timer forMode:NSDefaultRunLoopMode];
2. CADisplayLink
CADisplayLink可能大家很少用过,CADisplayLink的功能很单一，就是作为一个定时器的存在。他的优势就在于他的执行频率是根据设备屏幕的刷新频率来计算的。换句话讲，他也是时间间隔最准确的定时器。
CADisplayLink是一个能让我们以和屏幕刷新率相同的频率将内容画到屏幕上的定时器。我们在应用中创建一个新的 CADisplayLink 对象，把它添加到一个runloop中，并给它提供一个 target 和 selector 在屏幕刷新的时候调用。
一但 CADisplayLink 以特定的模式注册到runloop之后，每当屏幕需要刷新的时候，runloop就会调用CADisplayLink绑定的target上的selector，这时target可以读到 CADisplayLink 的每次调用的时间戳，用来准备下一帧显示需要的数据。例如一个视频应用使用时间戳来计算下一帧要显示的视频数据。在UI做动画的过程中，需要通过时间戳来计算UI对象在动画的下一帧要更新的大小等等。
在添加进runloop的时候我们应该选用高一些的优先级，来保证动画的平滑。可以设想一下，我们在动画的过程中，runloop被添加进来了一个高优先级的任务，那么，下一次的调用就会被暂停转而先去执行高优先级的任务，然后在接着执行CADisplayLink的调用，从而造成动画过程的卡顿，使动画不流畅。
CADisplayLink 不能被继承.
给非UI对象添加动画效果:
我们知道动画效果就是一个属性的线性变化，比如 UIView 动画的 EasyIn EasyOut 。通过数值按照不同速率的变化我们能生成更接近真实世界的动画效果。我们也可以利用这个特性来使一些其他属性按照我们期望的曲线变化。比如当播放视频时关掉视频的声音我可以通过 CADisplayLink 来实现一个 EasyOut 的渐出效果：先快速的降低音量，在慢慢的渐变到静音。
注意
通常来讲：iOS设备的刷新频率事60HZ也就是每秒60次。那么每一次刷新的时间就是1/60秒 大概16.7毫秒。当我们的frameInterval值为1的时候我们需要保证的是 CADisplayLink调用的target的函数计算时间不应该大于 16.7否则就会出现严重的丢帧现象。 在mac应用中我们使用的不是CADisplayLink而是 CVDisplayLink它是基于C接口的用起来配置有些麻烦但是用起来还是很简单的。
CADisplayLink的创建方法:
self.link = [CADisplayLink displayLinkWithTarget:self selector:@selector(linkTest)];
[self.link addToRunLoop:[NSRunLoop mainRunLoop] forMode:NSDefaultRunLoopMode];
参数的解析:
duration属性:提供了每帧之间的时间，也就是屏幕每次刷新之间的的时间。该属性在target的selector被首次调用以后才会被赋值。selector的调用间隔时间计算方式是：时间=duration×frameInterval。 我们可以使用这个时间来计算出下一帧要显示的UI的数值。但是 duration只是个大概的时间，如果CPU忙于其它计算，就没法保证以相同的频率执行屏幕的绘制操作，这样会跳过几次调用回调方法的机会。
frameInterval属性:是可读可写的NSInteger型值，标识间隔多少帧调用一次selector 方法，默认值是1，即每帧都调用一次。如果每帧都调用一次的话，对于iOS设备来说那刷新频率就是60HZ也就是每秒60次，如果将 frameInterval 设为2 那么就会两帧调用一次，也就是变成了每秒刷新30次。
pause属性:控制CADisplayLink的运行。当我们想结束一个CADisplayLink的时候，应该调用-(void)invalidate 从runloop中删除并删除之前绑定的 target 跟 selector。
timestamp属性: 只读的CFTimeInterval值，表示屏幕显示的上一帧的时间戳，这个属性通常被target用来计算下一帧中应该显示的内容。 打印timestamp值，其样式类似于：179699.631584。
3. CADisplayLink和NSTimer循环引用
demo
@interface ViewController ()
@property (strong , nonatomic) CADisplayLink *link;
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
//保证调用频率和屏幕的刷帧频率一致,60fps
self.link = [CADisplayLink displayLinkWithTarget:self selector:@selector(linkTest)];
[self.link addToRunLoop:[NSRunLoop mainRunLoop] forMode:NSDefaultRunLoopMode];
}
- (void) linkTest{
NSLog(@"%s",__func__);
}
@end
@interface ViewController ()
@property (strong , nonatomic) NSTimer *timer;
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
self.timer = [NSTimer scheduledTimerWithTimeInterval:1.0 target:self selector:@selector(timerTest) userInfo:nil repeats:YES];
}
- (void) timerTest{
NSLog(@"%s",__func__);
}
@end
上述代码，将创建一个无限循环的 timer,但是无论是NSTimer还是CADisplayLink都会造成循环引用.
我们以timer的代码作分析:
在这个方法中，如果repeats传入的参数是YES，那么NSTimer对象会保留target传入的对象，也就是强持有它，这种情形会保持到NSTimer对象失效为止。如果是一次性的定时器，不需要手动去invalidate就会失效，但是重复性的定时器，需要主动去调用invalidate方法才会失效。
综上看来，viewController强持有了NSTimer对象，而NSTimer对象在其[NSTimer scheduledTimerWithTimeInterval:1.0 target:self selector:@selector(timeStart) userInfo:nil repeats:YES];方法中对传入的target参数也进行了强引用，这也保证了NSTimer对象调用时的正确性。此时如果传入target的是self，那么就会形成viewController和NSTimer对象的循环引用环，如果循环引用环没有被打破，那么viewController在弹栈的时候就不会被释放，也就不会走dealloc方法，也就不会将NSTimer对象invalidate，这个时候viewController和NSTimer对象都得不到释放，也就产生了内存泄漏。
一. 那么这种循环引用的问题我们如何解决呢?
①. 第一种解决办法
我们可能想如果我们将weak去弱化self,是不是就可以解决循环引用的问题了.
_weak typeof(self) weakSelf = self;
_timer = [NSTimer scheduledTimerWithTimeInterval:1.0f
target:weakSelf
selector:@selector(timerFire)
userInfo:nil
repeats:YES];
然而这并没有什么卵用，这里的 __weak 和 __strong 唯一的区别就是：如果在这两行代码执行的期间 self 被释放了， NSTimer 的 target 会变成 nil 。但是如果我们用blcok的形式去创建NSTimer就可以用对self的弱化来解决了.
②. 第二种解决办法
既然没办法通过 __weak 把 self 抽离出来，我们可以造个假的 target 给 NSTimer 。这个假的 target 类似于一个中间的代理人，它做的唯一的工作就是挺身而出接下了 NSTimer 的强引用。实现方式如下：
@interface MJProxy : NSObject
+ (instancetype)proxyWithTarget: (id)target;
@property (weak, nonatomic) id target;
@end
@implementation MJProxy
+ (instancetype)proxyWithTarget: (id)target{
MJProxy *proxy = [[MJProxy alloc] init];
proxy.target = target;
return proxy;
}
-(id)forwardingTargetForSelector:(SEL)aSelector{
return self.target;
}
@end
调用的时候是这样调用的
- (void)viewDidLoad {
[super viewDidLoad];
self.timer = [NSTimer scheduledTimerWithTimeInterval:1.0 target:[MJProxy proxyWithTarget:self] selector:@selector(timerTest) userInfo:nil repeats:YES];
}
- (void) timerTest{
NSLog(@"%s",__func__);
}
3. NSProxy
NSProxy是一个虚类.OC中类是不支持多继承的，要想实现多继承一般是有protocol的方式，还有一种就是利用NSProxy。有同学可能会问为什么不用NSObject来做？同样都是基类，都支持NSObject协议，NSProxy 有的NSObject 都有。但是点进NSProxy .h可以看见NSProxy没有init方法，而且NSProxy自身的方法很少，是一个很干净的类。这点很重要，因为NSObject自身的分类特别多，而消息转发的机制是当接收者无法处理时才会通过forwardInvocation:来寻求能够处理的对象.在日常使用时，我们很难避免不使用NSObject 的分类方法比如valueForKey这个方法NSObject就不会转发。
一. 多继承
虚基类本身就是为了解决继承问题而生，而OC的动态特性使得我们可以利用NSProxy做多继承：
首先我们新建两个基类如下：
@implementation classA
-(void)infoA{
NSLog(@"这里 是 classA");
}
@end
@implementation classB
-(void)infoB{
NSLog(@"这里 是 classB");
}
@end
classA和classB，但是分开买太麻烦，所以我找了一个代理如下:
@interface ClassProxy : NSProxy
@property(nonatomic,strong,readonly)NSMutableArray *targetArray;
-(void)target:(id)target;
-(void)handleTargets:(NSArray *)targets;
@end
NSProxy 必须以子类的形式出现。
因为考虑到很可能还有其他的类classC，classC也需要ClassProxy来代理，这边做了一个数组来存放需要代理的类.
@interface ClassProxy()
@property(nonatomic,strong)NSMutableArray *targetArray;//多个targets皆可代理
@property(nonatomic,strong)NSMutableDictionary *methodDic;
@property(nonatomic,strong)id target;
@end
然后target 和 相对应的method demo做了一个字典来存储，方便获取
-(void)registMethodWithTarget:(id)target{
unsigned int countOfMethods = 0;
Method *method_list = class_copyMethodList([target class], &countOfMethods);
for (int i = 0; i然后就是最主要的两个方法
-(void)forwardInvocation:(NSInvocation *)invocation{
SEL sel = invocation.selector;
NSString *methodName = NSStringFromSelector(sel);
id target = self.methodDic[methodName];
if (target) {
[invocation invokeWithTarget:target];
}
}
-(NSMethodSignature *)methodSignatureForSelector:(SEL)sel{
NSMethodSignature *Method;
NSString *methodName = NSStringFromSelector(sel);
id target = self.methodDic[methodName];
if (target) {
Method = [target methodSignatureForSelector:sel];
}else{
Method = [super methodSignatureForSelector:sel];
}
return Method;
}
methodSignatureForSelector:得到对应的方法签名，通过forwardInvocation：转发
下面看一下调用和打印结果:
[super viewDidLoad];
// [self analysis];
[self classInheritance];
// Do any additional setup after loading the view, typically from a nib.
}
//多继承
-(void)classInheritance{
classA *A = [[classA alloc]init];
classB *B = [[classB alloc]init];
ClassProxy *proxy = [ClassProxy alloc];
[proxy handleTargets:@[A,B]];
[proxy performSelector:@selector(infoA)];
[proxy performSelector:@selector(infoB)];
}
2018-12-27 18:02:34.445 NSProxyStudy[18975:4587631] 这里 是 classA
2018-12-27 18:02:34.446 NSProxyStudy[18975:4587631] 这里 是 classB
以上就是利用NSProxy 实现多继承。
二. 避免循环引用
这里举了比较常见了一个例子NSTimer,(注意:NSProxy是没有init方法).
由于目前苹果在iOS10以上，已经给出了timer 的block方式，已经可以解决循环引用的问题。所以demo举例只是说明利用NSProxy如何解决循环引用，大家在使用的时候可直接使用系统的方法。
首先因为NSTimer创建的时候需要传入一个target，并且持有它，而target本身也会持有timer所以会造成循环引用。所以我们将target 用NSProxy的子类代替如下:
@interface MJProxy : NSProxy
+ (instancetype)proxyWithTarget: (id)target;
@property (weak, nonatomic) id target;
@end
@implementation MJProxy
+ (instancetype)proxyWithTarget: (id)target{
MJProxy *proxy = [MJProxy alloc];
proxy.target = target;
return proxy;
}
-(NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector{
return [self.target methodSignatureForSelector:aSelector];
}
-(void)forwardInvocation:(NSInvocation *)anInvocation{
[anInvocation invokeWithTarget:self.target];
}
@end
- (void)viewDidLoad {
[super viewDidLoad];
self.timer = [NSTimer scheduledTimerWithTimeInterval:1.0 target:[MJProxy proxyWithTarget:self] selector:@selector(timerTest) userInfo:nil repeats:YES];
}
- (void) timerTest{
NSLog(@"%s",__func__);
}
三. AOP面向切片编程
iOS中面向切片编程一般有两种方式 ，一个是直接基于runtime 的method-Swizzling.还有一种就是基于NSProxy.
我们先创建一个子类AOPProxy:
typedef void(^proxyBlock)(id target,SEL selector);
NS_ASSUME_NONNULL_BEGIN
@interface AOPProxy : NSProxy
+(instancetype)proxyWithTarget:(id)target;
-(void)inspectSelector:(SEL)selector preSelTask:(proxyBlock)preTask endSelTask:(proxyBlock)endTask;
@end
-(void)inspectSelector:(SEL)selector preSelTask:(proxyBlock)preTask endSelTask:(proxyBlock)endTask;
第一个参数是需要hook的方法名字 后面两个分别是hook 该方法后 执行前需要执行的block 和 执行后的需要执行的block.
@interface AOPProxy ()
@property(nonatomic,strong)id target;
@property(nonatomic,strong)NSMutableDictionary *preSelTaskDic;
@property(nonatomic,strong)NSMutableDictionary *endSelTaskDic;
@end
然后创建两个字典，分别存放 不同selector 对应的执行block（可能一个target有好几个方法需要被hook）.
然后我们来看一下执行:
-(void)inspect{
NSMutableArray *targtArray = [AOPProxy proxyWithTarget:[NSMutableArray arrayWithCapacity:1]];
[(AOPProxy *)targtArray inspectSelector:@selector(addObject:) preSelTask:^(id target, SEL selector) {
[target addObject:@"-------"];
NSLog(@"%@我加进来之前",target);
} endSelTask:^(id target, SEL selector) {
[target addObject:@"-------"];
NSLog(@"%@我加进来之后",target);
}];
[targtArray addObject:@"我是一个元素"];
}
2018-12-28 11:57:05.590 NSProxyStudy[23812:4840464] (
"-------"
)我加进来之前
2018-12-28 11:57:05.591 NSProxyStudy[23812:4840464] (
"-------",
"\U6211\U662f\U4e00\U4e2a\U5143\U7d20",
"-------"
)我加进来之后
4. GCD定时器
GCD定时器实际上是使用了dispatch源(dispatch source)，dispatch源监听系统内核对象并处理。dispatch类似生产者消费者模式，通过监听系统内核对象，在生产者生产数据后自动通知相应的dispatch队列执行，后者充当消费者。通过系统级调用，更加精准。
NSTimer依赖于RunLoop，如果RunLoop的任务过于繁重，可能会导致NSTimer不准时,而GCD的定时器会更加准时.
GCD定时器的使用:
//队列创建
dispatch_queue_t queue = dispatch_get_main_queue();
//创建定时器
dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
//设置时间
NSTimeInterval start = 2.0;
NSTimeInterval interval = 1.0;
dispatch_source_set_timer(timer, DISPATCH_TIME_NOW, start * NSEC_PER_SEC, interval * NSEC_PER_SEC);
//设置回调
dispatch_source_set_event_handler(timer, ^{
NSLog(@"111");
});
//启动定时器
dispatch_resume(timer);
GCD的定时器写法相对比较固定，这里建议封装,封装之前先理一理思路（GCD定时器的封装必然依赖原有的写法，所以原有的一些关键性的参数必须保留）：
1、开始时间
2、时间间隔
3、是否需要重复执行
4、是否支持多线程
5、具体执行任务的函数或者block，其实这里两种都是可以的
6、取消定时任务
上述就是简单的思路，接下来先进行简单的封装：
@interface ZCGCDTimer : NSObject
+ (void)timerTask:(void(^)(void))task
start:(NSTimeInterval) start
interval:(NSTimeInterval) interval
repeats:(BOOL) repeats
async:(BOOL)async;
+(void)canelTimer;
@end
@implementation ZCGCDTimer
+ (void)timerTask:(void(^)(void))task
start:(NSTimeInterval) start
interval:(NSTimeInterval) interval
repeats:(BOOL) repeats
async:(BOOL)async{
/**
对参数做一些限制
1.如果task不存在，那就没有执行的必要（!task）
2.开始时间必须大于当前时间
3.当需要重复执行时，重复间隔时间必须 >0
以上条件必须满足，定时器才算是比较合理，否则没必要执行
*/
if (!task || start < 0 || (interval <= 0 && repeats)) {
return;
}
//if (!task || start < 0 || (interval <= 0 && repeats)) return; (上面的代码有人可能会写成这样，都一样，这是if的语法，里面只有一行时候可以省略{}，其他的没区别)
/**
队列
async：YES 全局队列 dispatch_get_global_queue(0, 0) 可以简单理解为其他线程(非主线程)
async：NO 主队列 dispatch_get_main_queue() 可以理解为主线程
*/
dispatch_queue_t queue = async ? dispatch_get_global_queue(0, 0) : dispatch_get_main_queue();
/**
创建定时器 dispatch_source_t timer
*/
dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
dispatch_source_set_timer(timer, dispatch_time(DISPATCH_TIME_NOW, start * NSEC_PER_SEC), interval * NSEC_PER_SEC, 0);
dispatch_source_set_event_handler(timer, ^{
//定时任务
task();
//如果不需要重复，执行一次即可
if (!repeats) {
dispatch_source_cancel(timer);
}
});
//启动定时器
dispatch_resume(timer);
}
+(void)canelTimer{
}
@end
当我们想取消定时器的时候会思考，多个定时器如何取消呢(很多时候可能会创建不止一个定时器)，得需要一个标准，或者说根据一个标记取到对应的定时器，这里我们根据key - value的形式进行完善上述定时器,具体如下：
进一步封装（这里关于load、initialize的选择抽时间再讲，必要的话专门开一篇细说）:
@interface ZCGCDTimer : NSObject
+ (NSString*)timerTask:(void(^)(void))task
start:(NSTimeInterval) start
interval:(NSTimeInterval) interval
repeats:(BOOL) repeats
async:(BOOL)async;
+(void)canelTimer:(NSString*) timerName;
@end
@implementation ZCGCDTimer
static NSMutableDictionary *timers_;
/**
load 与 initialize区别，这里选用initialize
*/
+(void)initialize{
//GCD一次性函数
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
timers_ = [NSMutableDictionary dictionary];
semaphore_ = dispatch_semaphore_create(1);
});
}
+ (NSString*)timerTask:(void(^)(void))task
start:(NSTimeInterval) start
interval:(NSTimeInterval) interval
repeats:(BOOL) repeats
async:(BOOL)async{
/**
对参数做一些限制
1.如果task不存在，那就没有执行的必要（!task）
2.开始时间必须大于当前时间
3.当需要重复执行时，重复间隔时间必须 >0
以上条件必须满足，定时器才算是比较合理，否则没必要执行
*/
if (!task || start < 0 || (interval <= 0 && repeats)) {
return nil;
}
//if (!task || start < 0 || (interval <= 0 && repeats)) return nil; (上面的代码有人可能会写成这样，都一样，这是if的语法，里面只有一行时候可以省略{}，其他的没区别)
/**
队列
async：YES 全局队列 dispatch_get_global_queue(0, 0) 可以简单理解为其他线程(非主线程)
async：NO 主队列 dispatch_get_main_queue() 可以理解为主线程
*/
dispatch_queue_t queue = async ? dispatch_get_global_queue(0, 0) : dispatch_get_main_queue();
/**
创建定时器 dispatch_source_t timer
*/
dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
// 定时器的唯一标识
NSString *timerName = [NSString stringWithFormat:@"%zd", timers_.count];
// 存放到字典中
timers_[timerName] = timer;
dispatch_source_set_timer(timer, dispatch_time(DISPATCH_TIME_NOW, start * NSEC_PER_SEC), interval * NSEC_PER_SEC, 0);
dispatch_source_set_event_handler(timer, ^{
//定时任务
task();
//如果不需要重复，执行一次即可
if (!repeats) {
[self canelTimer:timerName];
}
});
//启动定时器
dispatch_resume(timer);
return timerName;
}
+(void)canelTimer:(NSString*) timerName{
if (timerName.length == 0) {
return;
}
dispatch_source_t timer = timers_[timerName];
if (timer) {
dispatch_source_cancel(timer);
[timers_ removeObjectForKey:timerName];
}
}
@end
上面的代码涉及到对字典的存取，所以还需要考虑到线程安全(只需要在存值取值的时候进行处理)，因此，需要进一步完善代码，如下所示：
最终封装:
@interface ZCGCDTimer : NSObject
+ (NSString*)timerTask:(void(^)(void))task
start:(NSTimeInterval) start
interval:(NSTimeInterval) interval
repeats:(BOOL) repeats
async:(BOOL)async;
+(void)canelTimer:(NSString*) timerName;
@end
@implementation ZCGCDTimer
static NSMutableDictionary *timers_;
dispatch_semaphore_t semaphore_;
/**
load 与 initialize区别，这里选用initialize
*/
+(void)initialize{
//GCD一次性函数
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
timers_ = [NSMutableDictionary dictionary];
semaphore_ = dispatch_semaphore_create(1);
});
}
+ (NSString*)timerTask:(void(^)(void))task
start:(NSTimeInterval) start
interval:(NSTimeInterval) interval
repeats:(BOOL) repeats
async:(BOOL)async{
/**
对参数做一些限制
1.如果task不存在，那就没有执行的必要（!task）
2.开始时间必须大于当前时间
3.当需要重复执行时，重复间隔时间必须 >0
以上条件必须满足，定时器才算是比较合理，否则没必要执行
*/
if (!task || start < 0 || (interval <= 0 && repeats)) {
return nil;
}
//if (!task || start < 0 || (interval <= 0 && repeats)) return nil; (上面的代码有人可能会写成这样，都一样，这是if的语法，里面只有一行时候可以省略{}，其他的没区别)
/**
队列
async：YES 全局队列 dispatch_get_global_queue(0, 0) 可以简单理解为其他线程(非主线程)
async：NO 主队列 dispatch_get_main_queue() 可以理解为主线程
*/
dispatch_queue_t queue = async ? dispatch_get_global_queue(0, 0) : dispatch_get_main_queue();
/**
创建定时器 dispatch_source_t timer
*/
dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
dispatch_semaphore_wait(semaphore_, DISPATCH_TIME_FOREVER);
// 定时器的唯一标识
NSString *timerName = [NSString stringWithFormat:@"%zd", timers_.count];
// 存放到字典中
timers_[timerName] = timer;
dispatch_semaphore_signal(semaphore_);
dispatch_source_set_timer(timer, dispatch_time(DISPATCH_TIME_NOW, start * NSEC_PER_SEC), interval * NSEC_PER_SEC, 0);
dispatch_source_set_event_handler(timer, ^{
//定时任务
task();
//如果不需要重复，执行一次即可
if (!repeats) {
[self canelTimer:timerName];
}
});
//启动定时器
dispatch_resume(timer);
return timerName;
}
+(void)canelTimer:(NSString*) timerName{
if (timerName.length == 0) {
return;
}
dispatch_semaphore_wait(semaphore_, DISPATCH_TIME_FOREVER);
dispatch_source_t timer = timers_[timerName];
if (timer) {
dispatch_source_cancel(timer);
[timers_ removeObjectForKey:timerName];
}
dispatch_semaphore_signal(semaphore_);
}
@end
上面是以block的方式进行封装，当然了，也可以使用target的方式，相对比较简单，具体如下：
#import
@interface ZCGCDTimer : NSObject
/**
Block方式的定时器
@param task 任务（这里使用block）
@param start 开始时间
@param interval 间隔
@param repeats 时候否重复调用
@param async 是否子线程
@return 定时器标识（最终取消定时器是需要根据此标识取消的）
*/
+ (NSString*)timerTask:(void(^)(void))task
start:(NSTimeInterval) start
interval:(NSTimeInterval) interval
repeats:(BOOL) repeats
async:(BOOL)async;
/**
Target方式的定时器
@param target 目标对象（这里使用方法）
@param selector 调用方法
@param start 开始时间
@param interval 间隔
@param repeats 是否重复调用
@param async 是否子线程
@return 定时其标识（最终取消定时器是需要根据此标识取消的）
*/
+ (NSString*)timerTask:(id)target
selector:(SEL)selector
start:(NSTimeInterval)start
interval:(NSTimeInterval)interval
repeats:(BOOL)repeats
async:(BOOL)async;
/**
取消定时器
@param timerName 定时器标识
*/
+(void)canelTimer:(NSString*) timerName;
@end
#import "ZCGCDTimer.h"
@implementation ZCGCDTimer
static NSMutableDictionary *timers_;
dispatch_semaphore_t semaphore_;
/**
load 与 initialize区别，这里选用initialize
*/
+(void)initialize{
//GCD一次性函数
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
timers_ = [NSMutableDictionary dictionary];
semaphore_ = dispatch_semaphore_create(1);
});
}
+ (NSString*)timerTask:(void(^)(void))task
start:(NSTimeInterval) start
interval:(NSTimeInterval) interval
repeats:(BOOL) repeats
async:(BOOL)async{
/**
对参数做一些限制
1.如果task不存在，那就没有执行的必要（!task）
2.开始时间必须大于当前时间
3.当需要重复执行时，重复间隔时间必须 >0
以上条件必须满足，定时器才算是比较合理，否则没必要执行
*/
if (!task || start < 0 || (interval <= 0 && repeats)) {
return nil;
}
//if (!task || start < 0 || (interval <= 0 && repeats)) return nil; (上面的代码有人可能会写成这样，都一样，这是if的语法，里面只有一行时候可以省略{}，其他的没区别)
/**
队列
asyc：YES 全局队列 dispatch_get_global_queue(0, 0) 可以简单理解为其他线程(非主线程)
asyc：NO 主队列 dispatch_get_main_queue() 可以理解为主线程
*/
dispatch_queue_t queue = async ? dispatch_get_global_queue(0, 0) : dispatch_get_main_queue();
/**
创建定时器 dispatch_source_t timer
*/
dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
dispatch_semaphore_wait(semaphore_, DISPATCH_TIME_FOREVER);
// 定时器的唯一标识
NSString *timerName = [NSString stringWithFormat:@"%zd", timers_.count];
// 存放到字典中
timers_[timerName] = timer;
dispatch_semaphore_signal(semaphore_);
dispatch_source_set_timer(timer, dispatch_time(DISPATCH_TIME_NOW, start * NSEC_PER_SEC), interval * NSEC_PER_SEC, 0);
dispatch_source_set_event_handler(timer, ^{
//定时任务
task();
//如果不需要重复，执行一次即可
if (!repeats) {
[self canelTimer:timerName];
}
});
//启动定时器
dispatch_resume(timer);
return timerName;
}
+ (NSString*)timerTask:(id)target
selector:(SEL)selector
start:(NSTimeInterval)start
interval:(NSTimeInterval)interval
repeats:(BOOL)repeats
async:(BOOL)async{
if (!target || !selector) return nil;
return [self timerTask:^{
if ([target respondsToSelector:selector]) {
//（这是消除警告的处理）
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
[target performSelector:selector];
#pragma clang diagnostic pop
}
} start:start interval:interval repeats:repeats async:async];
}
+(void)canelTimer:(NSString*) timerName{
if (timerName.length == 0) {
return;
}
dispatch_semaphore_wait(semaphore_, DISPATCH_TIME_FOREVER);
dispatch_source_t timer = timers_[timerName];
if (timer) {
dispatch_source_cancel(timer);
[timers_ removeObjectForKey:timerName];
}
dispatch_semaphore_signal(semaphore_);
}
@end
block 样式
- (void)viewDidLoad {
[super viewDidLoad];
//这里async传值为YES，即在子线程
NSString* jcdTimer = [JCGCDTimer timerTask:^{
NSLog(@"%@", [NSThread currentThread]);
} start:1 interval:2 repeats:YES async:YES];
self.jcTimer = jcdTimer;
}
-(void)dealloc{
NSLog(@"%s", __func__);
[JCGCDTimer canelTimer:self.jcTimer];
}
target样式
- (void)viewDidLoad {
[super viewDidLoad];
//这里async传值为NO，即在主线程
NSString* jcdTimer = [JCGCDTimer timerTask:self selector:@selector(jcTimerAction) start:1 interval:2 repeats:YES async:NO];
self.jcTimer = jcdTimer;
}
-(void)jcTimerAction{
NSLog(@"%@", [NSThread currentThread]);
}
-(void)dealloc{
NSLog(@"%s", __func__);
[JCGCDTimer canelTimer:self.jcTimer];
}
想了解更多iOS学习知识请联系:QQ(814299221)