Block源码分析

1.什么是Block

Block是带有自动变量（局部变量）的匿名函数。Block的内部数据结构如下：

struct Block_layout {
    void *isa;
    int flags;
    int reserved;
    void (*invoke)(void *, ...);
    struct Block_descriptor *descriptor;
    /* Imported variables. */
};

struct Block_descriptor {
    unsigned long int reserved;
    unsigned long int size;
    void (*copy)(void *dst, void *src);
    void (*dispose)(void *);
};

isa指针：指向表明该block类型的类。
flags：按bit位表示一些block的附加信息，比如判断block类型、判断block引用计数、判断block是否需要执行辅助函数等。
reserved：保留变量，我的理解是表示block内部的变量数。
invoke：函数指针，指向具体的block实现的函数调用地址。
descriptor：block的附加描述信息，比如保留变量数、block的大小、进行copy或dispose的辅助函数指针。
variables：因为block有闭包性，所以可以访问block外部的局部变量。这些variables就是复制到结构体中的外部局部变量或变量的地址。

2.block类型

C/C++/OC编译的程序占用内存分布的结构如下：

image.png

栈区（stack）：由系统自动分配，一般存放函数参数值、局部变量的值等。由编译器自动创建与释放。其操作方式后进先出、先进后出。
堆区（heap）：一般由程序员申请并指明大小，最终也由程序员释放。如果程序员不释放，程序结束时可能会由OS回收。对于堆区的管理是采用链表式管理的，操作系统有一个记录空闲内存地址的链表，当接收到程序分配内存的申请时，操作系统就会遍历该链表，遍历到一个记录的内存地址大于申请内存的链表节点，并将该节点从该链表中删除，然后将该节点记录的内存地址分配给程序。
全局区/静态区：全局变量和静态变量存储在这个区域。程序结束后由系统释放。
程序代码区：主要存放函数体的二进制代码。

block按照不同的内存区域可以分为：

_NSConcreteStackBlock，存放在栈区。只用到外部局部变量、成员属性变量，且没有强指针引用的block。
StackBlock的生命周期由系统控制的，一旦返回之后，就被系统销毁了。
_NSConcreteMallocBlock，存放在堆区。有强指针引用或copy修饰的成员属性引用的block会被复制一份到堆中成为MallocBlock，没有强指针引用即销毁，生命周期由程序员控制。
_NSConcreteGlobalBlock，存放在全局/静态区。没有用到外界变量或只用到全局变量、静态变量的block，生命周期从创建到应用程序结束。

int globalNum = 3;
int main(int argc, const char * argv[]) {
    int a = 3;
    NSLog(@"this block is: %@",^{NSLog(@"I use nothing");});
    NSLog(@"this block is: %@",[^{NSLog(@"I use ivar %d",a);} copy]);
    NSLog(@"this block is: %@",^{NSLog(@"I use ivar %d",a);});
    NSLog(@"this block is: %@",^{NSLog(@"%d",globalNum);});
    return 0;
}

其输出结果如下：

2017-12-26 09:01:27.668046+0800 BlockDemo[98660:1165488] this block is: <__NSGlobalBlock__: 0x100001050>
2017-12-26 09:01:27.668246+0800 BlockDemo[98660:1165488] this block is: <__NSMallocBlock__: 0x100507f80>
2017-12-26 09:01:27.668293+0800 BlockDemo[98660:1165488] this block is: <__NSStackBlock__: 0x7fff5fbfefe0>
2017-12-26 09:01:27.668367+0800 BlockDemo[98660:1165488] this block is: <__NSGlobalBlock__: 0x1000010d0>

注意：在ARC的作用下，block类型通过=进行传递时，会导致objc_retainBlock->_Block_copy->_Block_copy_internal方法链，导致__NSStackBlock__类型的block转换为__NSMallocBlock__类型。

3. block的实现原理

用clang工具重写为c++代码来探究一下block的内部实现。
测试代码如下：

typedef int(^blk)(int);

int globalNum = 3;
int main(int argc, const char * argv[]) {
    int a = 3;
    __block int blockVar = 3;
    static int staticNum = 3;
    blk blk = ^(int count) {
        NSLog(@"a = %d", a);
        staticNum --;
        globalNum --;
        blockVar --;
        return count * a * globalNum * staticNum;
    };
    a = 10;
    NSLog(@"%d", blk(1));
    return 0;
}

clang重写c++后的代码如下：

typedef int(*blk)(int);

int globalNum = 3;
struct __Block_byref_blockVar_0 {
  void *__isa;
  __Block_byref_blockVar_0 *__forwarding;
 int __flags;
 int __size;
 int blockVar;
};

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  int a;
  int *staticNum;
  __Block_byref_blockVar_0 *blockVar; // by ref
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _a, int *_staticNum, __Block_byref_blockVar_0 *_blockVar, int flags=0) : a(_a), staticNum(_staticNum), blockVar(_blockVar->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static int __main_block_func_0(struct __main_block_impl_0 *__cself, int count) {
  __Block_byref_blockVar_0 *blockVar = __cself->blockVar; // bound by ref
  int a = __cself->a; // bound by copy
  int *staticNum = __cself->staticNum; // bound by copy

    NSLog((NSString *)&__NSConstantStringImpl__var_folders_03_v9qmb8t568sgwcjv8bj5ng380000gn_T_main_6b603d_mi_0, a);
    (*staticNum) --;
    globalNum --;
    (blockVar->__forwarding->blockVar) --;
    return count * a * globalNum * (*staticNum);
}
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->blockVar, (void*)src->blockVar, 8/*BLOCK_FIELD_IS_BYREF*/);}

