iOS:计时器

~~~objective-c
+ (NSTimer *)scheduledTimerWithTimeInterval:(NSTimeInterval)ti target:(id)aTarget selector:(SEL)aSelector userInfo:(nullable id)userInfo repeats:(BOOL)yesOrNo;
~~~

~~~objective-c
+ (NSTimer *)timerWithTimeInterval:(NSTimeInterval)ti target:(id)aTarget selector:(SEL)aSelector userInfo:(nullable id)userInfo repeats:(BOOL)yesOrNo;
~~~

~~~objective-c
FOUNDATION_EXPORT NSRunLoopMode const NSDefaultRunLoopMode;
FOUNDATION_EXPORT NSRunLoopMode const NSRunLoopCommonModes NS_AVAILABLE(10_5, 2_0);
- (void)addTimer:(NSTimer *)timer forMode:(NSRunLoopMode)mode;
~~~

~~~objective-c
// 创建并执行新的线程
- (void)StartTimerThread {   
    NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(timerThread) object:nil];
    [thread start];
}
- (void)timerThread {
    @autoreleasepool {
        // 在当前Run Loop中添加timer，模式是默认的NSDefaultRunLoopMode
        _timer = [NSTimer scheduledTimerWithTimeInterval:2.0 target:self selector:@selector(timerCallback) userInfo:nil repeats:YES];
        // 开始执行新线程的Run Loop
        [[NSRunLoop currentRunLoop] run];
    }
}

// timer的关联方法
- (void)timerCallback {
    // 逻辑运算
  	// 执行完毕后主线程回调刷新UI
    [self performSelectorOnMainThread:@selector(refreshUI) withObject:nil waitUntilDone:false];
}
// 回调方法
- (void)refreshUI {
    /// 刷新UI
}

// timer的取消方法
- (void)cancelTimer {
    NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(timerCancelThread) object:nil];
    [thread start];
}
- (void)timerCancelThread {
    if (_timer) {
        [_timer invalidate];
        _timer = nil;
    }
}
~~~

~~~objective-c
int main(int argc, char * argv[]) {
    @autoreleasepool {
        return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class]));
    }
}
~~~

~~~objective-c
dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, dispatch_get_main_queue());
    dispatch_source_set_timer(timer, DISPATCH_TIME_NOW, 1 * NSEC_PER_SEC, 1 * NSEC_PER_SEC);
    dispatch_source_set_event_handler(timer, ^{
        //
    });
    dispatch_resume(timer);
~~~

~~~objective-c
// 创建一个队列
dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
// 根据队列创建timer
dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
// 首次执行时间
dispatch_time_t start = dispatch_time(DISPATCH_TIME_NOW, 0);
// 任务执行时间间隔
uint64_t interval = timeInterval * NSEC_PER_SEC;
// 允许的延迟（精确度）
uint64_t leeway = 0 * NSEC_PER_SEC;
// 设置timer的 首次执行时间， 任务执行时间间隔， 精确度
dispatch_source_set_timer(timer, start, interval, leeway);
// 设置timer的 执行任务事件
__weak typeof (self) weakSelf = self;
dispatch_source_set_event_handler(timer, ^{
    // action handle
    [weakSelf do];
});
// 启动timer
dispatch_resume(timer);
// 取消timer
dispatch_source_cancel(timer);
~~~

~~~objective-c
#import <Foundation/Foundation.h>
typedef NS_ENUM(NSUInteger, ActionOption) {
    PreviousActionCancel,//废除旧任务
    PreviousActionMerge,//合并新旧任务
};
@interface SeanTimer : NSObject
/**
 * method:sharedInstance.
 */
+ (instancetype)sharedInstance;
/**
 * method:create&start a timer based GCD.
 * Name:         名字标识;
 * TimeInterval: 计时器执行任务间隔;
 * Queue:        任务执行的线程(默认子线程);
 * Repeats:      是否重复;
 * Option:       相同标识timer任务执行模式,0废除旧任务(默认),1合并新旧任务;
 * Action:       timer关联SEL.
 * 合并新任务模式下暂不支持传参
 */
