本文主要是分析NSTimer 循环引用的原因及解决方案：

1. NSTimer循环引用的原因；
2. 苹果API接口解决方案；（iOS 10.0）
3. NSProxy解决方案；
4. Block解决方案；

一.NSTimer循环引用的案例：

1.对定时器SJTimer进行简单封装

//SJTimer.h文件
#import <Foundation/Foundation.h>
@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,输出结果如下：

NSTimer_00.jpg

由输入结果可以看到，当返回到控制器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方法，所以计时器将一直处于有效状态。
该情况如下图所示：

NSTimer_01.png

当指向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，来帮助避免循环引用。
使用很简单，就不再举例了，使用时注意两点：

1. 避免block的循环引用（使用__weak和__strong来避免）；
2. 在持用NSTimer对象的类的方法中-(void)dealloc调用NSTimer 的- (void)invalidate方法；

四.NSProxy解决方案

timer_0.jpg

实现代码如下：

#import <Foundation/Foundation.h>

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 <Foundation/Foundation.h>
@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

其输入结果如下：

NSTimer_02.png