Block 底层原理（二）

2021-01-13 本文已影响0人 Jax_YD

一、block的循环引用

什么是循环引用？
对于高级开发人员来讲，如果对于循环引用，你知道到A持有B，B持有A。这样显然是不够的。下面我们就来讲一讲循环引用。
一个新创建的OC对象引用计数默认是1，当引用计数减为0，OC对象就会销毁，释放其占用的内存空间
调用retain会让OC对象的引用计数+1，调用release会让OC对象的引用计数-1
正常释放：是指A持有B的引用，当A调用dealloc方法时，给B发送release信号，B收到release信号进行release，接收到信号之后，如果此时B的retainCount(引用计数) 为0，则调用B的dealloc方法。
循环引用：A和B相互持有，导致的结果就是A无法调用自身的dealloc方法给B发送release信号，而B也无法收到release信号，进而无法调用自身的dealloc方法。所以A和B这种情况下都无法是释放。这就是循环引用。

image.png

二、循环引用的解决办法

解决block的循环引用有四种方法：
① weak-strong(注意：这里一定要把名字说全，单独说weak意思就变了)
② __block修饰对象(注意：在block内部需要 $\color{red}{置空对象}$ ，而且block $\color{red}{必须调用}$ )
③ 传递对象作为block的参数，提供给block内部使用
③ 使用NSProxy

方法一：weak-strong

如果block内部未嵌套block，则直接使用__weak修饰self就可以了：

#import "ViewController.h"

typedef void(^MyBlock)(void);

@interface ViewController ()

@property (nonatomic, assign) int age;
@property (nonatomic, copy) MyBlock myBlock;

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view.
    
    __weak typeof(self) weakSelf = self;
    self.myBlock = ^{
        weakSelf.age = 20;
    };
}


@end

此时，weakSelf和self指向同一片内存空间，而且使用__weak不会导致self的引用计数发生变化。

image.png

如果block内部嵌套了block，此时就需要__weak和__strong结合起来使用。

__weak typeof(self) weakSelf = self;
self.myBlock = ^{
    __strong typeof(self) strongSelf = weakSelf;
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)),
dispatch_get_main_queue(), ^{
        strongSelf.age = 20;
    });
};

其中strongSelf是一个临时变量，在myBlock的作用域内，临时持有weakSelf。在内部block执行完之后，释放strongSelf。
这里注意：weakSelf存放在弱引用表里面，随时有可能被释放掉，在block作用域内需要对weakSelf进行临时持有。 $\color{red}{这里的持有是在 block 的作用域内部的，对外部没有影响}$
这种方式属于打破self对block的强引用，依赖于中介者模式，属于自动置位nil，即自动释放。

方法二：__block修饰变量

这种方式同样依赖于中介者模式，属于手动释放，是通过__block修饰对象，主要是因为__block修饰的对象是可以改变的。(注：关于__block的详细分析可以查看Block 底层原理（一）)

__block ViewController *vc = self;
self.myBlock = ^{
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)),
dispatch_get_main_queue(), ^{
        vc.age = 20;
        vc = nil; ///手动释放
    });
};
self.myBlock();

注意：在这里myBlock $\color{red}{必须被调用}$ ，如果不调用myBlock，则vc就不会被置空，那么循环引用依然存在，self和block都不会被释放。

方法三：对象self作为参数，传入block

对象self作为参数，提供给block内部使用，不会有引用计数的问题。

typedef void(^MyBlock)(ViewController *);

/***********************************/
self.myBlock = ^(ViewController *vc){
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)),
dispatch_get_main_queue(), ^{
        vc.age = 20;
    });
};
self.myBlock(self);

NSProxy 虚拟类

OC是单继承的语言，但是它是基于运行时机制的动态语言，因此可以通过NSProxy来实现伪多继承，填补了多继承的空白。
NSProxy和NSObject是同一个级别的类，也可以说是一个虚拟类，只是实现了NSObject的协议。
NSProxy其实是一个消息重定向封装的抽象类，类似于一个代理人，中间件，可以通过继承它，并重写下面两个方法来实现消息转发到另一个实例。
使用场景
NSProxy的使用场景主要有两种
实现多继承功能
解决了NSTimer和CADisplyLink创建时对self的强引用问题。

NSProxy循环引用的原理
主要是通过自定义NSProxy类的对象来代替self,并使用方法类实现消息转发。

下面来实际操作一下：

自定义一个NSProxy的子类MyProxy

/************ MyProxy.h *********/
@interface MyProxy : NSProxy

- (id)transformObjc:(NSObject *)objc;
+ (instancetype)proxyWithObjc:(id)objc;

@end

/************ MyProxy.m *********/
@interface MyProxy ()

@property (nonatomic, weak, readonly) NSObject *objc;

@end

@implementation MyProxy

- (id)transformObjc:(NSObject *)objc {
    _objc = objc;
    return self;
}

+ (instancetype)proxyWithObjc:(id)objc {
    return [[self alloc] transformObjc:objc];
}

//1、查询该方法的方法签名
- (NSMethodSignature *)methodSignatureForSelector:(SEL)sel {
    NSMethodSignature *signature;
    if (self.objc) {
        signature = [self.objc methodSignatureForSelector:sel];
    } else {
        signature = [super methodSignatureForSelector:sel];
    }
    return  signature;
}

//2、有了方法签名之后就会调用方法的实现
- (void)forwardInvocation:(NSInvocation *)invocation {
    SEL sel = [invocation selector];
    if ([self.objc respondsToSelector:sel]) {
        [invocation invokeWithTarget:self.objc];
    }
}

///注意：此处为对象方法
- (BOOL)respondsToSelector:(SEL)aSelector {
    return [self.objc respondsToSelector:aSelector];
}

@end

自定义Fish和Bird类

/********** Fish 类 **********/
@interface Fish : NSObject
@end

@implementation Fish
- (void)swim {
    NSLog(@"鱼可以游泳");
}
@end

/********** Bird 类 **********/
@interface Bird : NSObject
@end

@implementation Bird
- (void)fly {
    NSLog(@"鸟可以飞翔");
}
@end

通过MyProxy实现多继承功能

- (void)proxyAction {
    Fish *fish = [[Fish alloc] init];
    Bird *bird = [[Bird alloc] init];
    MyProxy *proxy = [MyProxy alloc];
    
    [proxy transformObjc:fish];
    [proxy performSelector:@selector(swim)];
    
    [proxy transformObjc:bird];
    [proxy performSelector:@selector(fly)];
}

通过MyProxy解决定时器中self的强引用的问题

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