解决NSTimer循环引用

NSTimer常见用法

 @interface XXClass : NSObject
 - (void)start;
 - (void)stop;
 @end

 @implementation XXClass {
     NSTimer *timer;
 }

 - (id)init {
     return [super init];
 }

 - (void)dealloc {
     [timer]
 }

 - (void)stop {
     [timer invalidate];
     timer = nil;
 }

 - (void)start {
     timer = [NSTimerscheduledTimerWithTimeInterval:5.0
                                             target:self
                                           selector:selector(doSomething)
                                           userInfo:nil
                                            repeats:YES];
 }

 - (void)doSomething {
     //doSomething
 }

 @end

创建定时器的时候，由于目标对象是self，所以要保留此实例。然而，因为定时器是用实例变量存放的，所以实例也保留了定时器，这就造成了循环引用。除非调用stop方法，或者系统回收实例，才能打破循环引用，如果无法确保stop一定被调用，就极易造成内存泄露。

当指向XXClass实例的最后一个外部引用移走之后，该实例仍然会继续存活，因为定时器还保留着它。而定时器对象也不可能被系统释放，因为实例中还有一个强引用正在指向它。这种内存泄露是很严重的，如果定时器每次轮训都执行一些下载工作，常常会更容易导致其他内存泄露问题。

针对于此，有人想到利用block来避免这种循环应用。

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
 //调用
 - (void)start {
     __weak XXClass *weakSelf = self;
     timer = [NSTimer xx_scheduledTimerWithTimeInterval:.
                                                  block:^{
                                                  XXClass *strongSelf = weakSelf;
                                                  [strongSelf doSomething];
                                                         }
                                                repeats:YES];
 }

定时器现在的target是NSTimer类对象，这是个单例，此处依然有类对象的循环引用.下面介绍更好的解决方式weakProxy。

weakProxy解决循环引用

NSProxy

NSProxy本身是一个抽象类，它遵循NSObject协议，提供了消息转发的通用接口。NSProxy通常用来实现消息转发机制和惰性初始化资源。

使用NSProxy，你需要写一个子类继承它，然后需要实现init以及消息转发的相关方法。

 //当一个消息转发的动作NSInvocation到来的时候，在这里选择把消息转发给对应的实际处理对象
 - (void)forwardInvocation:(NSInvocation *)anInvocation

 //当一个SEL到来的时候，在这里返回SEL对应的NSMethodSignature
 - (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector

 //是否响应一个SEL
 + (BOOL)respondsToSelector:(SEL)aSelector

消息转发机制

消息转发涉及到三个核心方法

 //消息转发第一步，在这里可以动态的为类添加方法，这样类自己就能处理了
 ＋resolveInstanceMethod:
 //消息转发第二步，在第一步无法完成的情况下执行。这里只是把一个Selector简单的转发给另一个对象
 - forwardingTargetForSelector:
 //消息转发第三步，在第二步也无法完成的情况下执行。将整个消息封装成NSInvocation，传递下去
 - forwardInvocation:

消息转发机制使得代码变的很灵活：一个类本身可以完全不实现某些方法，它只要能转发就可以了。

WeakProxy来实现弱引用

@interface WeakProxy : NSProxy
@property (weak,nonatomic,readonly)id target;
+ (instancetype)proxyWithTarget:(id)target;
- (instancetype)initWithTarget:(id)target;
@end

@implementation WeakProxy
- (instancetype)initWithTarget:(id)target{
    _target = target;
    return self;
}
+ (instancetype)proxyWithTarget:(id)target{
    return [[self alloc] initWithTarget:target];
}
- (void)forwardInvocation:(NSInvocation *)invocation{
    SEL sel = [invocation selector];
    if ([self.target respondsToSelector:sel]) {
        [invocation invokeWithTarget:self.target];
    }
}
- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector{
    return [self.target methodSignatureForSelector:aSelector];
}
- (BOOL)respondsToSelector:(SEL)aSelector{
    return [self.target respondsToSelector:aSelector];
}
@end

外部创建Timer

  self.timer = [NSTimer timerWithTimeInterval:
                                         target:[WeakProxy proxyWithTarget:self]
                                       selector:@selector(timerInvoked:)
                                       userInfo:nil
                                        repeats:YES];

原理如下:

我们把虚线处变成了弱引用。于是，Controller就可以被释放掉，我们在Controller的dealloc中调用invalidate,就断掉了Runloop对Timer的引用，于是整个三个淡蓝色的就都被释放掉了。

Reference：

1.用Block解决NSTimer循环引用

2.NSProxy与消息转发机制