一、强引用问题分析

• 现在有两个控制器 A、B，从 A push 到 B 控制器，在 B 控制器中有如下代码：

	self.timer = [NSTimer timerWithTimeInterval:1 target:self selector:@selector(popHome) userInfo:nil repeats:YES];
	[[NSRunLoop currentRunLoop] addTimer:self.timer forMode:NSRunLoopCommonModes];

• 当从控制器 B pop 回到控制器 A 时，我们发现定时器没有停止，其 popHome 方法仍然在执行，这是为什么呢？
• 在控制器 B 的 dealloc 方法打上断点，可以看到程序并没有执行。因此可以得出，控制器 B 没有被释放，即控制器 B 没有执行 dealloc 方法，从而导致 timer 也无法停止运行和释放。
• 重写 didMoveToParentViewController 方法，可以看到：当控制器 B 退出到上层控制器的时候消除了引用，dealloc 方法被调用，timer 被销毁：

	- (void)didMoveToParentViewController:(UIViewController *)parent {
	    if (parent == nil) {
	       [self.timer invalidate];
	        self.timer = nil;
	        NSLog(@"timer 被释放");
	    }
	}

• 定义 timer 时，可以采用闭包的形式，不需要指定 target，就不会产生 timer 无法被释放的问题：

	- (void)blockTimer {
	    self.timer = [NSTimer scheduledTimerWithTimeInterval:1 repeats:YES block:^(NSTimer * _Nonnull timer) {
	        NSLog(@"timer fire - %@", timer);
	    }];
	}

• 经过上面的两种方式，都可以正常处理 timer 释放的问题，那么这又是为什么呢？
• 通过查看官方文档对 timerWithTimeInterval:target:selector:userInfo: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.
	timer强引用了target，直接对target所指向的内存地址强引用

• 从文档中描述可以看出，timer 对传入的 target 具有强持有，即 timer 持有 self，又由于 timer 是定义在控制器 B 中，所以 self 也持有 timer，因此 self -> timer -> self 构成了循环引用。
• 我们知道：循环引用可以通过 __weak 即弱引用来解决，那么我们代码修改如下：

	__weak typeof(self) weakSelf = self;
	self.timer = [NSTimer timerWithTimeInterval:1 target:weakSelf selector:@selector(popHome) userInfo:nil repeats:YES];
	[[NSRunLoop currentRunLoop] addTimer:self.timer forMode:NSRunLoopCommonModes];

• 再次运行程序，进行 push-pop 跳转，却发现问题还是存在，即定时器方法仍然在执行，并没有执行 B 的 dealloc 方法，这是为什么呢？
• 使用 __weak 虽然打破了 self -> timer -> self 之前的循环引用，即引用链变成了 self -> timer -> weakSelf -> self，但是我们遗漏了一个点，Runloop 对 timer 也强持有，因为 Runloop 的生命周期比控制器 B 更长，所以导致了 timer 无法被释放，同时也导致了控制器 B 的 self 也无法被释放。
• 没有添加 weakSelf 之前的引用链如下：

• 添加 weakSelf 之后的引用链变成了如下所示：

二、weakSelf 与 self

• 对于 weakSelf 和 self，我们关心的是：
• • weakSelf 会对引用计数进行 +1 操作吗？
• • weakSelf 和 self 的指针地址相同吗，是指向同一片内存吗？
• 在添加 weakSelf 前后打印 self 的引用计数：

	NSLog(@"%ld",CFGetRetainCount((__bridge CFTypeRef)self));
	__weak typeof(self) weakSelf = self;
	NSLog(@"%ld",CFGetRetainCount((__bridge CFTypeRef)self));

• 运行程序，可以看到前后 self 的引用计数都是 8，因此可以判定 weakSelf 没有对内存进行 +1 操作。
• 继续打印 weakSelf 和 self 对象，以及指针地址：

	po weakSelf
	<ViewController: 0x7fea4f024200>
	po self
	<ViewController: 0x7fea4f024200>
	
	p &self
	(ViewController **) $4 = 0x00000001085a5fc8
	p &weakSelf
	(ViewController *const *) $5 = 0x00007ffeeb06b648