- (void)TimerWithName:(NSString *)name TimeInterval:(double)timeInterval Queue:(dispatch_queue_t)queue Repeats:(BOOL)repeats  Option:(ActionOption)option Target:(id)target Action:(SEL)action Object:(id)obj;
/**
 * method:cancelTimerWithName.
 */
- (void)cancelTimerWithName:(NSString *)name;
/**
 * method:cancel all timer.
 */
- (void)cancelAllTimer;
@end
~~~

~~~objective-c
#import "SeanTimer.h"
@interface SeanTimer ()
@property (strong , nonatomic) NSMutableDictionary * timerCache;
@property (strong , nonatomic) NSMutableDictionary * actionCache;
@end
~~~

~~~objective-c
#pragma mark - sharedInstance.
static SeanTimer * _instance = nil;
/**
 * method:sharedInstance.
 */
+ (instancetype)sharedInstance {
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        _instance = [[SeanTimer alloc] init];
    });
    return _instance;
}

#pragma mark - lazy loading.
/**
 * timer cache, timer缓存.
 */
- (NSMutableDictionary *)timerCache {
    if (!_timerCache) {
        _timerCache = [NSMutableDictionary dictionary];
    }
    return _timerCache;
}
/**
 * action cache, action缓存.
 */
- (NSMutableDictionary *)actionCache {
    if (!_actionCache) {
        _actionCache = [NSMutableDictionary dictionary];
    }
    return _actionCache;
}
~~~

~~~objective-c
#pragma mark - methods:public
/**
 * method:create&start a timer based GCD.
 * Name:         名字标识;
 * TimeInterval: 计时器执行任务间隔;
 * Queue:        任务执行的线程(默认子线程);
 * Repeats:      是否重复;
 * Option:       相同标识timer任务执行模式,0废除旧任务(默认),1合并新旧任务;
 * Action:       timer关联SEL.
 */
- (void)TimerWithName:(NSString *)name TimeInterval:(double)timeInterval Queue:(dispatch_queue_t)queue Repeats:(BOOL)repeats  Option:(ActionOption)option Target:(id)target Action:(SEL)action Object:(id)obj {
    if (!name)  return;
    if (!action) return;
    if (!target)  return;
    if (!queue) queue = dispatch_get_global_queue(0, 0);
  
    dispatch_source_t timer = self.timerCache[name];  
    if (!timer) {
        timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
        // timer cache
        [self.timerCache setObject:timer forKey:name];
    }
    dispatch_time_t start = dispatch_time(DISPATCH_TIME_NOW, 0);
    uint64_t interval = timeInterval * NSEC_PER_SEC;
    uint64_t leeway = 0 * NSEC_PER_SEC;
    dispatch_source_set_timer(timer, start, interval, leeway);
    
    __weak typeof (self) weakSelf = self;
    switch (option) {
        case PreviousActionMerge: // 合并之前的任务，下一轮一起执行
        {
            [self saveAction:action WithName:name];
            dispatch_source_set_event_handler(timer, ^{
                [weakSelf performActionsWithName:name Target:target];
                if (!repeats) {
                    [self cancelTimerWithName:name];
                }
            });
            break;
        }
        case PreviousActionCancel: // 取消之前的任务，下一次仅执行新任务
        {
            [self removeActionCacheWithName:name];
            dispatch_source_set_event_handler(timer, ^{
                [weakSelf performActionWithTarget:target Action:action Object:obj];
                if (!repeats) {
                    [self cancelTimerWithName:name];
                }
            });
            break;
        }
    }
    dispatch_resume(timer);
}
/**
 * method:cancelTimerWithName.
 */
