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

  运行结果：

  

  可以看到，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

    

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

  运行结果:

  

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

  运行结果见下图：

  

  结果分析：

  • 声明了一个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，其他没有变化。这时候运行结果会是怎么样呢？运行程序：

  

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

  

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

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

  

3.block循环引用

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

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

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

• 循环引用的案例

  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，强持有中断，所以不会引起循环引用。

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

  

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

  运行结果见下图：

  

  通过运行结果可以发现，在完成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进行持有。

  

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