• 可以看出，当前 self 取地址和 weakSelf 取地址的值是不一样的，意味着有两个指针地址，指向的是同一片内存空间，即 weakSelf 和 self 的内存地址是不一样，都指向同一片内存空间的。
• 此时 timer 捕获的是 <ViewController: 0x7fea4f024200>，是一个对象，所以无法通过 weakSelf 来解决强持有，即引用链关系为：NSRunLoop -> timer -> weakSelf（<ViewController: 0x7fea4f024200>），所以 RunLoop 对整个对象的空间强持有，runloop 没停，timer 和 weakSelf 就无法被释放。
• block 的循环引用，与 timer 的是有区别的，通过 block 底层原理的方法 __Block_object_assign 可知，block 捕获的是对象的指针地址，即 weakself 是临时变量的指针地址，与 self 无关，因为 weakSelf 是新的地址空间，所以此时的 weakSelf 相当于中间值，其引用关系链为 self -> block -> weakSelf（临时变量的指针地址），可以通过地址拿到指针。
• block 和 timer 循环引用的模型如下：
• • timer 模型：self -> timer -> weakSelf -> self，当前的 timer 捕获的是控制器 B 的内存，即 vc 对象的内存，即 weakSelf 表示的是 vc 对象；
• • Block 模型：self -> block -> weakSelf -> self，当前的 block 捕获的是指针地址，即 weakSelf 表示的是指向 self 的临时变量的指针地址。

三、强引用的解决方案

① 当 controller 界面 pop 到上层界面的消除引用

• 根据上文中的分析中，由于 Runloop 对 timer 的强持有，导致 Runloop 间接的强持有了self（因为 timer 中捕获的是 vc 对象），所以导致 dealloc 方法无法执行，需要查看在 pop 时，是否还有其他方法可以销毁 timer，这个方法就是 didMoveToParentViewController。
• didMoveToParentViewController 方法，是用于当一个视图控制器中添加或者移除 viewController 后，必须调用的方法，目的是为了告诉系统，已经完成添加/删除子控制器的操作。

	- (void)didMoveToParentViewController:(UIViewController *)parent {
	    if (parent == nil) {
	       [self.timer invalidate];
	        self.timer = nil;
	        NSLog(@"timer 被释放");
	    }
	}

② 中介者模式，不直接使用 self

• 在 timer 模式中，主要是 popHome 能执行，并不用管 timer 捕获的 target 是谁，由于这里不能使用self（因为会有强持有问题），所以可以将 target 换成其他对象，例如将 target 换成 NSObject 对象，将 popHome 交给 target 执行：

	// 定义其他对象
	@property (nonatomic, strong) id            target;
	
	// 修改target
	self.target = [[NSObject alloc] init];
	class_addMethod([NSObject class], @selector(popHome), (IMP)popHomeObjc, "v@:");
	self.timer = [NSTimer scheduledTimerWithTimeInterval:1 target:self.target selector:@selector(popHome) userInfo:nil repeats:YES];
	
	// imp
	void popHomeObjc(id obj){
	    NSLog(@"%s -- %@", __func__, obj);
	}

• 运行程序，发现程序执行 dealloc 之后，timer 还是会继续执行，这是因为虽然解决了中介者的释放，但是没有解决中介者的回收，即 self.target 的回收。
• 继续通过在 dealloc 方法中，取消定时器来解决，代码如下：

	- (void)dealloc{
	    [self.timer invalidate];
	    self.timer = nil;
	    NSLog(@"%s", __func__);
	}

• 再次运行程序如下，发现 pop 之后，timer 被释放，从而中介者也会进行回收释放。

③ 自定义封装 timer