- (void)cancelTimerWithName:(NSString *)name {
    dispatch_source_t timer = self.timerCache[name];
    if (!timer) return;
    dispatch_source_cancel(timer);
    [self.timerCache removeObjectForKey:name];
//    [self.actionCache removeObjectForKey:name];
}
/**
 * method:cancel all timer.
 */
- (void)cancelAllTimer {
    [self.timerCache enumerateKeysAndObjectsUsingBlock:^(NSString * name, dispatch_source_t timer, BOOL * _Nonnull stop) {
        [self.timerCache removeObjectForKey:name];
        dispatch_source_cancel(timer);
    }];
}

#pragma mark - methods:private.
/**
 * 根据timer名，将新的action加入缓存
 */
- (void)saveAction:(SEL)action WithName:(NSString *)name {
    NSString * actionString = NSStringFromSelector(action);
    id actionArray = self.actionCache[name];
    if (actionArray&&[actionArray isKindOfClass:[NSMutableArray class]]) {
        [(NSMutableArray *)actionArray addObject:actionString];
        return;
    }
    NSMutableArray * actionArrayNew = [[NSMutableArray alloc] initWithObjects:actionString, nil];
    [self.actionCache setObject:actionArrayNew forKey:name];
}
/**
 * 根据timer名，将之前的action移除缓存
 */
- (void)removeActionCacheWithName:(NSString *)name {
    if (!self.actionCache[name]) return;
    [self.actionCache removeObjectForKey:name];
}
- (void)performActionsWithName:(NSString *)name Target:(id)target {
//    [self removeActionCacheWithName:name];
    NSMutableArray * actionArray = self.actionCache[name];
    [actionArray enumerateObjectsUsingBlock:^(NSString * actionString, NSUInteger idx, BOOL * _Nonnull stop) {
        SEL aAction = NSSelectorFromString(actionString);
        IMP imp = [target methodForSelector:aAction];
        void (*func)(id, SEL , id) = (void *)imp;
        func(target, aAction , nil);
    }];
}
- (void)performActionWithTarget:(id)target Action:(SEL)action Object:(id)obj {
    IMP imp = [target methodForSelector:action];
    void (*func)(id, SEL , id) = (void *)imp;
    func(target, action , obj);
}
~~~

~~~objective-c
IMP imp = [target methodForSelector:action];
void (*func)(id, SEL , id) = (void *)imp;
func(target, action , obj);
~~~

~~~objective-c

#define TIMER_TEST @"Timer_Test"
@interface ViewController ()
{
    int index;
}
@property (weak, nonatomic) IBOutlet UILabel *label;
@end
~~~

~~~objective-c
- (void)viewDidLoad  {
    [super viewDidLoad];
//    [self timerTestWithActionOption:PreviousActionMerge];
    [self timerTestWithActionOption:PreviousActionCancel];
}

- (void)timerTestWithActionOption:(ActionOption)option {
    index = 0;
    [[SeanTimer sharedInstance] TimerWithName:TIMER_TEST TimeInterval:1.f Queue:dispatch_get_global_queue(0, 0) Repeats:true Option:option Target:self Action:@selector(action1) Object:nil];
  
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        [[SeanTimer sharedInstance] cancelTimerWithName:TIMER_TEST];
    });
    
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        [[SeanTimer sharedInstance] TimerWithName:TIMER_TEST TimeInterval:1.f Queue:dispatch_get_global_queue(0, 0) Repeats:true Option:option Target:self Action:@selector(action2) Object:nil];
    });
}
- (void)action1 {
    index += 1;
    dispatch_async(dispatch_get_main_queue(), ^{
        _label.text = [NSString stringWithFormat:@"%i", index];
    });
}
- (void)action2 
    dispatch_async(dispatch_get_main_queue(), ^{
        NSLog(@"%i", index);
    });
}
~~~

~~~objective-c
- (void)dealloc {
    [[SeanTimer sharedInstance] cancelTimerWithName:TIMER_TEST];
}
~~~