iOS block底层原理分析(1)--循环引用

准备工作

weak实现原理

1. 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]);

运行结果如下：

运行结果

由以上的案例运行结果可知，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)));

运行结果如下：

运行结果

查看运行结果发现，blockB在MRC下是NSStackBlock类型，而在ARC下是NSMallocBlock类型。

• NSGlobalBlock
  此种情况和MRC一样，block内部没有引用外部变量的，Block类型都是NSGlobalBlock类型，存储于全局数据区，由系统管理其内存，如果访问了外部static或者全局变量也是这种类型。
• NSStackBlock
  访问了外部变量，但没有强引用指向这个block，如直接打印出来的block，如下：
  
  弱引用block
• NSMallocBlock
ARC环境下只要访问了外部变量，而且有强引用指向该block(或者作为函数返回值)就会自动将__NSStackBlock类型copy到堆上。

2. block的内存分析

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

ARC环境，案例中定义了两个block，跟踪objc的引用计数变化。引入相关案例如下：

    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();

运行结果如下：

运行结果

查看运行结果看出引用计数分别是1，2，4，第一个是1应该多数人是没问题的，那么后面为什么是2，4呢？接着往下分析：

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

2.2 堆栈释放差异

• 差异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();
}

运行结果如下：

运行结果

可以知道案例的运行是没有出现问题的，那么结果分析如下：

• 声明了一个weakBlock，该block为NSStackBlock；

• 在代码块中，定义了strongBlock，其也为NSStackBlock；

• 对weakBlock进行了赋值，此时两个block均指向同一个NSStackBlock；

• 因为这两个栈block的生命周期到blockDemo方法运行结束，并不会被提前释放；

• 所以调用weakBlock()可以正常运行，并能够输出a的值。

• 差异2
  对上面的案例strongBlock修改成了NSMallocBlock，其他没有变化。如下：

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

运行结果如下：

运行结果

可以知道这个案例运行是有问题的，出现了崩溃，常规办法我们用lldb调试看看：

lldb调试结果

结合lldb调试结果分析：

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

lldb继续验证是否为指针拷贝，如下：

指针拷贝

如果将weakBlock去掉__weak修饰呢？请继续往下看：

去掉__weak修饰

可以知道这样子是完全没有问题的，分析如下：

• 对weakBlock进行了赋值时，weakBlock对堆中的block进行了强引用。所以代码块运行完后不会释放，能够正常运行。

3. block循环引用

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

持有情况下

释放情况下

循环引用就是对方面持有导致对象不能正常释放，会发生内存泄漏，如下：

循环引用

3.1 循环引用的案例

引入一个循环引用的案例如下：

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可能会导致循环循环。

特殊案例
以下代码并没有引起循环引用，如下：

- (void)viewDidLoad {
    [super viewDidLoad];

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

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

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

3.2 循环引用解决方法

最常用的也是我们最熟知的_weak。__weak之所以能够解决循环引用，根本原因是__weak不会对引用计数进行操作。

• weak的使用

__weak typeof(self) weakSelf = self;

上面的案例修改成weak来避免循环引用如下：

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

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

    self.block();

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

• 反面案例
  如果在以上的案例中修改成如下的话，会发生代码执行过程中对象被释放的情况，如下：
  

  反面案例
  
  虽然没有引起循环引用，但是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();

运行结果如下：

运行结果

通过运行结果发现，完全解决了以上self中途被释放的问题，这是为什么呢？分析如下：

• 在完成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();

运行结果如下：

运行结果

使用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进行持有。运行结果如下：

运行结果

3.3 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底层究竟做了什么，请拭目以待！！哈哈