Block二

C语言内存分配

Objective-C从名字来看就可以知道是一门超C语言，所以了解C语言的内存模型对于理解Objective-C的内存管理有很大的帮助。C语言内存模型图如下：

1-1 C内存分配.png

从图中可以看出内存被分成了5个区，每个区存储的内容如下：

• 栈区(stack)：存放函数的参数值、局部变量的值等，由编译器自动分配释放，通常在函数执行结束后就释放了，其操作方式类似数据结构中的栈。栈内存分配运算内置于处理器的指令集，效率很高，但是分配的内存容量有限，比如iOS中栈区的大小是2M。

• 堆区(heap)：就是通过new、malloc、realloc分配的内存块，它们的释放编译器不去管，由我们的应用程序去释放。如果应用程序没有释放掉，操作系统会自动回收。分配方式类似于链表。

• 静态区：全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。程序结束后，由系统释放。

• 常量区：常量存储在这里，不允许修改的。

• 代码区：存放函数体的二进制代码。

栈区在什么时候释放内存呢？我们通过下面的一个例子来说明下：

1 2 3 4 5

- (void)print {      int i = 10;      int j = 20;      NSLog(@ "i+j = %d" , (i+j)); }

在上面的代码中当程序执行到 } 的时候，变量i和j的作用域已经结束了，编译器就会自动释放掉i和j所占的内存，所以理解好作用域就理解了栈区的内存分配。

栈区和堆区的区别主要为以下几点：

• 对于栈来说，内存管理由编译器自动分配释放；对于堆来说，释放工作由程序员控制。

• 栈的空间大小比堆小许多。

• 栈是机器系统提供的数据结构，计算机会在底层对栈提供支持，所以分配效率比堆高。

