【iOS底层探索- Block原理分析-循环引用】

文章目录

  • 前言
  • 准备工作
  • 1. Block的分类
  • 2. Block的内存分析
    • 捕获外部变量引用计数的变化
    • 堆栈释放的差异
    • 总结
  • 3. Block的循环引用
    • 3.1 什么是循环引用?
      • 案例引入
    • 循环引用解决方法
      • 1. 强弱共舞
      • 2. 手动中断循环引用
      • 3. 参数形式解决循环引用(block传参)
    • Block循环引用案例
  • 总结

前言

本来打算这周看看源码的,因为某些原因进度耽误了,另外强调了 GCD多线程,Runtime RunLoop,BLock都是面试必问必考的点,想起之前看的比较简略,就借着Block的循环引用顺带复习一下Block的整个流程。

在学习之前 对于ARC以及涉及到的属性关键字都要有了解还是要有了解的基础,尤其是weak。

准备工作

weak的实现原理
iOS ARC实现
iOS Block基础再探究

1. Block的分类

简单复习
block的分类主要分为以下三种

  • __NSGlobalBlock__ 全局block
  • __NSStackBlock__ 栈区block
  • __NSMallocBlock__ 堆区block

他们的分类原因和block的定义有关系 block是一个带有自动变量值的匿名函数

  • 什么是带有自动变量?
  • 带有自动变量值”在Block中表现为“截取自动变量值

例如如下blk即截取了外部变量。

- (void)mallocBlock {
    NSString* str = @"mallocBlk";
    void (^glbBlk)(void) = ^{
        NSLog(@"%@", str);
    };
    NSLog(@"%@", glbBlk);
}

Block分类简单总结如下

  • A、没有引用外部变量 — block存放在全局区
  • B、引用了外部变量----显式声明为weak类型的block则存放在区,反之则是存在在堆区的,也就是说block是strong类型的。

2. Block的内存分析

捕获外部变量引用计数的变化

ARC环境,案例中定义了两个block,跟踪objc的引用计数变化。

#pragma mark- Blk内存分析
- (void)blkMemory {
    NSObject *objc = [NSObject new];
       NSLog(@"%ld",CFGetRetainCount((__bridge CFTypeRef)(objc))); // 1

       void(^strongBlock)(void) = ^{
           NSLog(@"---%ld",CFGetRetainCount((__bridge CFTypeRef)(objc)));
       };
       strongBlock();

       void(^__weak weakBlock)(void) = ^{
           NSLog(@"---%ld",CFGetRetainCount((__bridge CFTypeRef)(objc)));
       };
       weakBlock();
       
       void(^mallocBlock)(void) = [weakBlock copy];
       mallocBlock();
}

运行结果如下:
【iOS底层探索- Block原理分析-循环引用】_第1张图片

  • 第一个打印为1就是简单创建引用计数+1
  • 第二个为3:strongBlock是一个堆区的block这里捕获了objc这个外部变量会进行加一,这里会把栈区的objc拷贝到堆区又进行了加一,所以打印结果为 3。
  • 打印 4是因为这里weakBlock是栈block,没有进行拷贝只是捕获+1,所以为4。
  • 最后打印5是因为[weakBlock copy]进行了拷贝操作,再赋值给mallocBlock也是+1操作,所以打印结果为 5。

如何区分堆栈Blk 这个需要了解blk的实现过程,在之前已作学习。

堆栈释放的差异

  • 差异1
#pragma mark -堆栈释放差异
- (void)blockDemo1 {
    int a = 777;
    void(^__weak weakBlock)(void) = nil;
    {
        void(^__weak strongBlock)(void) = ^{
            NSLog(@"%d", a);
        };
        weakBlock = strongBlock;
        NSLog(@"1 - %@ - %@", weakBlock,strongBlock);
    }
    weakBlock();
}

【iOS底层探索- Block原理分析-循环引用】_第2张图片
该段代码的运行并无任何问题:

  • 声明了一个weakBlock,该block为NSStackBlock;
  • 在代码块中,定义了strongBlock,其也为NSStackBlock
  • 对weakBlock进行了赋值,此时两个block均指向同一个NSStackBlock
  • 因为这两个栈block的生命周期到blockDemo方法运行结束,并不会被提前释放;(特地查了它的生命周期当创建 NSStackBlock 的函数返回时,栈上分配的内存将被释放,NSStackBlock 对象也将被销毁。)
  • 所以调用weakBlock()可以正常运行,并能够输出a的值。
  • 差异2

