循环引用：
案例一：
A持有B
B持有A
如果A释放会发给B一个dealloc但是A要释放的前提是要B释放掉。这样就出现，就产生一个环。
例子：
self.name = "hello"
self.block = ^{
self.name="hello world"
}
解决：
self.name = "hello"
__weak typeof(self) weakSelf = self;
self.block = ^{
weakSelf.name="hello world"
}
另一种解决：
self.name = "hello"
//self -> block ->vc(nil)->self
__block ViewController *vc = self; //初始化一个临时变理的结构体
self.block = ^{
vc.name="hello world"
vc = nil;//这里自己手动释放掉，就打破循环
}
第三种解决：（这种性能最高）
self.name = "hello"
self.blockVc = ^(ViewController *vc){ //直接传参
vc.name="hello world"
}
self.blockVc(self)
上面只是一般解决：
但是遇到线程的时候 ,还是会有问题，要用strong-weak
self.name = "hello"
__weak typeof(self) weakSelf = self;
self.block = ^{
dispath_after(dispatch_time(DISPATCH_TIME_NOW,(int64_t)(2*NSEC_PER_SEC)),dispatch_getMain_queue(),^{
weakSelf.name="hello world" //这里weakself已经是nil了，所有会崩溃
});
}.
解决：
self.name = "hello"
__weak typeof(self) weakSelf = self;
self.block = ^{
__strong typeof(self) strongSelf=weakSelf; //这里只是个临时变量，只是暂时保留了self引用,出括号外还是会销掉，但是对于线程 运行完才销掉。就达到我们的目的了。
dispath_after(dispatch_time(DISPATCH_TIME_NOW,(int64_t)(2*NSEC_PER_SEC)),dispatch_getMain_queue(),^{
strongSelf.name="hello world" //这里weakself已经是nil了，所有会崩溃
});
}.
案例二：
NStimer的循环引用
self.timer = [NSTimer scheduledTimerWithInterval:1 target:self selector:@selector(hello) userInfo:nil repeats:YES];
-(void)dealloc:{
[self.timer invation];
self.timer =nil;
}
在这里是释放不了，timer会添加runloop
self -> runloop -> timer -> self
解决方案：
在退出视图的时候 我先把timer销掉，下次退出这个控制器的时候 (dealloc时就不用管)这个timer了
-(void didMoveTParentViewController:(UIViewController *) parent{
if(parent == nil){
[self.timer invation];
self.timer =nil;
}
}
第二方案：
引入第三者的变量去解决(self.target)
self.timer = [NSTimer scheduledTimerWithInterval:1 target:self.target selector:@selector(hello) userInfo:nil repeats:YES];
-(void)dealloc:{
[self.timer invation];
self.timer =nil;
}
现在模型变成
self->runloop->timer->self.target(第三者)
target创建一个类(TimerWapper)
实现vc需要的方法selector传进来，然后去调用
-(instancetype) initwithTimeInterval:(NStimeInterval)ti target:(id)target selector:(SEL)aselector userInfo:(nullable id)userInfo repeats:(BOOL)yesOrNo{
self.target = target;
self.selector = selector;
self.timer = [NSTimer scheduledTimeWithTimeInterval:ti target:self selector:@selector(action) userInfo:userInfo repeats:yesOrNo];
}
-(void)action{
if([self.target respondsToSelector:self.selector]){
[self.target performSelector:self.selector];
}
}
再写一个释放timer
-(void)timerInvalidate{ //这里可以手动释放
[self.timer invalidate];
self.timer = nil;
}
最后VC里改成
self -> timerWapper(这里相互持有,释放不了，但是我们留出timerInvalidate可以自己手动释放，在dealloc里释放掉，然后再释放掉TimerWapper)<-> timer <- runloop
self.target = [TimerWapper initwithTimeInterval:1 target:self selector:@selector(action) userInfo:nil repearts:YES];
-(void)dealloc:{
[self.target timerInvalidate]; //这里对timer释放，就不会持有timer了
}
第三种方案
利用timer的block方式,这种调用，系统自己优化过，就不会产生循环引用了
//在NSTimer里target就自己(NSTimer)这样就不会循环引用了,[https://www.jianshu.com/p/823ef4fb63bc](https://www.jianshu.com/p/823ef4fb63bc)
self.timer = [NSTimer scheduledTimerWithTimeInterval:1 repeats:YES block:^(NSTimer * _Nonnull timer){
}];
第四种方案(同样适用于 通知的循环引用)
利用代理Proxy与第二种类似
把target调用变成自己的Proxy
Proxy里面不用重写方法，直接 调用runtime的消息转发
+(instancetype)proxyWithTransformObject:(id)object{
Proxy *proxy = [Proxy alloc];
proxy.object=object;
return proxy;
}
//消息转发出去
-(NSMethodSignature *)methodSignatureForSelector:(SEL)sel{
return [self.object methodSignatureForSelector:sel];
}
-(void)forwardInvocation:(NSInvocation *)invocation{
[invocation invokeWithTarget:self.object];
}
最后VC改成
//self->timer<-runloop
// |
// proxy
self.proxy = [Proxy proxyWithTransformObject:self];
self.timer = [NSTimer scheduledTimerWithInterval:1 target:self.proxy selector:@selector(hello) userInfo:nil repeats:YES];
-(void)dealloc:{
[self.timer invation]; //这里断掉timer引用
self.timer =nil;
}
