如下代码所示,是我们最常见的使用timer的方式
@property (nonatomic , strong) NSTimer *animationTimer;
self.animationTimer = [NSTimer scheduledTimerWithTimeInterval:(self.animationDuration = animationDuration)
target:self
selector:@selector(animationTimerDidFired:)
userInfo:nil
repeats:YES];
当使用NSTimer的scheduledTimerWithTimeInterval方法时。事实上此时Timer会被加入到当前线程的Run Loop中，且模式是默认的NSDefaultRunLoopMode。而如果当前线程就是主线程，也就是UI线程时，某些UI事件，比如UIScrollView的拖动操作，会将Run Loop切换成NSEventTrackingRunLoopMode模式，在这个过程中，默认的NSDefaultRunLoopMode模式中注册的事件是不会被执行的。也就是说，此时使用scheduledTimerWithTimeInterval添加到Run Loop中的Timer就不会执行
我们可以通过添加一个UICollectionView,然后滑动它后打印定时器方法
2016-01-27 11:41:59.770 TimerAbout[89719:1419729] enter timer 2016-01-27 11:42:00.339 TimerAbout[89719:1419729] enter timer 2016-01-27 11:42:01.338 TimerAbout[89719:1419729] enter timer 2016-01-27 11:42:02.338 TimerAbout[89719:1419729] enter timer 2016-01-27 11:42:03.338 TimerAbout[89719:1419729] enter timer 2016-01-27 11:42:15.150 TimerAbout[89719:1419729] enter timer 2016-01-27 11:42:15.338 TimerAbout[89719:1419729] enter timer
从中可以看到,当UICollectionView滑动时候,定时器方法并没有打印(从03.338到15.150)
为了设置一个不被UI干扰的Timer，我们需要手动创建一个Timer，然后使用NSRunLoop的addTimer:forMode:方法来把Timer按照指定模式加入到Run Loop中。这里使用的模式是：NSRunLoopCommonModes，这个模式等效于NSDefaultRunLoopMode和NSEventTrackingRunLoopMode的结合,官方参考文档
还是上面的例子,换为
| | self.animationTimer = [NSTimer timerWithTimeInterval:1 target:self selector:@selector(animationTimerDidFired:) userInfo:nil repeats:YES]; [[NSRunLoop mainRunLoop] addTimer:self.animationTimer forMode:NSRunLoopCommonModes]; |
则,无论你滑动不滑动UICollectionView,定时器都是起作用的!!
上面的NSTimer无论采用何种方式,都是在主线程上跑的,那么怎么在非主线程中跑一个NSTimer呢?
我们简单的可以使用如下代码
| | //创建并执行新的线程
NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(newThread) object:nil];
[thread start];
- (void)newThread {
@autoreleasepool {
//在当前Run Loop中添加timer，模式是默认的NSDefaultRunLoopMode
[NSTimer scheduledTimerWithTimeInterval:1.0 target:self selector:@selector(animationTimerDidFired:) userInfo:nil repeats:YES];
//开始执行新线程的Run Loop
[[NSRunLoop currentRunLoop] run];
}
} |
当然了,因为是开启的新的线程,在定时器的回调方法中,需要切换到主线程才能操作UI额
GCD的方式
| | //GCD方式
uint64_t interval = 1 * NSEC_PER_SEC;
//创建一个专门执行timer回调的GCD队列
dispatch_queue_t queue = dispatch_queue_create("timerQueue", 0);
_timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
//使用dispatch_source_set_timer函数设置timer参数
dispatch_source_set_timer(_timer, dispatch_time(DISPATCH_TIME_NOW, 0), interval, 0);
//设置回调
dispatch_source_set_event_handler(_timer, ^(){
NSLog(@"Timer %@", [NSThread currentThread]);
});
dispatch_resume(_timer);
//dispatch_source默认是Suspended状态，通过dispatch_resume函数开始它 |
其中的dispatch_source_set_timer的最后一个参数,是最后一个参数（leeway），他告诉系统我们需要计时器触发的精准程度。所有的计时器都不会保证100%精准，这个参数用来告诉系统你希望系统保证精准的努力程度。如果你希望一个计时器每5秒触发一次，并且越准越好，那么你传递0为参数。另外，如果是一个周期性任务，比如检查email，那么你会希望每10分钟检查一次，但是不用那么精准。所以你可以传入60，告诉系统60秒的误差是可接受的。他的意义在于降低资源消耗。
一次性的timer方式的GCD模式
| | dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
NSLog(@"dispatch_after enter timer");
}); |
另一种dispatch_after方式的定时器
这个是使用上面的dispatch_after来创建的,通过递归调用来实现
| | - (void)dispatechAfterStyle {
__weak typeof (self) wself = self;
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
NSLog(@"dispatch_after enter timer,thread = %@", [NSThread currentThread]);
[wself dispatechAfterStyle];
});
} |
利用GCD的弱引用型的timer
MSWeaker 实现了一个利用GCD的弱引用的timer
原理是利用一个新的对象,在这个对象中
| | NSString *privateQueueName = [NSString stringWithFormat:@"com.mindsnacks.msweaktimer.%p", self];
self.privateSerialQueue = dispatch_queue_create([privateQueueName cStringUsingEncoding:NSASCIIStringEncoding], DISPATCH_QUEUE_SERIAL);
dispatch_set_target_queue(self.privateSerialQueue, dispatchQueue);
self.timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, self.privateSerialQueue);
- (void)resetTimerProperties{
int64_t intervalInNanoseconds = (int64_t)(self.timeInterval * NSEC_PER_SEC);
int64_t toleranceInNanoseconds = (int64_t)(self.tolerance * NSEC_PER_SEC);
dispatch_source_set_timer(self.timer, dispatch_time(DISPATCH_TIME_NOW, intervalInNanoseconds), (uint64_t)intervalInNanoseconds, toleranceInNanoseconds);}
- (void)schedule{
[self resetTimerProperties];
__weak MSWeakTimer *weakSelf = self;
dispatch_source_set_event_handler(self.timer, ^{
[weakSelf timerFired];
});
dispatch_resume(self.timer);
} |
创建了一个队列self.timer = dispatch_source_create,然后在这个队列中创建timer dispatch_source_set_timer
注意其中用到了dispatch_set_target_queue(self.privateSerialQueue, dispatchQueue); 这个是将dispatch队列的执行操作放到队列dispatchQueue 中去
这份代码中还用到了原子操作!!!值得好好研读,以便以后可以在自己的多线程设计中使用原子操作
为什么用原子操作呢,因为作者想的是在多线程的环境下设置定时器的开关与否
| | if (OSAtomicAnd32OrigBarrier(1, &_timerFlags.timerIsInvalidated))
if (!OSAtomicTestAndSet(7, &_timerFlags.timerIsInvalidated)) {
dispatch_source_t timer = self.timer;
dispatch_async(self.privateSerialQueue, ^{
dispatch_source_cancel(timer); ms_release_gcd_object(timer); });
} |
至于其中
| | struct { uint32_t timerIsInvalidated; } _timerFlags; |
这里为什么要用结构体呢?为什么不直接使用一个uint32_t 的变量???
使用NSTimer方式创建的Timer,使用时候需要注意
由于
| | self.animationTimer = [NSTimer scheduledTimerWithTimeInterval:1 target:self selector:@selector(animationTimerDidFired:) userInfo:nil repeats:YES]; |
会导致timer 强引用 self,而animationTimer又是self的一个强引用,这造成了强引用的循环了
如果不手工停止timer,那么self这个VC将不能够被释放,尤其是当我们这个VC是push进来的时候,pop将不会被释放!!!
怎么解决呢??
当然了,可以采用上文提到的MSWeakerGCD的弱引用的timer
可是如果有时候,我们不想使用它,觉得它有点复杂呢?
-
在VC的disappear方法中应该调用 invalidate方法,将定时器释放掉,这里可能有人要说了,我直接在vc的dealloc中释放不行么
-(void)dealloc { [_animationTimer invalidate]; }很遗憾的告诉你,都已经循环引用了,vc压根就释放不了,怎么调dealloc方法!!
-
在vc的disappear方法中
-(void)viewWillDisappear:(BOOL)animated { [super viewWillDisappear:animated]; [_animationTimer invalidate]; }这样的确能解决问题,可是不一定是我们想要的呀,当我们vc 再push了一个新的页面的时候,本身vc没有释放,按理说,其成员timer不应该被释放呀,你可能会说,那还不容易,在appear方法中再重新生成一下呗….但是这样的话,又要增加一个变量,标识定时器在上一次disappear时候是不是启动了吧,是启动了,被invaliate的时候,才能在appear中重新启动吧.这样,是不是觉得很麻烦!!
-
你可能会说,那简单啊,直接若引用就可以了想想我们使用block的时候
@property (nonatomic, copy) void (^ myblock)(NSInteger i); __weak typeof (self) weakSelf = self; self.myblock = ^(NSInteger i){ [weakSelf view]; };在其中,我们需要在block中引用self,如果直接引用,也是循环引用了,采用先定义一个weak变量,然后在block中引用weak对象,避免循环引用 你会直接想到如下的方式
__weak typeof (self) wself = self; self.animationTimer = [NSTimer scheduledTimerWithTimeInterval:1 target:wself selector:@selector(animationTimerDidFired:) userInfo:nil repeats:YES];
是不是瞬间觉得完美了,呵呵,我只能说少年,你没理解两者之间的区别.在block中,block是对变量进行捕获,意思是对使用到的变量进行拷贝操作,注意是拷贝的不是对象,而是变量自身,拿上面的来说,block中只是对变量wself拷贝了一份,也就是说,block中也定义了一个weak对象,相当于,在block的内存区域中,定义了一个__weak blockWeak对象,然后执行了blockWeak = wself;注意到了没,这里并没有引起对象的持有量的变化,所以没有问题,再看timer的方式,虽然你是将wself传入了timer的构造方法中,我们可以查看NSTimer的
+ (NSTimer *)timerWithTimeInterval:(NSTimeInterval)seconds target:(id)target selector:(SEL)aSelector userInfo:(id)userInfo repeats:(BOOL)repeats
定义,其target的说明The object to which to send the message specified by aSelector when the timer fires. The timer maintains a strong reference to this object until it (the timer) is invalidated,是要强应用这个变量的 也就是说,大概是这样的,
__strong strongSelf = wself强引用了一个弱应用的变量,结果还是强引用,也就是说strongSelf持有了wself所指向的对象(也即是self所只有的对象),这和你直接传self进来是一样的效果,并不能达到解除强引用的作用!! 看来只能换个思路了,我直接生成一个临时对象,让Timer强用用这个临时对象,在这个临时对象中弱引用self,可以了吧. -
考虑引入一个对象,在这个对象中弱引用self,然后将这个对象传递给timer的构建方法 这里可以参考YYWeakProxy建立这个对象
@interface YYWeakProxy : NSProxy @property (nonatomic, weak, readonly) id target; -(instancetype)initWithTarget:(id)target; +(instancetype)proxyWithTarget:(id)target; @end @implementation YYWeakProxy -(instancetype)initWithTarget:(id)target { _target = target; return self; } +(instancetype)proxyWithTarget:(id)target { return [[YYWeakProxy alloc] initWithTarget:target]; } //当不能识别方法时候,就会调用这个方法,在这个方法中,我们可以将不能识别的传递给其它对象处理//由于这里对所有的不能处理的都传递给_target了,所以methodSignatureForSelector和forwardInvocation不可能被执行的,所以不用再重载了吧//其实还是需要重载methodSignatureForSelector和forwardInvocation的,为什么呢?因为_target是弱引用的,所以当_target可能释放了,当它被释放了的情况下,那么forwardingTargetForSelector就是返回nil了.然后methodSignatureForSelector和forwardInvocation没实现的话,就直接crash了!!! //这也是为什么这两个方法中随便写的!!! -(id)forwardingTargetForSelector:(SEL)selector { return _target; } -(void)forwardInvocation:(NSInvocation *)invocation { void *null = NULL; [invocation setReturnValue:&null]; } -(NSMethodSignature *)methodSignatureForSelector:(SEL)selector { return [NSObject instanceMethodSignatureForSelector:@selector(init)];} -(BOOL)respondsToSelector:(SEL)aSelector { return [_target respondsToSelector:aSelector];} -(BOOL)isEqual:(id)object { return [_target isEqual:object]; } -(NSUInteger)hash { return [_target hash]; } -(Class)superclass { return [_target superclass]; } -(Class)class { return [_target class];} -(BOOL)isKindOfClass:(Class)aClass { return [_target isKindOfClass:aClass]; } -(BOOL)isMemberOfClass:(Class)aClass { return [_target isMemberOfClass:aClass]; } -(BOOL)conformsToProtocol:(Protocol *)aProtocol { return [_target conformsToProtocol:aProtocol];} -(BOOL)isProxy { return YES; } -(NSString *)description { return [_target description]; } -(NSString *)debugDescription { return [_target debugDescription]; } @end使用的时候,将原来的替换为
self.animationTimer = [NSTimer scheduledTimerWithTimeInterval:1 target:[YYWeakProxy proxyWithTarget:self ] selector:@selector(animationTimerDidFired:) userInfo:nil repeats:YES];
-
block方式来解决循环引用
@interface NSTimer (XXBlocksSupport) +(NSTimer *)xx_scheduledTimerWithTimeInterval:(NSTimeInterval)interval block:(void(^)())block repeats:(BOOL)repeats; @end @implementation NSTimer (XXBlocksSupport) +(NSTimer *)xx_scheduledTimerWithTimeInterval:(NSTimeInterval)interval block:(void(^)())block repeats:(BOOL)repeats{ return [self scheduledTimerWithTimeInterval:interval target:self selector:@selector(xx_blockInvoke:) userInfo:[block copy] repeats:repeats];} +(void)xx_blockInvoke:(NSTimer *)timer { void (^block)() = timer.userinfo; if(block) { block(); } } @end注意以上NSTimer的target是NSTimer类对象,类对象本身是个单利,此处虽然也是循环引用,但是由于类对象不需要回收,所以没有问题.但是这种方式要注意block的间接循环引用,当然了,解决block的间接循环引用很简单,定义一个weak变量,在block中使用weak变量即可
扫一扫
313
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