对上面的案例strongBlock修改成了NSMallocBlock,取消了__weak修饰符。

- (void)blockDemo2 {
    int a = 0;
    void(^__weak weakBlock)(void) = nil;
    {
        void(^strongBlock)(void) = ^{
            NSLog(@"---%d", a);
        };
        weakBlock = strongBlock;
        NSLog(@"1 - %@ - %@", weakBlock,strongBlock);
    }
    weakBlock();
}

【iOS底层探索- Block原理分析-循环引用】_第3张图片

案例崩溃 ,lldb调试发现在代码块{}结束之前 调用p weakBlock都是有地址的,但是出了代码块{}发现就没有了。
【iOS底层探索- Block原理分析-循环引用】_第4张图片

结合lldb调试结果分析:

  • strongBlockNSMallocBlock,其生命周期范围在代码块{}内,也就是出了代码块其就会被释放;
  • 在代码块中对weakBlock进行了赋值,指针拷贝,指向了对应的NSMallocBlock,但是并没有强引用指向这个block(__weak修饰符不会带有强引用,创建暨被释放)
    • 这里的指针拷贝可以从下图看到,二者指向相同的一片内存地址,
      【iOS底层探索- Block原理分析-循环引用】_第5张图片
  • 代码块执行完毕后,该NSMallocBlock就会被释放,此时weakBlock指向的对象已经被释放,形成野指针,所以无法正常执行。

最后把两个block的__weak都去掉,则能够正常运行并打印结果

- (void)blockDemo3 {
    int a = 0;
    void(^weakBlock)(void) = nil;
    {
        void(^strongBlock)(void) = ^{
            NSLog(@"---%d", a);
        };
        weakBlock = strongBlock;
        NSLog(@"1 - %@ - %@", weakBlock, strongBlock);
    }
    weakBlock();
}

【iOS底层探索- Block原理分析-循环引用】_第6张图片

上面的例子崩溃了,是因为堆区的 block出了作用域,被释放了。

此时的赋值,weakBlock对堆中的block进行了强引用,代码块运行结束后不会释放掉,也就不存在野指针的问题了。

总结

  • block分为全局 block、堆 block、栈 block
  • block可以捕获外部变量
  • 堆区的 block捕获外部变量会拷贝到堆区引计数+1
  • block 在使用的时候,堆block注意作用域的问题,弱引用指针赋值,出了作用域就释放了,可以通过强引用解决

3. Block的循环引用

  • 参考自:iOS_Block循环引用

3.1 什么是循环引用?

  • 正常情况对于对象的持有和释放是如下逻辑
    【iOS底层探索- Block原理分析-循环引用】_第7张图片
  • 循环引用就是对面持有导致对象不能及时的正常释放,容易造成内存泄漏。
    在这里插入图片描述

案例引入

如下代码可能造成循环引用

#import "ViewController.h"
typedef void (^TBlock)(void);
@interface ViewController ()
@property (nonatomic, strong) TBlock block;
@property (nonatomic, strong) NSString *name;
@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view.
    
    // 循环引用
    self.name = @"ViewController";
    self.block = ^() {
        NSLog(@"%@", self.name);
    };
    self.block();
}

self持有了block,block持有了self,导致循环引用。 编译器也会提示:Capturing 'self' strongly in this block is likely to lead to a retain cycle
请添加图片描述

  • 如果我们取消某一方的持有即可取消循环引用,恢复到正常的逻辑里面去。
 // 不会引起循环引用
    void(^blk1)(void);
    blk1 = ^() {
        NSLog(@"%@", self.name);
    };
    blk1();

这个案例就没有出现循环引用是因为当前self,也就是ViewController并没有对block进行强持有,block的生命周期只在viewDidLoad方法内,viewDidLoad方法执行完,block就会释放。

循环引用解决方法

在开始也提到过weak是基础,weak也是最为熟知的解决循环引用的方法,__weak不会进行引用计数的操作

  • weak的使用
    __weak typeof(self) weakSelf = self;

typeof(self)typeof 是一个运算符,用于获取表达式的类型。在这种情况下,表达式是 self,它代表当前对象的引用

避免循环引用方法:

 __weak typeof(self) weakSelf = self;
    self.block = ^(){
        NSLog(@"%@", weakSelf.name);
    } ;
    self.block();

此时self持有blockblock弱引用self,弱引用会自动变为nil,强持有中断,所以不会引起循环引用。

  • 反面案例

