iOS底层学习——block以及循环引用问题

gufs镜像
2,425 阅读7分钟

1.block分类

  • block分类

    block分为三种类型：

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

block在MRC和ARC环境出现的情况：

  • MRC环境下

    引入下面的案例:

        void(^block)(void);
    int aa = 0;

    NSLog(@"\n********A**********");

    void (^blockA)(void) = ^{
    };
    NSLog(@"blockA is : %@ -----retainCount : %lu", blockA, [blockA retainCount]);
    block = [blockA copy];
    NSLog(@"copy blockA is : %@ -----retainCount : %lu",  block, [blockA retainCount]);

    NSLog(@"\n********B**********");

    void (^blockB)(void) = ^{
        NSLog(@"hello aa %d", aa);
    };
    NSLog(@"blockB is : %@ -----retainCount : %lu", blockB, [blockB retainCount]);
    block = [blockB copy];
    NSLog(@"copy blockB is : %@ -----retainCount : %lu",  block, [block retainCount]);

    运行结果：

    image.png

    可以看到，blockA与blockB的差异只在于有没有调用外部变量，这点差异导致它们的类型不同，存储位置不同。

    • NSGlobalBlock

      block内部没有引用外部变量的，Block类型都是NSGlobalBlock类型，存储于全局数据区，由系统管理其内存，retain、copy、release操作都无效。如果访问了外部static或者全局变量也是这种类型。

    • NSStackBlock

      block内部引用外部变量，retain、release操作无效，存储于栈区，变量作用域结束时，其被系统自动释放销毁。

    • NSMallocBlock

      如上例中的[blockB copy]操作后变量类型变为NSMallocBlock，支持retain、release，虽然retainCount始终是1，但内存管理器中仍然会增加、减少计数，当引用计数为零的时候释放。

  • ARC环境

    引入下面的案例:

        void(^block)(void);
    int aa = 0;

    NSLog(@"\n********A**********");

    void (^blockA)(void) = ^{
    };
    NSLog(@"blockA is : %@ -----retainCount : %lu", blockA, CFGetRetainCount(((__bridge CFTypeRef)blockA)));
    block = [blockA copy];
    NSLog(@"copy blockA is : %@ -----retainCount : %lu",  block, CFGetRetainCount(((__bridge CFTypeRef)block)));

    NSLog(@"\n********B**********");

    void (^blockB)(void) = ^{
        NSLog(@"hello aa %d", aa);
    };
    NSLog(@"blockB is : %@ -----retainCount : %lu", blockB, CFGetRetainCount(((__bridge CFTypeRef)blockB)));
    block = [blockB copy];
    NSLog(@"copy blockB is : %@ -----retainCount : %lu",  block, CFGetRetainCount(((__bridge CFTypeRef)block)));

    NSLog(@"\n********C**********");

    void (^__weak blockC)(void) = ^{
        NSLog(@"hello aa %d", aa);
    };
    NSLog(@"blockC is : %@ -----retainCount : %lu", blockC, CFGetRetainCount(((__bridge CFTypeRef)blockC)));
    block = [blockB copy];
    NSLog(@"copy blockC is : %@ -----retainCount : %lu",  block, CFGetRetainCount(((__bridge CFTypeRef)block)));

    运行结果：

    image.png

    我们发现，blockB在MRC下是NSStackBlock类型，而在ARC下是NSMallocBlock类型。

    • NSGlobalBlock

      此种情况和MRC一样，block内部没有引用外部变量的，Block类型都是NSGlobalBlock类型，存储于全局数据区，由系统管理其内存，如果访问了外部static或者全局变量也是这种类型。

    • NSStackBlock

      访问了外部变量，但没有强引用指向这个block，如直接打印出来的block

      image.png

    • NSMallocBlock

      ARC环境下只要访问了外部变量，而且有强引用指向该block(或者作为函数返回值)就会自动将__NSStackBlock类型copy到堆上