• 栈中存储的变量出了作用域就无效了，而堆由于是由程序员进行控制释放的，变量的生命周期可以延长。

  
  

  声明block属性的时候为什么用copy呢？

  在说明为什么要用copy前，先思考下block是存储在栈区还是堆区呢？其实block有3种类型：

  • 全局块(_NSConcreteGlobalBlock)

  • 栈块(_NSConcreteStackBlock)

  • 堆块(_NSConcreteMallocBlock)

  全局块存储在静态区（也叫全局区），相当于Objective-C中的单例；栈块存储在栈区，超出作用域则马上被销毁。堆块存储在堆区中，是一个带引用计数的对象，需要自行管理其内存。

  怎么判断一个block所在的存储位置呢？

  • block不访问外界变量（包括栈中和堆中的变量）

  block既不在栈中也不在堆中，此时就为全局块，ARC和MRC下都是如此。

  • block访问外界变量

  MRC环境下：访问外界变量的block默认存储在栈区。

  ARC环境下：访问外界变量的block默认存放在堆中，实际上是先放在栈区，在ARC情况下自动又拷贝到堆区，自动释放。

  使用copy修饰符的作用就是将block从栈区拷贝到堆区，为什么要这么做呢？我们看下Apple官方文档给出的答案：

  

  1-2 block copy.png

  通过官方文档可以看出，复制到堆区的主要目的就是保存block的状态，延长其生命周期。因为block如果在栈上的话，其所属的变量作用域结束，该block就被释放掉，block中的__block变量也同时被释放掉。为了解决栈块在其变量作用域结束之后被释放掉的问题，我们就需要把block复制到堆中。

  不同类型的block使用copy方法的效果也不一样，如下所示：

  

  block的类型 存储区域 复制效果

  _NSConcreteStackBlock 栈 从栈复制到堆

  _NSConcreteGlobalBlock 静态区(全局区) 什么也不做

  _NSConcreteMallocBlock 堆 引用计数增加

  
  

  在使用系统提供的block api需要考虑循环引用的问题吗？比如：

  1 2 3

  [UIView animateWithDuration:0.5 animations:^{      [self doSomething]; }];

  在这种情况下是不需要考虑循环引用的，因为这里只有block对self进行了一次强引用，属于单向的强引用，没有形成循环引用。

  weak与strong有什么区别呢？先看一段代码：

  1 2 3 4 5 6 7 8

  - (void)configureBlock {      __weak  typeof (self) weakSelf = self;      self.block = ^{          [weakSelf doSomething];  // weakSelf != nil          // preemption(抢占) weakSelf turned nil          [weakSelf doAnotherThing];      }; }

  这段代码看起来很正常呀，但是在并发执行的时候，block的执行是可以抢占的，而且对weakSelf指针的调用时序不同可以导致不同的结果，比如在一个特定的时序下weakSelf可能会变成nil，这个时候在执行doAnotherThing就会造成程序的崩溃。为了避免出现这样的问题，采用__strong的方式来进行避免，更改后的代码如下：

  1 2 3 4 5 6 7 8 9

  - (void)configureBlock {      __weak  typeof (self) weakSelf = self;      self.block = ^{          __strong  typeof (weakSelf) strongSelf = weakSelf;          [strongSelf doSomething];  // strongSelf != nil          // 在抢占的时候，strongSelf还是非nil的。          [strongSelf doAnotherThing];      }; }

  从代码中可以看出加入__strong所起的作用就是在抢占的时候strongSelf还是非nil的，避免出现nil的情况。

  问题来源

  
  

  这是一种 强引用 --> 弱引用 --> 强引用 的变换过程。在弄明白为什么要如此大费周章之前，我们首先来看看一般的写法会有什么问题。

  
  

  __weak MyViewController *wself = self;

  self.completionHandler = ^(NSInteger result) {

  [wself.property removeObserver: wself forKeyPath:@"pathName"];

  };

  
  

  这种写法可以避免循环引用，但是我们要考虑这样的问题：

  
  

  假设 block 被放在子线程中执行，而且执行过程中 self 在主线程被释放了。由于 wself 是一个弱引用，因此会自动变为 nil。而在 KVO 中，这会导致崩溃。

  
  

  Strong-Weak Dance

  
  

  解决以上问题的方法很简单，新增一行代码即可：

  
  

  __weak MyViewController *wself = self;

  self.completionHandler = ^(NSInteger result) {

  __strong __typeof(wself) sself = wself; // 强引用一次

  [sself.property removeObserver: sself forKeyPath:@"pathName"];

  };

  
  

  这样一来，self 所指向对象的引用计数变成 2，即使主线程中的 self 因为超出作用于而释放，对象的引用计数依然为 1，避免了对象的销毁。

  
  

  思考

  
  

  在和小伙伴的讨论过程中，他提出了几个问题。虽然都不难，但是有利于把各种知识融会贯通起来。

  
  

  1.Q：下面这行代码，将一个弱引用的指针赋值给强引用的指针，可以起到强引用效果么？

  
  

  __strong __typeof(wself) sself = wself;

  
  

  A：会的。引用计数描述的是对象而不是指针。这句话的意思是：

  
  

  sself 强引用 wself 指向的那个对象

  
  

  因此对象的引用计数会增加一个。

  
  

  2.Q：block 内部定义了sself，会不会因此强引用了 sself？

  
  

  A：不会。block 只有截获外部变量时，才会引用它。如果是内部新建一个，则没有任何问题。

  
  

  3.Q：如果在 block 内部没有强引用，而是通过 if 判断，是不是也可以，比如这样写：

  
  

  __weak MyViewController *wself = self;

  wself.completionHandler = ^(NSInteger result) {

  if (wself) { // 只有当 wself 不为 nil 时，才执行以下代码

  [wself.property removeObserver: wself forKeyPath:@"pathName"];

  }

  };

  
  

  A：不可以！考虑到多线程执行，也许在判断的时候，self 还没释放，但是执行 self 里面的代码时，就刚好释放了。

  
  

  4.Q：那按照这个说法，block 内部强引用也没用啊。也许 block 执行以前，self 就释放了。

  
  

  A：有用！如果在 block 执行以前，self 就释放了，那么 block 的引用计数降为 0，所以自己就会被释放。这样它根本就不会被执行。另外，如果执行一个为 nil 的闭包会导致崩溃。

  
  

  5.Q：如果在执行 block 的过程中，block 被释放了怎么办？

  
  

  A：简单来说，block 还会继续执行，但是它捕获的指针会具有不确定的值

  
  

  @strongify 和 @weakify

  
  

  这是 ReactiveCocoa 中定义的一个宏。一般可以这样使用：

  
  

  @weakify(self);

  self.completionHandler = ^(NSInteger result) {

  @strongify(self);

  [self.property removeObserver: sself forKeyPath:@"pathName"];

  };

  
  

  本文并非分析它们的实现原理，所以就简单解释两点：

  
  

  1. 这里的“@”没有任何用处，仅表示强调，这个宏实际上包含了一个空的 AutoreleasePool，这也就是为什么一定要加上“@”。

     
     

  2. 它的原理还是和之前一样，生成了一段形如 __weak MyViewController *wself = self; 这种格式的代码：

  
  

  #define rac_strongify_(INDEX, VAR) \

  __strong __typeof__(VAR) VAR = metamacro_concat(VAR, _weak_);

  
  

  Swift 中的情况

  
  

  感谢 @Cyrus_dev 的提醒，在 Swift 中也有 Strong-Weak Dance 的概念。最简单的方法就是直接沿用 OC 的思路：

  
  

  self.completionHandler = { [weak self] in

  if let strongSelf = self {

  /// ....

  }

  };

  
  

  这种写法的缺点在于，我们不能写 if let self = self，因此需要重新定义一个变量 strongSelf，命名方式显得不够优雅。

  除此以外还可以使用 Swift 标准库提供的函数 withExtendedLifetime：

  
  

  self.completionHandler = { [weak self] in

  withExtendedLifetime(self) {

  /// ...

  }

  };

  
  

  这种写法的缺点在于，self 依然是可选类型的，还需要把它解封后才能使用。

  最后，还有一种解决方案是自定义 withExtendedLifetime函数：

  
  

  extension Optional {

  func withExtendedLifetime(body: T -> Void) {

  if let strongSelf = self {

  body(strongSelf)

  }

  }

  }

  
  

  至于这种写法是否更加优雅，就见仁见智了：

  
  

  self.completionHandler = { [weak self] in

  self.withExtendedLifetime {

  /// 这里用 $0 表示 self

  }

  };