Block 原理和内存管理

Block是什么？

在oc中它是带有^符号的匿名函数，遵循BN范式: ^ 返回值类型 参数列表 表达式 （参数和返回值为空的时候可以省略）。

而在C中（OC编译后的C）它会被编译成一堆结构体和几个函数以及静态变量。

而这几个结构体和函数，正是Block实现的本质.

1. Block 结构体
2. 表达式转换成的函数
3. 描述体
4. Block主体结构体
5. Block的调用

// Block 结构体
struct __block_imp1 {
  void *isa;
  int Flags;
  int Reserved;
  void *FuncPtr;
}

// 描述体
static struct __main_block_desc_0 {
  unsigned long reserved;
  unsigned long Block_size;
} __main_block_desc_0_DATA = {
  0,
  sizeof(struct __main_block_imp1_0)
}

// Block主体结构体
struct __main_block_imp1_0 {
  struct __block_imp1 imp1;
  struct __main_block_desc_0* Desc;
  
  __main_block_imp1_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) {
    imp1.isa = &_NSConcreteStackBlock;
    imp1.Flags = flags;
    imp1.FuncPtr = fp;
    Desc = desc;
  }
}

// 表达式转换成的函数
static void  __main_block_func_0(struct __main_block_imp1_0 *__cself) {
  printf("this is a block");
}

int main() {
  // Block的调用
  void (*blk)(void) = (void(*)(void))&__main_block_imp1_0((void*)__main_block_func_0,&__main_block_desc_0_DATA);
  ((void(*)(struct __block_imp1 *))((struct __block_imp1 *)blk)->FuncPtr)((struct __block_imp1 *)blk);
  return 0;
}

逐一来分析一下，这几个结构体的作用。

// Block 结构体
struct __block_imp1 {
  void *isa;
  int Flags;
  int Reserved;
  void *FuncPtr;
}

由于转化后的Block类型结构体的成员中有isa指针，不难得知它和某些OC的类有关系，而在struct __main_block_imp1_0的初始化函数中，isa被赋予了一个_NSConcreteStackBlock的类。这表明该Block属于stack存在于栈中的类。

_NSConcreteStackBlock  存在于栈中
_NSConcreteMallocBlock 存在于堆中
_NSConcreteGlobalBlock 存在于.Data（程序的数据区域）中

​

// 描述体
static struct __main_block_desc_0 {
  unsigned long reserved;
  unsigned long Block_size;
} __main_block_desc_0_DATA = {
  0,
  sizeof(struct __main_block_imp1_0)
}

只是存储了一些升级区域和结构大小。

// Block主体结构体
struct __main_block_imp1_0 {
  struct __block_imp1 imp1;
  struct __main_block_desc_0* Desc;
  
  __main_block_imp1_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) {
    imp1.isa = &_NSConcreteStackBlock;
    imp1.Flags = flags;
    imp1.FuncPtr = fp;
    Desc = desc;
  }
}

__main_block_imp1_0结构体从某种程度上封装了前两个结构体，但它的实际意义不止于此。

// 表达式转换成的函数
static void  __main_block_func_0(struct __main_block_imp1_0 *__cself) {
  printf("this is a block");
}

int main() {
  // Block的调用
  void (*blk)(void) = (void(*)(void))&__main_block_imp1_0((void*)__main_block_func_0,&__main_block_desc_0_DATA);
  ((void(*)(struct __block_imp1 *))((struct __block_imp1 *)blk)->FuncPtr)((struct __block_imp1 *)blk);
  return 0;
}

函数和调用很简单，就是一些类型转换容易让人眼花缭乱，经过删繁就简之后，就是简单的函数声明和调用而已。

需要注意的是，__main_block_func_0是以__main_block_imp1_0这个主体结构体入参的，这在变量捕捉的时候有很大作用。

变量捕捉

熟悉了Block的本质之后，就是对于Block的运用了，Block为什么如此好用的原因之一就在于，我们可以做到一般函数不能做到的事情，例如：局部变量的捕捉。

int main() {
    int v = 1;
    void (^blk)(void) = ^{
        printf("this is a block %d",v);
    };
    blk();
    return 0;
}

可以看到，变量v能够在表达式内部获取到。

然而当我们想要在内部改变这个变量的值的时候，会得到一个编译错误。

int main() {
    int v = 1;
    void (^blk)(void) = ^{
        printf("this is a block %d",v);
        v = 2; // error: Variable is not assignable (missing __block type specifier)
    };
    blk();
    return 0;
}

为什么？

既然错误发生在表达式内，我们就来分析一下编译后的函数static void __main_block_func_0(struct __main_block_imp1_0 *__cself) 捕获变量后，这个函数的实现变成了这样：

// 表达式转换成的函数
static void  __main_block_func_0(struct __main_block_imp1_0 *__cself) {
        int v = __cself->v;
    printf("this is a block %d",v);
}

入参__main_block_imp1_0多了个v的成员变量。

也就是说，编译后，__main_block_imp1_0结构体负责存储捕获的局部变量。

然而捕获的变量也是Int类型的，并非指针，所以我们在__main_block_func_0中改变变量V的值是没有任何意义的。编译器很聪明的检测到了这个操作。

那么我们加入__block之后呢？