2.block内存的影响

  • 捕获外部变量引用计数案例分析

    引入一个案例：

        NSObject * objc = [NSObject alloc];
    NSLog(@"objc -----retainCount : %lu", CFGetRetainCount(((__bridge CFTypeRef)objc)));

    void (^__weak blockA)(void) = ^{
        NSLog(@"A objc -----retainCount : %lu", CFGetRetainCount(((__bridge CFTypeRef)objc)));
    };
    blockA();

    void (^blockB)(void) = ^{
        NSLog(@"B objc -----retainCount : %lu", CFGetRetainCount(((__bridge CFTypeRef)objc)));
    };
    blockB();

    运行结果:

    image.png

    ARC环境，案例中定义了两个block，跟踪objc的引用计数变化。下面我们来分析一下这个结果:

    • 首先objc对象创建好之后，调用CFGetRetainCount函数获取引用计数，此时应该为1；
    • blockA为__weak，也就是没有强引用指向这个block，并且访问了外部变量，所以是NSStackBlock，因为blockA对变量objc进行了捕获，并在其结构体内部创建了一个objc的变量，所以此时引用计数应该变成2；
    • blockB是一个NSMallocBlock，ARC环境下只要访问了外部变量，而且有强引用指向该block就会自动将__NSStackBlock类型copy到堆上，所以这个过程进行了一次block的copy，所以这个地方引用计数加2，变为4。

  • 堆栈释放差异1

    引入下面的案例，是否能正常运行：

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

        weakBlock = strongBlock;
        NSLog(@"1 - %@ - %@", weakBlock,strongBlock);
    }
    weakBlock();
}

    运行结果见下图：

    image.png

    结果分析：

    • 声明了一个weakBlock，该block为NSStackBlock；
    • 在代码块中，定义了strongBlock，其也为NSStackBlock；
    • 对weakBlock进行了赋值，此时两个block均指向同一个NSStackBlock；
    • 因为这两个栈block的生命周期到blockDemo方法运行结束，并不会被提前释放；
    • 所以调用weakBlock()可以正常运行，并能够输出a的值。

  • 堆栈释放差异2

    对上面的案例进行一下修改:

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

    strongBlock修改成了NSMallocBlock，其他没有变化。这时候运行结果会是怎么样呢？运行程序：

    image.png

    运行报错，为什么呢？结合lldb调试结果进行分析：

    image.png

    • 在代码块中strongBlock为NSMallocBlock，其生命周期范围在代码块{}内，也就是出了代码块其就会被释放；
    • 在代码块中对weakBlock进行了赋值，指针拷贝，指向了对应的NSMallocBlock，但是并没有强引用指向这个block；
    • 代码块执行完毕后，该NSMallocBlock就会被释放，此时weakBlock指向的对象已经被释放，形成野指针，所以无法正常执行。

    如果将weakBlock和NSMallocBlock都去掉__weak，则能够正常执行，因为在对weakBlock进行了赋值时，weakBlock对堆中的block进行了强引用。所以代码块运行完后不会释放，能够正常运行，见下图：

    image.png

3.block循环引用

引起循环引用的前提——你中有我，我中有你！！！

正常情况下，持有释放，按照下图的逻辑：

image.png image.png

但是引起循环情况下，却不能完成正常的释放，导致内存泄露。见下图：

image.png

  • 循环引用的案例

    typedef void(^TBlock)(void);

@interface ViewController ()
@property (nonatomic, strong) TBlock block;
@property (nonatomic, copy) NSString *name;
@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];

    // 循环引用
    self.name = @"Hello";
    self.block = ^(){
        NSLog(@"%@", self.name);
    };
    self.block();
}

    这里self持有了block，block持有了self，导致循环引用。编译时Xcode也会给出提示，在此块中强烈捕获self可能会导致循环循环。

  • 注意事项

    以下代码并没有引起循环引用，因为当前self，也就是ViewController并没有对block进行强持有，block的生命周期只在viewDidLoad方法内，viewDidLoad方法执行完，block就会释放。

    - (void)viewDidLoad {
    [super viewDidLoad];

    // 循环引用
    self.name = @"Hello";

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

1.循环引用解决方法

如何解决循环引用问题呢？最常用的也是我们最熟知的_weak。__weak之所以能够解决循环引用，根本原因是__weak不会对引用计数进行操作。weak实现原理查看文章：weak实现原理和销毁过程

  • weak的使用

    __weak typeof(self) weakSelf = self;

    这是我们常用的方式，上面的案例可以修改为一下代码：

        // 循环引用
    self.name = @"Hello";

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

    self.block();

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

    但是这种方式存在一些问题，见下图：

    image.png

    虽然没有引起循环引用，但是block中延迟2秒钟执行任务，如果此时ViewController被销毁，此时block已经无法获取ViewController的属性name，很不合理，如何解决这个问题呢？

  • 强弱共舞

    将上面的案例再改进一下：

        self.name = @"Hello";

    __weak typeof(self) weakSelf = 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(@"%@", strongWeak.name);
        });
    };

    self.block();

    运行结果见下图：

    image.png

    通过运行结果可以发现，在完成block中的操作之后，才调用了dealloc方法。添加strongWeak之后，持有关系为： self -> block -> strongWeak -> weakSelf -> self，weakSelf被强应用了就不会自动释放，为什么这里可以释放呢，因为strongWeak只是一个临时变量，它的声明周期只在block内部，block执行完毕后，strongWeak就会释放，而弱引用weakSelf也会自动释放。

  • 手动中断持有关系

    手动中断持有关系的方式解决循环引用问题，见下面代码：

        self.name = @"Hello";

    __block ViewController * ctrl = 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);
            ctrl = nil;
        });
    };
    self.block();

    运行结果见下图：

    image.png

    使用ctrl之后，持有关系为： self -> block -> ctrl -> self，ctrl在block使用完成后，被置空，至此block对self持有就解除，不构成循环引用。

  • block传参

    block传参的方式解决循环引用问题，见下面代码：

        // 循环引用
    self.name = @"Hello";
    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进行持有。

    image.png

2.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的引用计数增加，无法释放掉，进而导致循环引用！

avatar
文章
阅读
粉丝