本文主要是分析NSTimer 循环引用的原因及解决方案：
- NSTimer循环引用的原因；
- 苹果API接口解决方案；（iOS 10.0）
- NSProxy解决方案；
- Block解决方案；
一.NSTimer循环引用的案例：
1.对定时器SJTimer进行简单封装
//SJTimer.h文件
#import
@interface SJTimer : NSObject
//开启定时器
- (void)startTimer;
//暂停定时器
- (void)stopTimer;
@end
//SJTimer.m文件
#import "SJTimer.h"
@implementation SJTimer
{
NSTimer *_timer;
}
- (void)stopTimer{
if (_timer == nil) {
return;
}
[_timer invalidate];
_timer = nil;
}
- (void)startTimer{
_timer = [NSTimer scheduledTimerWithTimeInterval:1.0 target:self selector:@selector(work) userInfo:nil repeats:YES];
}
- (void)work{
NSLog(@"正在计时中。。。。。。");
}
- (void)dealloc{
NSLog(@"%@-----%s",NSStringFromClass([SJTimer class]),__func__);
[_timer invalidate];
}
@end
2.创建两个控制器A，B;由控制器A跳转到控制器B；在控制器B中创建一个定时器timer，点击开始按钮，开启定时器；点击返回按钮，则返回控制器A;
//控制器A的.m文件
#import "ViewController.h"
#import "SJSecondVC.h"
@interface ViewController ()
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
}
//跳转到控制器B
- (IBAction)jump:(UIButton *)sender {
SJSecondVC *secondVC = [[SJSecondVC alloc] init];
[self presentViewController:secondVC animated:YES completion:^{
}];
}
@end
//控制器B的.m文件
#import "SJSecondVC.h"
#import "SJTimer.h"
@interface SJSecondVC ()
@property (nonatomic, strong) SJTimer *timer;
@end
@implementation SJSecondVC
//开启定时器
- (IBAction)start:(id)sender {
SJTimer * timer = [[SJTimer alloc] init];
self.timer = timer;
[timer startTimer];
}
//返回控制器A
- (IBAction)back:(UIButton *)sender {
[self dismissViewControllerAnimated:YES completion:^{
}];
}
//控制器B销毁时，会自动调用该方法
- (void)dealloc{
NSLog(@"%@-----%s",NSStringFromClass([SJSecondVC class]),__func__);
}
- (void)viewDidLoad {
[super viewDidLoad];
// Do any additional setup after loading the view from its nib.
}
@end
3.运行程序，由控制器A跳转到控制器B,并开启定时器，然后返回到控制A,输出结果如下：
由输入结果可以看到，当返回到控制器A后，控制器B已经被销毁，但SJTimer的实例对象没有被销毁，计时器仍然在执行任务。这是什么原因呢？
二.NSTimer循环引用分析
下面的方法可以创建计时器，并将其预先安排到当前运行循环（Run Loop）当中：
+ (NSTimer *)scheduledTimerWithTimeInterval:(NSTimeInterval)ti target:(id)aTarget selector:(SEL)aSelector userInfo:(nullable id)userInfo repeats:(BOOL)yesOrNo;
参数target和selector表示计时器将在哪个对象上调用哪个方法，repeats表示是否重复执行任务。
计时器会保留其目标对象，等到自身“失效”时再释放此对象。
（1）当repeats设置为NO时，执行完相关任务之后，计时器会自动失效；
（2）当调用invalidate方法时，可以令计时器失效；
因此将计时器设置成重复模式时，很容易导致“循环引用”的问题，必须自己调用invalidate方法，才能停止计时器。
在上面的案例中，当我们在控制器B中创建SJTimer类的实例对象timer，并调用其startTimer方法时，由于NSTimer的目标对象是self，所以NSTimer要保留该实例timer。然而，因为计时器是用实例变量存放的，所以实例对象timer也保留了计时器。因此产生了“保留环”。
如果能在某一刻打破该保留环，则程序不会出问题。若要打破保留环，只能改变实例变量或令计时器无效。所以当调用stopTimer方法，或者令系统将实例对象timer回收时才能打破保留环。
但是在团队开发中，我们无法保证stopTimer一定会被调用，而且这种做法也不是一种很好的解决方案。另外，如果想在系统回收本类实例的过程中令计时器无效，从而打破保留环，又会陷入死结。因为在计时器对象有效时，SJTimer实例的自动计数器绝不会为0，因此系统也绝不会将其回收。此时，又没有调用invalidate方法，所以计时器将一直处于有效状态。
该情况如下图所示：
当指向SJTimer实例的最后一个外部引用被移走之后，该实例仍然继续存活。因为计时器还保留着它。而计时器对象也不可能被系统释放，因为实例中还有一个强引用正在指向它。于是，导致循环引用，内存就泄漏了。这种内存泄露问题尤为重要，因为计时器还将继续反复的执行轮训任务。倘若每次轮训时都要联网下载数据的话，那么程序会一直下载数据，这又更容易导致其他内存泄漏问题了。
NSTimer循环引用的原因到此分析完毕。下面来看看NSTimer循环引用的解决方案。
三.苹果API接口解决方案（iOS 10.0以上）
在iOS 10.0以后，苹果官方新增了关于NSTimer的三个API：
+ (NSTimer *)timerWithTimeInterval:(NSTimeInterval)interval repeats:(BOOL)repeats block:(void (^)(NSTimer *timer))block API_AVAILABLE(macosx(10.12), ios(10.0), watchos(3.0), tvos(10.0));
+ (NSTimer *)scheduledTimerWithTimeInterval:(NSTimeInterval)interval repeats:(BOOL)repeats block:(void (^)(NSTimer *timer))block API_AVAILABLE(macosx(10.12), ios(10.0), watchos(3.0), tvos(10.0));
- (instancetype)initWithFireDate:(NSDate *)date interval:(NSTimeInterval)interval repeats:(BOOL)repeats block:(void (^)(NSTimer *timer))block API_AVAILABLE(macosx(10.12), ios(10.0), watchos(3.0), tvos(10.0));
这三个方法都有一个Block的回调方法。关于block参数，官方文档有说明：
the timer itself is passed as the parameter to this block when executed to aid in avoiding cyclical references。
翻译过来就是说，定时器在执行时，将自身作为参数传递给block，来帮助避免循环引用。
使用很简单，就不再举例了，使用时注意两点：
- 避免block的循环引用（使用
__weak和__strong来避免）；- 在持用NSTimer对象的类的方法中
-(void)dealloc调用NSTimer 的- (void)invalidate方法；
四.NSProxy解决方案
实现原理图如下：
实现代码如下：
#import
NS_ASSUME_NONNULL_BEGIN
@interface MyProxy : NSProxy
- (instancetype)initWithObjc:(id)objc;
+ (instancetype)proxyWithObjc:(id)objc;
@end
NS_ASSUME_NONNULL_END
#import "MyProxy.h"
@interface MyProxy()
@property(nonatomic,weak) id objc;
@end
@implementation MyProxy
- (instancetype)initWithObjc:(id)objc{
self.objc = objc;
return self;
}
+ (instancetype)proxyWithObjc:(id)objc{
return [[self alloc] initWithObjc:objc];
}
- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector {
return [self.objc methodSignatureForSelector:aSelector];
}
- (void)forwardInvocation:(NSInvocation *)invocation {
if ([self.objc respondsToSelector:invocation.selector]) {
[invocation invokeWithTarget:self.objc];
}
}
@end
- (void)viewDidLoad {
[super viewDidLoad];
// Do any additional setup after loading the view from its nib.
_count = 0;
MyProxy *proxy = [[MyProxy alloc] initWithObjc:self];
_timer = [NSTimer timerWithTimeInterval:1 target:proxy selector:@selector(test_000) userInfo:nil repeats:YES];
[[NSRunLoop currentRunLoop] addTimer:_timer forMode:NSRunLoopCommonModes];
}
- (void)test_000{
NSLog(@"------%d",_count++);
}
-(void)dealloc{
NSLog(@"---dealloc----");
[_timer invalidate];
}
五.Block解决方案
从计时器本身入手，很难解决该问题，可以要求外界对象在释放最后一个指向本实例的引用之前，必须调用stopTimer方法。然而这种情况无法通过代码检测出来。此外，在团队开发中，我们无法保证其他开发人员一定会调用此方法。我们可以通过“Block”来解决该问题。
其代码如下：
//NSTimer+SJSafeTimer.h文件
#import
@interface NSTimer (SJSafeTimer)
+ (NSTimer *)SJ_ScheduledTimerWithTimeInterval:(NSTimeInterval)interval repeats:(BOOL)repeats block:(void(^)(void))block;
@end
//NSTimer+SJSafeTimer.m 文件
#import "NSTimer+SJSafeTimer.h"
@implementation NSTimer (SJSafeTimer)
+ (NSTimer *)SJ_ScheduledTimerWithTimeInterval:(NSTimeInterval)interval repeats:(BOOL)repeats block:(void(^)(void))block{
return [self scheduledTimerWithTimeInterval:interval target:self selector:@selector(handler:) userInfo:[block copy] repeats:repeats];
}
+ (void)handler:(NSTimer *)timer{
void (^block)(void) = timer.userInfo;
if (block) {
block();
}
}
@end
该方案是将计时器所应执行的任务封装成"Block"，在调用计时器函数时，把block作为userInfo参数传进去。userInfo参数用来存放"不透明值"，只要计时器有效，就会一直保留它。在传入参数时要通过copy方法，将block拷贝到"堆区"，否则等到稍后要执行它的时候，该blcok可能已经无效了。计时器现在的target是NSTimer类对象，这是个单例，因此计时器是否会保留它，其实都无所谓。此处依然有保留环，然而因为类对象（class object）无需回收，所以不用担心。
该方案本身不能解决问题，它只是提供了解决问题所需的工具。现在我们将使用新分类中的方法来创建计时器，将SJTimer中的方法startTimer修改如下：
- (void)startTimer{
_timer = [NSTimer SJ_ScheduledTimerWithTimeInterval:1.0 repeats:YES block:^{
[self work];
}];
}
这段代码，还是会有保留环。因为block捕获了self变量，所以block要保留实例。而计时器又通过userInfo参数保留了block。最后，实例对象本身还有保留计时器。我们要打破保留环，只需改用weak引用即可：
- (void)startTimer{
__weak SJTimer *weakSelf = self;
_timer = [NSTimer SJ_ScheduledTimerWithTimeInterval:1.0 repeats:YES block:^{
__strong SJTimer *strongSelf = weakSelf;
[strongSelf work];
}];
}
这里，我们先定义了一个弱引用，令其指向self，然后使block捕获这个弱引用，而不是直接捕获普通的self变量（即self不会被计时器所保留）。当block开始执行时，立刻生成strong引用，以保证实例对象在执行期间持续存活。
当外界指向SJTimer实例对象的最后一个引用将其释放，则该实例就会被系统回收。回收过程中还会调用计时器的invalidate方法，这样计时器就不会再继续执行任务了。
最后我们在控制器B中调用：
@interface SJSecondVC ()
@end
@implementation SJSecondVC
{
SJTimer *_timer;
}
//开启定时器
- (IBAction)start:(id)sender {
_timer = [[SJTimer alloc] init];
[_timer startPolling];
}
//返回控制器a
- (IBAction)back:(UIButton *)sender {
[self dismissViewControllerAnimated:YES completion:^{
}];
}
- (void)dealloc{
NSLog(@"%@-----%s",NSStringFromClass([SJSecondVC class]),__func__);
}
- (void)viewDidLoad {
[super viewDidLoad];
// Do any additional setup after loading the view from its nib.
}
- (void)didReceiveMemoryWarning {
[super didReceiveMemoryWarning];
// Dispose of any resources that can be recreated.
}
@end
其输入结果如下：