int main() {
    __block int v = 1;
    void (^blk)(void) = ^{
        printf("this is a block %d",v);
        v = 2;
    };
    blk();
    return 0;
}

编译器的报错消失了。

意味着我们可以随意在block内改动v这个局部变量了。

那么内部是怎么实现的呢？

还是看函数实现:

// 表达式转换成的函数
static void  __main_block_func_0(struct __main_block_imp1_0 *__cself) {
        __Block_byref_val_0 *val = __cself->val;
    printf("this is a block %d",(val->_forwarding->v));
    (val->_forwarding->v) = 2;
}

__main_block_imp1_0里存储的成员V变了，不再是简单的Int类型，而是变成了

__Block_byref_val_0 指针。

struct __Block_byref_val_0 {
  void *__isa;
  __Block_byref_val_0 *__forwarding;
  int __flags;
  int __size;
  int __v;
}

需要稍微分析一下，这几个成员变量的意义。

找到它初始化的地方，在main函数内：

__Block_byref_val_0 v = (
  0,
  &v,
  0,
  sizeof(__Block_byref_val_0),
  1
)

• isa 被赋值为空

• _forwarding 指向了自己，

• flags =0

• size 传入了大小

• v 赋值成捕获的变量的值

而原本的int变量v消失了，__Block_byref_val_0变量v取而代之，将此结构体的指针赋值给

__main_block_imp1_0成员变量后，就可以实现对变量v的修改了。

这是__block的作用，可是在结构体

__Block_byref_val_0初始化的时候还有一个有趣的地方，就是：

__Block_byref_val_0 *__forwarding;

__forwarding指针有什么意义呢？它指向了自己，并且在函数体内修改存储值时，也访问了"自己"。为何要多此一举？

Block的存储域

再弄清__forwarding指针的作用之前，我们先要缕清楚这三种Block的区别以及应用的场景。

类型	内存分布	场景
_NSConcreteStackBlock	存在于栈中	定义在函数内部，未被强引用，且捕获了外部变量。
_NSConcreteMallocBlock	存在于堆中	被强引用，由_NSConcreteStackBlock被拷贝到堆内存。
_NSConcreteGlobalBlock	存在于.Data（程序的数据区域）中	定义在全局区域，或者未捕获外部变量且定义在函数内部的block

从内存管理的角度看，_NSConcreteGlobalBlock类型的Block讨论意义不大。

_NSConcreteStackBlock和 _NSConcreteMallocBlock 才是我们要讨论的重点。

假定这样一种情况(MRC下)：

blk_t blk;
{
     NSAutoreleasePool *pool = [NSAutoreleasePool new];
    id array = [[[NSMutableArray alloc] init] autorelease];
    blk = ^( id obj){
        [array addObject:obj];
        NSLog(@"count is %d",[array count]);
    };
     [pool release];
}
blk([[NSObject alloc] init]);
blk([[NSObject alloc] init]);
blk([[NSObject alloc] init]);
    

由于是MRC环境，加入NSAutoreleasePool来模拟array的释放周期。

可以看到，在大括号以外调用block，肯定会崩溃，因为array已经释放了。并且在这种情况下，Block属于_NSConcreteStackBlock类型。

我们稍稍改动一下：

blk_t blk;
{
    NSAutoreleasePool *pool = [NSAutoreleasePool new];
    id array = [[[NSMutableArray alloc] init] autorelease];
    blk = [^( id obj){
        [array addObject:obj];
        NSLog(@"count is %d",[array count]);
    } copy];
    [pool release];
}
blk([[NSObject alloc] init]);
blk([[NSObject alloc] init]);
blk([[NSObject alloc] init]);

程序输出正常了，array也被block正常捕获。

而Block的类型经过copy之后，变成了_NSConcreteMallocBlock，copy方法实际调用的是：

id objc_retainBlock(id x) {
    return (id)_Block_copy(x);
}

_Block_copy 作用按照文档上来说是将Block拷贝到堆内存——这和我们的测试结果一样。

随着Block被复制到堆内存之后，Block所持有的__block变量也会复制到堆内存并且持有，要证明需要看编译后的代码：

static void __main_block_copy_0 (struct __main_block_imp1_0*dst ,struct __main_block_imp1_0*src){
  _Block_object_assign(&dst->val, src->val, BLOCK_FIELD_IS_BYREF);
}
static void __main_block_dispose_0(struct __main_block_imp1_0*scr){
  _Block_object_dispose(src->val, BLOCK_FIELD_IS_BYREF);
}

这两个方法是在Block被复制到堆内存和从堆内存释放的时候调用的。

_Block_object_assign 和 _Block_object_dispose分别是Block持有变量的赋值和释放。

__forwarding指针：

这时候我们可以来解释这个指针的作用了：

__block int v = 1;
void (^blk)(void) = [^{v++;} copy];
v++;
blk();
printf("num is  %d",v);

可以看到经过copy后的变量v在外部仍然可以改变，试想如果没有__forwarding指针存在的话，v经过编译后，结构体仍然存在于栈上，此时改变v的值结果肯定不是我们想要的3。

__forwarding保证__Block的变量在赋值时使得位于栈上的结构体内的__forwarding指针指向堆内的Block，从内访问同一个且正确的变量。