用GCD来实现个Timer

##少用NSTimer

在iOS中开发中，定时器是经常用到的工具。一般情况下，我们都会去使用NSTimer这个类。然而，这个类一旦使用不当的话，会给我们造成很多无法预见的坑。

NSTimer有哪些坑，一个个来数一数

Timer必须作用在一个运行中的runloop

用过NSTimer的都知道，在创建了NSTimer之后，必须将NSTimer加入到runloop中。如果是在主线程的还好，因为主线程默认是有runLoop的（实际上一般很少会在主线程开timer）。如果是在子线程，那么就要手动激活runLoop先，不然就调用时无效的。

操作必须在同一个线程中

NSTimer的创建与撤销必须在同一个线程操作、performSelector的创建与撤销必须在同一个线程操作

内存泄漏

一般用NSTimer最容易出现的问题。首先来分析为什么会出现这个情况。

通常，我们创建一个NSTimer的方法是调用以下的API：

1
2
3
4
+ (NSTimer *)timerWithTimeInterval:(NSTimeInterval)ti target:(id)aTarget selector:(SEL)aSelector userInfo:(nullable id)userInfo repeats:(BOOL)yesOrNo;
+ (NSTimer *)scheduledTimerWithTimeInterval:(NSTimeInterval)ti target:(id)aTarget selector:(SEL)aSelector userInfo:(nullable id)userInfo repeats:(BOOL)yesOrNo;

- (instancetype)initWithFireDate:(NSDate *)date interval:(NSTimeInterval)ti target:(id)t selector:(SEL)s userInfo:(nullable id)ui repeats:(BOOL)rep NS_DESIGNATED_INITIALIZER;

这个时候，target会被timer持有，引用计数+1。

此时，如果直接销毁target，即使在target的deallco里面调用了[timer invaild]也无用。因为timer和target相关，因此必须提前调用[timer invaild]。这种BUG最常见的的就是一个UIViewControllerpop的时候，timer没有被invaild，结果UIViewController没有被销毁，导致了内存泄漏。

This method is the only way to remove a timer from an NSRunLoop object. The NSRunLoop object removes its strong reference to the timer, either just before the invalidate method returns or at some later point.

If it was configured with target and user info objects, the receiver removes its strong references to those objects as well.
You must send this message from the thread on which the timer was installed. If you send this message from another thread, the input source associated with the timer may not be removed from its run loop, which could prevent the thread from exiting properly.

注意到官方文档中提到，runLoop会持有NSTimer的引用，因此除了调用invaild方法外，没有别的方法.

##用GCD代替NSTimer

用过GCD的都说好，可以说把GCD玩的很溜的话，很多异步并行问题都能解决，在这里我们就要去解决NSTimer的坑的问题。这里用三个开源库来抛砖引玉，讲讲不同的实现由什么优缺点。

###RNTimer

这个库很老了，12年后就没有更新了，内容也很简单，只有两个文件，因为代码很少，直接上源码了

源码摘要

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

@interface RNTimer : NSObject

/**---------------------------------------------------------------------------------------
 @name Creating a Timer
 -----------------------------------------------------------------------------------------
*/

/** Creates and returns a new repeating RNTimer object and starts running it

 After `seconds` seconds have elapsed, the timer fires, executing the block.
 You will generally need to use a weakSelf pointer to avoid a retain loop.
 The timer is attached to the main GCD queue.

 @param seconds The number of seconds between firings of the timer. Must be greater than 0.
 @param block Block to execute. Must be non-nil

 @return A new RNTimer object, configured according to the specified parameters.
*/
+ (RNTimer *)repeatingTimerWithTimeInterval:(NSTimeInterval)seconds block:(dispatch_block_t)block;


/**---------------------------------------------------------------------------------------
 @name Firing a Timer
 -----------------------------------------------------------------------------------------
*/

/** Causes the block to be executed.

 This does not modify the timer. It will still fire on schedule.
*/
- (void)fire;


/**---------------------------------------------------------------------------------------
 @name Stopping a Timer
 -----------------------------------------------------------------------------------------
*/

/** Stops the receiver from ever firing again

 Once invalidated, a timer cannot be reused.

*/


@interface RNTimer ()
@property (nonatomic, readwrite, copy) dispatch_block_t block;
@property (nonatomic, readwrite, assign) dispatch_source_t source;
@end

@implementation RNTimer
@synthesize block = _block;
@synthesize source = _source;