static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->blockVar, 8/*BLOCK_FIELD_IS_BYREF*/);}

static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
  void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*);
  void (*dispose)(struct __main_block_impl_0*);
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0), __main_block_copy_0, __main_block_dispose_0};

int main(int argc, const char * argv[]) {
    int a = 3;
    __attribute__((__blocks__(byref))) __Block_byref_blockVar_0 blockVar = {(void*)0,(__Block_byref_blockVar_0 *)&blockVar, 0, sizeof(__Block_byref_blockVar_0), 3};
    static int staticNum = 3;
    blk blk = ((int (*)(int))&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, a, &staticNum, (__Block_byref_blockVar_0 *)&blockVar, 570425344));
    a = 10;
    NSLog((NSString *)&__NSConstantStringImpl__var_folders_03_v9qmb8t568sgwcjv8bj5ng380000gn_T_main_6b603d_mi_1, ((int (*)(__block_impl *, int))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk, 1));
    return 0;
}

我们看到block其实就是struct __main_block_impl_0 结构体，它由4个成员变量和一个构造函数组成。
其中第一个成员变量是__block_impl结构体，指向的是__main_block_func_0函数。
第二个成员变量是__main_block_desc_0结构体，负责管理block的内存管理。__main_block_copy_0和__main_block_dispose_0就是利用OC的runtime进行内存管理。在Block中使用 __strong或者__block修饰符的id类型或对象类型的自动变量时，当block从栈复制到堆时，当对象需要retain的时候调用__main_block_copy方法增加引用计数，当需要释放的时候则调用__main_block_dispose方法释放对象。
第三个是int变量。因为block内部引用了外部的自动变量，所以在block结构体中多了一个同类型的成员变量。
第四个是捕获到的静态变量。
第五个是__block修饰符的变量。具体介绍看下一节。

__main_block_func_0包含了block的内部代码。其中包含了一个参数__cself，指向__main_block_impl_0，及匿名block自身。这种写法类似与OC中的方法消息传递。
另外可以看到系统加的注释bound by copy，自动变量通过__cself->val方式捕获。局部变量传入的是值，静态变量传入的是地址。因此局部变量无法更改，而静态变量可以更改。同时全局变量由于作用域大，因此不需要传入就可以自由的在block内部更改。而__block修饰符的变量是通过bound by ref方式被捕获进来的，具体介绍看下一节。

image.png

4. __block 修饰符

我们直到，当想要修改block外面的局部变量时，需要用__block修饰符。那么__block的原理是如何的呢。
从上面的转换代码中可以看到，带有__block修饰符的局部变量被转换为一个结构体__Block_byref_blockVar_0。这个结构体有5个成员变量。

__isa，isa指针
__forwarding，指向自身类型的指针
__flags，标记
__size，结构体大小
__blockVar，局部变量

struct __Block_byref_blockVar_0 {
  void *__isa;
  __Block_byref_blockVar_0 *__forwarding;
  int __flags;
  int __size;
  int blockVar;
};

从代码中我们可以看到blockVar->__forwarding->blockVar这样的方式来对__block修饰的变量进行操作，但是为什么要搞这么复杂呢？
__forwarding 指针就是针对堆里的block。把原来指向自己的__forwarding指针指向堆上的__block变量。然后堆上的变量的__forwarding指向自己。

image.png

5. Block中的循环引用

循环引用，就是相互引用。比如A强引用B，B又强引用A。那么A和B的引用计数永远无法为0，造成内存泄漏。当然这种循环也可以是多个对象间的。

image.png

而对于block的循环引用，一般是一个对象引用block，而block内部又引用了这个对象。
打破这种循环引用一般有两种方法：1.弱引用；2.主动释放

image.png

5.1 弱引用

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

5.2 主动释放

__block id blockSelf = self;
self.blk = ^{
    NSLog(@"%@",blockSelf);
    blockSelf = nil;
};
self.blk();

当然，弱引用和主动释放各有缺点：
主动释放的缺点：

必须执行block才能避免循环引用

弱引用的缺点：

不能保证self对象是否已经被销毁

当然对于弱引用，可以利用weak-strong-dance来保证不会出现因为self释放引起问题。

__weak typeof(self) weakSelf = self;
self.blk = ^{
    __strong typeof(weakSelf) strongSelf = weakSelf;
    NSLog(@"%@",strongSelf);
};

6. 参考链接

1.深入研究Block捕获外部变量和__block实现原理
 2.老司机出品——源码解析之从Block说开去
 3.A look inside blocks: Episode 1
4.A look inside blocks: Episode 2