关于NSTimer-你真的了解么?

循环引用的问题
NXProxy
NSTimer准时么?
GCD定时器

循环引用的问题

关于这个问题我们先来看一段代码:

@interface ViewController ()
@property (nonatomic, weak) NSTimer *timer1;
@end

@implementation ViewController
- (void)test{
    NSLog(@"%s",__func__);
}
-(void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
{
    self.timer1 = [NSTimer scheduledTimerWithTimeInterval:1.0 target:self selector:@selector(test) userInfo:nil repeats:YES];
}

-(void)dealloc{
    [self.timer1 invalidate];
    NSLog(@"%s",__func__);
}
@end

有心的朋友应该注意到了timer1使用的是weak修饰符,所以ViewController并没有对timer1进行强引用

但是当我们点击导航栏的返回按钮的时候并没有调用该控制器的dealloc方法,为什么会这样呢?

timer使用熟悉的朋友应该都知道下面这段代码

  self.timer1 = [NSTimer scheduledTimerWithTimeInterval:1.0 target:self selector:@selector(test) userInfo:nil repeats:YES];

其实等价于:

    NSTimer *timer = [NSTimer timerWithTimeInterval:1.0 target:self selector:@selector(test) userInfo:nil repeats:YES];
    [[NSRunLoop currentRunLoop] addTimer:timer forMode:NSDefaultRunLoopMode];
    self.timer1 = timer;

为了确保定时器能够正常运转,当加入到RunLoop以后系统会对NSTimer执行一次retain操作.(关于RunLoop的知识感兴趣的朋友可以看看我的这篇文章:RunLoop的使用)
而在创建定时器的时候指定了targetself,这样一来 定时器对ViewController产生了一个强引用,所以此时 你中有我 我中有你 谁也不放过谁

解决方案

我们可以将target分离出来独立成一个对象,并且在该对象中声明一个weak修饰的target属性,该属性指向ViewController,结构大概如下图:

  1. 首先创建一个继承于 NSProxy类的对象 GSProxy:
#import <Foundation/Foundation.h>
@interface GSProxy : NSProxy
@property (nonatomic, weak) id target;
+ (instancetype) proxyWithTarget:(id)target;
@end
#import "GSProxy.h"
@implementation GSProxy
+(instancetype)proxyWithTarget:(id)target{
    GSProxy *proxy = [GSProxy alloc];
    proxy.target = target;
    return proxy;
}
//查询方法签名
-(NSMethodSignature *)methodSignatureForSelector:(SEL)sel{
    NSMethodSignature *signature = nil;
    if ([self.target methodSignatureForSelector:sel]) {
        signature = [self.target methodSignatureForSelector:sel];
    }
    else
    {
        signature = [super methodSignatureForSelector:sel];
    }
    return signature;
}
//有了方法签名之后就会调用方法实现
-(void)forwardInvocation:(NSInvocation *)invocation{
    [invocation invokeWithTarget:self.target];
}
@end

在使用定时器的时候将target替换成GSProxy即可:

    self.timer1 = [NSTimer scheduledTimerWithTimeInterval:1.0 target:[GSProxy proxyWithTarget:self] selector:@selector(test) userInfo:nil repeats:YES];

注意:
可能苹果也注意到了这个问题,所以iOS10 之后推出了一个替代方案,可以使用Block的方式来使用NSTimer了,这样就不会造成循环引用的问题了

 self.timer = [NSTimer scheduledTimerWithTimeInterval:1.0 repeats:YES block:^(NSTimer * _Nonnull timer) {
         NSLog(@"%s",__func__);
    }];

NXProxy

关于NSproxy这里我想多说两句.点击到NSproxy的实现我们可以看到如下结构:

@interface NSProxy <NSObject> {
    Class   isa;
}

是不是非常眼熟呢? 是的,他是和 NSObject对象处于同级的一个对象,但是它非常的轻量,其实他是苹果设计出来专门用于消息转发的,在这个小栗子中就可以看出该对象的强大之处

NSTimer准时么?

NSTimer不是一种实时机制,官方文档中有明确描述,如下图:

因为NSTimer是依赖于RunLoop而执行的,所以如果RunLoop在某一时刻的任务过于繁重,可能会导致NSTimer不准时.
当然在iOS7 之后苹果为我们新增了一个属性Tolerance,该属性表示当触发时间点到了之后,允许有多少最大误差.当然它只会在准确的触发时间之后加上Tolerance时间内触发,而不会提前触发,具体解释看下图:

GCD定时器

上面讲了这么多NSTimer的使用问题, 下面我们来讲讲这个高逼格的定时器,使用方法如下:


//需要强引用
@property (strong, nonatomic) dispatch_source_t timer;

.
.
.
    // 队列
    // dispatch_queue_t queue = dispatch_get_main_queue();
    dispatch_queue_t queue = dispatch_queue_create("timer", DISPATCH_QUEUE_SERIAL);
    
    // 创建定时器
    dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
    
    // 设置时间
    uint64_t start = 2.0; // 2秒后开始执行
    uint64_t interval = 1.0; // 每隔1秒执行
    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, ^{
    //        NSLog(@"1111");
    //    });
    
    //或者
    dispatch_source_set_event_handler_f(timer, 触发回调方法);
    // 启动定时器
    dispatch_resume(timer);    
    self.timer = timer;

为了使用方便,操作简单,我们对 GCD定时器做了一个简单的封装,代码如下:

#import <Foundation/Foundation.h>
@interface GSTimer : NSObject

+ (NSString *)execTask:(void(^)(void))task
           start:(NSTimeInterval)start
        interval:(NSTimeInterval)interval
         repeats:(BOOL)repeats
           async:(BOOL)async;

+ (NSString *)execTarget:(id)target
              selector:(SEL)selector
                 start:(NSTimeInterval)start
              interval:(NSTimeInterval)interval
               repeats:(BOOL)repeats
                 async:(BOOL)async;

+ (void)cancelTask:(NSString *)name;

@end
``


```objc
#import "GSTimer.h"

@implementation GSTimer

static NSMutableDictionary *timers_;
dispatch_semaphore_t semaphore_;
+ (void)initialize
{
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        timers_ = [NSMutableDictionary dictionary];
        semaphore_ = dispatch_semaphore_create(1);
    });
}

+ (NSString *)execTask:(void (^)(void))task start:(NSTimeInterval)start interval:(NSTimeInterval)interval repeats:(BOOL)repeats async:(BOOL)async
{
    if (!task || start < 0 || (interval <= 0 && repeats)) return nil;
    
    // 队列
    dispatch_queue_t queue = async ? dispatch_get_global_queue(0, 0) : dispatch_get_main_queue();
    
    // 创建定时器
    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_semaphore_wait(semaphore_, DISPATCH_TIME_FOREVER);
    // 定时器的唯一标识
    NSString *name = [NSString stringWithFormat:@"%zd", timers_.count];
    // 存放到字典中
    timers_[name] = timer;
    dispatch_semaphore_signal(semaphore_);
    
    // 设置回调
    dispatch_source_set_event_handler(timer, ^{
        task();
        
        if (!repeats) { // 不重复的任务
            [self cancelTask:name];
        }
    });
    
    // 启动定时器
    dispatch_resume(timer);
    
    return name;
}

+ (NSString *)execTask:(id)target selector:(SEL)selector start:(NSTimeInterval)start interval:(NSTimeInterval)interval repeats:(BOOL)repeats async:(BOOL)async
{
    if (!target || !selector) return nil;
    
    return [self execTask:^{
        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)cancelTask:(NSString *)name
{
    if (name.length == 0) return;
    
    dispatch_semaphore_wait(semaphore_, DISPATCH_TIME_FOREVER);
    
    dispatch_source_t timer = timers_[name];
    if (timer) {
        dispatch_source_cancel(timer);
        [timers_ removeObjectForKey:name];
    }

    dispatch_semaphore_signal(semaphore_);
}
@end

使用的时候我们只需要:

- (void)viewDidLoad {
    [super viewDidLoad];
    self.task = [GSTimer execTarget:self
                         selector:@selector(doTask)
                            start:2.0
                         interval:1.0
                          repeats:YES
                            async:NO];
    
    //或者
//    self.task = [GSTimer execTask:^{
//        NSLog(@"111111 - %@", [NSThread currentThread]);
//    } start:2.0 interval:0 repeats:NO async:NO];
}

- (void)doTask
{
    NSLog(@"doTask - %@", [NSThread currentThread]);
}

是不是方便了很多....

因为GCD的定时器不需要依赖RunLoop,而且没有循环引用的问题,准确度更高 所以推荐使用GCD定时器

推荐阅读更多精彩内容