+ (RNTimer *)repeatingTimerWithTimeInterval:(NSTimeInterval)seconds
																			block:(void (^)(void))block {
	NSParameterAssert(seconds);
	NSParameterAssert(block);

	RNTimer *timer = [[self alloc] init];
	timer.block = block;
	timer.source = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER,
																				0, 0,
																				dispatch_get_main_queue());
	uint64_t nsec = (uint64_t)(seconds * NSEC_PER_SEC);
	dispatch_source_set_timer(timer.source,
														dispatch_time(DISPATCH_TIME_NOW, nsec),
														nsec, 0);
	dispatch_source_set_event_handler(timer.source, block);
	dispatch_resume(timer.source);
	return timer;
}

- (void)invalidate {
	if (self.source) {
		dispatch_source_cancel(self.source);
		dispatch_release(self.source);
		self.source = nil;
	}
	self.block = nil;
}

- (void)dealloc {
	[self invalidate];
}

- (void)fire {
	self.block();
}

实现分析

实现很简单，用的是最基本的方法，即创建了一个dispatch_source_t，传入block，然后通过dispatch_source_set_timer将timer添加到dispatch_source，设置事件处理为传入的block,然后执行timer。

提供两个和NSTimer一样的方法，invalidate和fire。fire会立即执行block，但是不会使timer失效，依然会按照预定计划执行。

在API定义上，保持了和NSTimer一样的定义，所以切换起来没有压力。但是简单也以为这功能不完善。

  1. 无法暂停挂起timer
  2. 无法指定线程
  3. 无法添加新的任务到timer中

MSWeakTimer

MSWeakTimer的API设计成和NSTimer一样，调用的方法也一致，直接使用并没有什么副作用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

- (id)initWithTimeInterval:(NSTimeInterval)timeInterval
										target:(id)target
									selector:(SEL)selector
									userInfo:(id)userInfo
									 repeats:(BOOL)repeats
						 dispatchQueue:(dispatch_queue_t)dispatchQueue;
						 
						 /**
 * Creates an `MSWeakTimer` object and schedules it to start ticking inmediately.
 */
+ (instancetype)scheduledTimerWithTimeInterval:(NSTimeInterval)timeInterval
																				target:(id)target
																			selector:(SEL)selector
																			userInfo:(id)userInfo
																			 repeats:(BOOL)repeats
																 dispatchQueue:(dispatch_queue_t)dispatchQueue;
																 
																 /**
 * Starts the timer if it hadn't been schedule yet.
 * @warning calling this method on an already scheduled timer results in undefined behavior.
 */
- (void)schedule;

/**
 * Sets the amount of time after the scheduled fire date that the timer may fire to the given interval.
 * @discussion Setting a tolerance for a timer allows it to fire later than the scheduled fire date, improving the ability of the system to optimize for increased power savings and responsiveness. The timer may fire at any time between its scheduled fire date and the scheduled fire date plus the tolerance. The timer will not fire before the scheduled fire date. For repeating timers, the next fire date is calculated from the original fire date regardless of tolerance applied at individual fire times, to avoid drift. The default value is zero, which means no additional tolerance is applied. The system reserves the right to apply a small amount of tolerance to certain timers regardless of the value of this property.
 As the user of the timer, you will have the best idea of what an appropriate tolerance for a timer may be. A general rule of thumb, though, is to set the tolerance to at least 10% of the interval, for a repeating timer. Even a small amount of tolerance will have a significant positive impact on the power usage of your application. The system may put a maximum value of the tolerance.
 */
@property (atomic, assign) NSTimeInterval tolerance;

/**
 * Causes the timer to be fired synchronously manually on the queue from which you call this method.
 * You can use this method to fire a repeating timer without interrupting its regular firing schedule.
 * If the timer is non-repeating, it is automatically invalidated after firing, even if its scheduled fire date has not arrived.
 */
- (void)fire;

/**
 * You can call this method on repeatable timers in order to stop it from running and trying
 * to call the delegate method.
 * @note `MSWeakTimer` won't invoke the `selector` on `target` again after calling this method.
 * You can call this method from any queue, it doesn't have to be the queue from where you scheduled it.
 * Since it doesn't retain the delegate, unlike a regular `NSTimer`, your `dealloc` method will actually be called
 * and it's easier to place the `invalidate` call there, instead of figuring out a safe place to do it.
 */
- (void)invalidate;

- (id)userInfo;

实现

先来看初始化方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
- (id)initWithTimeInterval:(NSTimeInterval)timeInterval
										target:(id)target
									selector:(SEL)selector
									userInfo:(id)userInfo
									 repeats:(BOOL)repeats
						 dispatchQueue:(dispatch_queue_t)dispatchQueue
{
		NSParameterAssert(target);
		NSParameterAssert(selector);
		NSParameterAssert(dispatchQueue);

		if ((self = [super init]))
		{
				self.timeInterval = timeInterval;
				self.target = target;
				self.selector = selector;
				self.userInfo = userInfo;
				self.repeats = repeats;

				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);
		}

		return self;
}