• 自定义 timerWapper：
• • 在初始化方法中，定义一个 timer，其 target 是自己，即 timerWapper 中的 timer，一直监听自己，判断 selector，此时的 selector 已交给了传入的 target（即 vc 对象），此时有一个方法 popHomeWapper，在方法中，判断 target 是否存在；
• • • 如果 target 存在，则需要让 vc 知道，即向传入的 target 发送 selector 消息，并将此时的 timer 参数也一并传入，所以 vc 就可以得知 popHome 方法，就这事这种方式定时器方法能够执行的原因 ；
• • • 如果 target 不存在，已经释放了，则释放当前的 timerWrapper，即打破了 RunLoop 对 timeWrapper 的强持有 （timeWrapper <-×- RunLoop）；
• • 自定义 ydw_invalidate 方法中释放 timer，这个方法在 vc 的 dealloc 方法中调用，即 vc 释放，从而导致 timerWapper 释放，打破了 vc 对 timeWrapper 的强持有（ vc -×-> timeWrapper）；

	// .h文件
	@interface YDWTimerWapper : NSObject
	
	- (instancetype)ydw_initWithTimeInterval:(NSTimeInterval)ti target:(id)aTarget selector:(SEL)aSelector userInfo:(nullable id)userInfo repeats:(BOOL)yesOrNo;
	- (void)ydw_invalidate;
	
	@end
	
	// .m文件
	#import "YDWTimerWapper.h"
	#import <objc/message.h>
	
	@interface YDWTimerWapper ()
	
	@property(nonatomic, weak) id target;
	@property(nonatomic, assign) SEL aSelector;
	@property(nonatomic, strong) NSTimer *timer;
	
	@end
	
	@implementation YDWTimerWapper
	
	- (instancetype)ydw_initWithTimeInterval:(NSTimeInterval)ti target:(id)aTarget selector:(SEL)aSelector userInfo:(nullable id)userInfo repeats:(BOOL)yesOrNo {
	    if (self == [super init]) {
	        // 传入vc
	        self.target = aTarget;
	        // 传入的定时器方法
	        self.aSelector = aSelector;
	        
	        if ([self.target respondsToSelector:self.aSelector]) {
	            Method method = class_getInstanceMethod([self.target class], aSelector);
	            const char *type = method_getTypeEncoding(method);
	            // 给timerWapper添加方法
	            class_addMethod([self class], aSelector, (IMP)fireHomeWapper, type);
	            
	            // 启动一个timer，target是self，即监听自己
	            self.timer = [NSTimer scheduledTimerWithTimeInterval:ti target:self selector:aSelector userInfo:userInfo repeats:yesOrNo];
	        }
	    }
	    return self;
	}
	
	// 一直执行 runloop
	void fireHomeWapper(YDWTimerWapper *wapper){
	    // 判断target是否存在
	    if (wapper.target) {
	        // 如果存在则需要让vc知道，即向传入的target发送selector消息，并将此时的timer参数也一并传入，所以vc就可以得知`fireHome`方法，就这事这种方式定时器方法能够执行的原因
	        // objc_msgSend发送消息，执行定时器方法
	        void (*lg_msgSend)(void *,SEL, id) = (void *)objc_msgSend;
	         lg_msgSend((__bridge void *)(wapper.target), wapper.aSelector,wapper.timer);
	    } else {
	        // 如果target不存在，已经释放了，则释放当前的timerWrapper
	        [wapper.timer invalidate];
	        wapper.timer = nil;
	    }
	}
	
	// 在vc的dealloc方法中调用，通过vc释放，从而让timer释放
	- (void)ydw_invalidate {
	    [self.timer invalidate];
	    self.timer = nil;
	}
	
	- (void)dealloc {
	    NSLog(@"%s",__func__);
	}
	
	@end

• timerWapper 的使用：

	// 定义
	self.timerWapper = [[YDWTimerWapper alloc] cjl_initWithTimeInterval:1 target:self selector:@selector(popHome) userInfo:nil repeats:YES];
	
	// 释放
	- (void)dealloc {
	     [self.timerWapper ydw_invalidate];
	}

④ 利用 NSProxy 虚基类的子类

• 定义一个继承自 NSProxy 的子类：

	// NSProxy子类
	@interface YDWProxy : NSProxy
	+ (instancetype)proxyWithTransformObject:(id)object;
	@end
	
	@interface YDWProxy()
	@property (nonatomic, weak) id object;
	@end
	
	@implementation YDWProxy
	+ (instancetype)proxyWithTransformObject:(id)object{
	    YDWProxy *proxy = [YDWProxy alloc];
	    proxy.object = object;
	    return proxy;
	}
	- (id)forwardingTargetForSelector:(SEL)aSelector {
	    return self.object;
	}

• 将 timer 中的 target 传入 NSProxy 子类对象，即 timer 持有 NSProxy 子类对象：

	// 解决timer强持有问题
	self.proxy = [YDWProxy proxyWithTransformObject:self];
	self.timer = [NSTimer scheduledTimerWithTimeInterval:1 target:self.proxy selector:@selector(popHome) userInfo:nil repeats:YES];
	
	// 在dealloc中将timer正常释放
	- (void)dealloc {
	    [self.timer invalidate];
	    self.timer = nil;
	}

• 这样将强引用的注意力转移成了消息转发，虚基类只负责消息转发，即使用 NSProxy 作为中间代理和中间者。
• 那么定义的 proxy 对象，在 dealloc 释放时，还存在吗？其实，proxy 对象会正常被释放，因为 vc 被释放，所以可以释放其持有者，即 timer 和 proxy，timer 的释放也打破了 runLoop 对 proxy 的强持有，完美的达到了两层释放，即 vc -×-> proxy <-×- runloop。