之前在学习GCD的时候学到过将其他线程的麻烦的方法执行完之后再次回到主线程,但是万一在其他线程执行的过程里面ViewController被销毁的话是什么情况,由于ARC不能显式调用dealloc 我们模拟一下延时。

 。。。。。。。
	__weak typeof(self) weakSelf = self;
    self.block = ^(){
    // 延迟2秒钟
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)( 2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
            NSLog(@"%@", weakSelf.name);
        });
    };
    self.block();
    [self fakeDealloc];
}
- (void)fakeDealloc {
    NSLog(@"调用了dealloc 模拟ViewController模拟销毁");
    // 模拟viewController被销毁
    self.name = nil;
}

dealloc方法调用了,VC 已经销毁了,block 也就释放了,内部的延时函数里面的打印还来不及打印,所以 name为 null.
【iOS底层探索- Block原理分析-循环引用】_第8张图片
虽然没有引起循环引用,但是block中延迟2秒钟执行任务,如果此时ViewController被销毁,此时block已经无法获取ViewController的属性name,很不合理。

1. 强弱共舞

为了解决上面的问题 由此引出了强弱共舞【iOS底层探索- Block原理分析-循环引用】_第9张图片
则一切就会正常打印。

原理:因为__weak会自动置为nil,所以这里使用__strong(strong-weak-dance)暂时延长 self的生命周期,使得可以正常打印。

为什么强弱共舞能够避免循环引用,不是也调用了self? 因为这里strongSelf是一个临时的变量,出了作用域也跟着释放了,所以不会出现循环引用

简单分析:

  • 在完成block中的操作之后,才调用了dealloc方法。添加strongWeak之后,持有关系为:self -> block -> strongWeak -> weakSelf -> self
  • weakSelf被强引用了就不会自动释放,因为strongWeak只是一个临时变量,它的声明周期只在block内部,block执行完毕后,strongWeak就会释放,而弱引用weakSelf也会自动释放

2. 手动中断循环引用

    self.name = @"ViewController";
    __block ViewController * VC = self;
    self.block = ^(){
        __strong __typeof(weakSelf)strongWeak = weakSelf;
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
            NSLog(@"%@", ctrl.name);
            VC = nil;
        });
    };
    self.block();

这里使用一个临时的VC变量之后,持有关系为: self --> block --> VC–> selfVCblock使用完成后就被置为nilblock不构成对self的持有关系了,因此这里就不构成循环引用问题。

__block是因为需要对外部变量,进行赋值操作

3. 参数形式解决循环引用(block传参)

- (void)parameterMethod {
    self.name = @"ViewController";
    // blk传参解决循环引用
    // 循环引用
    self.block = ^(ViewController * ctrl){
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
            NSLog(@"%@", ctrl.name);
        });
    };
    self.block(self);

self作为参数参入block中,进行指针拷贝,并没有对self进行持有。【iOS底层探索- Block原理分析-循环引用】_第10张图片

Block循环引用案例

  • 静态变量持有
    // staticSelf_定义:
    static ViewController *staticSelf_;

    - (void)blockWeak_static {
        __weak typeof(self) weakSelf = self;
        staticSelf_ = weakSelf;
    }

weakSelf虽然是弱引用,但是staticSelf_静态变量,并对weakSelf进行了持有,staticSelf_释放不掉,所以weakSelf也释放不掉!导致循环引用!

  • __strong持有问题
- (void)block_weak_strong {

    __weak typeof(self) weakSelf = self;

    self.doWork = ^{
        __strong typeof(self) strongSelf = weakSelf;
        NSLog(@"B objc -----retainCount : %lu", CFGetRetainCount(((__bridge CFTypeRef)strongSelf)));

        weakSelf.doStudent = ^{
            NSLog(@"%@", strongSelf);
            NSLog(@"B objc -----retainCount : %lu", CFGetRetainCount(((__bridge CFTypeRef)strongSelf)));
        };

       weakSelf.doStudent();
    };

   self.doWork();
}
  • doWork内部,__strong typeof(self) strongSelf = weakSelf;
  • 用强引用持有了weakSelf,和前的情况类似,strongSelf的生命周期也就在doWork方法内;
  • 这里需要注意的是,doStudent这个内部block调用了外部变量,所以他会从栈block copy到堆中,从而导致strongSelf的引用计数增加,无法释放掉,进而导致循环引用!

总结

通过今天对Block的再学习,也算是复习了block的小知识点,同时学习了几种循环引用出现的场景和如何解决循环引用的方法,记录并复习。

你可能感兴趣的:(ios,objective-c,xcode)