将传入的参数复制给当前类的属性，然后初始化privateSerialQueue，privateSerialQueue的名称是privateQueueName，可变参数为当前对象的内存地址。调用dispatch_set_target_queue将传参的dispatchQueue优先级赋给privateSerialQueue。最后，初始化timer。

然后看执行函数

1
2
3
4
5
6
7
8
9
10
11
12
- (void)schedule
{
		[self resetTimerProperties];

		__weak MSWeakTimer *weakSelf = self;

		dispatch_source_set_event_handler(self.timer, ^{
				[weakSelf timerFired];
		});

		dispatch_resume(self.timer);
}

首先调用了resetTimerProperties

1
2
3
4
5
6
7
8
9
10
11
- (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
															);
}

resetTimerProperties重置timer。

intervalInNanoseconds和toleranceInNanoseconds

充当interval和leeway

在执行完resetTimerProperties后，dispatch_source_set_event_handler一个block到timer，执行timerFired：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
- (void)timerFired
{
		// Checking attomatically if the timer has already been invalidated.
		if (OSAtomicAnd32OrigBarrier(1, &_timerFlags.timerIsInvalidated))
		{
				return;
		}

		// We're not worried about this warning because the selector we're calling doesn't return a +1 object.
		#pragma clang diagnostic push
		#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
				[self.target performSelector:self.selector withObject:self];
		#pragma clang diagnostic pop

		if (!self.repeats)
		{
				[self invalidate];
		}
}

这里OSAtomicAnd32OrigBarrier是个值得关注的函数。

OSAtomicAnd32OrigBarrier是一个原子操作的布尔与运算，且带有内存屏障。OSAtomicAnd32OrigBarrier保证了在与操作之前数据结构的存储结构发生改变。

详细的只是可以参考下面这篇文章

http://southpeak.github.io/blog/2014/10/17/osatomicyuan-zi-cao-zuo/

在这里，_timerFlags.timerIsInvalidated与1做与操作，如果返回return 则返回，如果不是，执行.

这里如果不加入invalidate的话，恐怕说不清楚为什么这里要做这个判断

1
2
3
4
5
6
7
8
9
10
11
12
13
- (void)invalidate
{
		// We check with an atomic operation if it has already been invalidated. Ideally we would synchronize this on the private queue,
		// but since we can't know the context from which this method will be called, dispatch_sync might cause a deadlock.
		if (!OSAtomicTestAndSetBarrier(7, &_timerFlags.timerIsInvalidated))
		{
				dispatch_source_t timer = self.timer;
				dispatch_async(self.privateSerialQueue, ^{
						dispatch_source_cancel(timer);
						ms_release_gcd_object(timer);
				});
		}
}
1
if (!OSAtomicTestAndSetBarrier(7, &_timerFlags.timerIsInvalidated))

OSAtomicTestAndSetBarrier和OSAtomicAnd32OrigBarrier正好可以作为一个相对操作。

OSAtomicTestAndSetBarrier(7, &_timerFlags.timerIsInvalidated)会指定变量中的一个bit，把它设置为‘1’并返回旧值。如果要指定32bit integer最低位，n应该是7。因此如果第一次调用OSAtomicTestAndSetBarrier的话，返回false同时话将timerIsInvalidated置成1.由于原子操作和内存屏障，这个方法不会和OSAtomicAnd32OrigBarrier一同执行。如果执行到timerFired的时候，OSAtomicAnd32OrigBarrier(1, &_timerFlags.timerIsInvalidated)返回true，就会返回了。通过这个方法保证了在调用invalidate后将timer失效。

timerFired如果能执行，则通过performSelector来调用对用的SEL

在invalidate中，如果需要释放，需要调用dispatch_async。原因是我们虽然通过原子操作保证了invalidated，但是我们无法确定当前的上下文情况，使用dispatch_async可能会造成死锁。

主流程分析就是如此，MSWeakTimer最值得关注的就是上面讲解决线程同步的方法。

MSWeakTimer解决了前面提到的问题中无法添加指定线程（实际上也不是添加到那个线程，而是新开了一个线程）。由于模仿的是NSTimer的API，所以另外两个方法也没有解决。

我的实现 – ZXGCDTimer

在参考了上面的两个开源库后，自己动手撸了一个简单的基于GCD的Timer。基本解决了上面提到了三个问题。

代码地址：https://github.com/csbzhixing/ZXGCDTimer

思路是，通过ZXGCDTimerManager提供对外操作包括创建，执行，取消，挂起，回复功能。每个timer通过ZXGCDTimer为单位去管理，以timerName去区分不同的timer。支持自定义线程，支持新增Action。

由于是自己处于研究目的写的，可能存在各种问题，也欢迎大家提出批评和指正。

赏

谢谢你请我吃糖果

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br>谢谢大家