在OC语言中，一共有3中类型的block：

1. _NSConcreteGlobalBlock，全局的静态block，不会访问任何外部变量
2. _NSConcreteStackBlock，保存在栈中的block，当函数返回时会被销毁
3. _NSConcreteMallocBlock，保存在堆中的block，当引用计数为0时会被销毁

1、用clang分析block实现

clang提供了一个命令，可以将OC的源码改写成C语言，借此可以研究block具体的源码实现方式：

clang -rewrite-objc block.c

1.1 NSConcreteGlobalBlock

创建文件block1.c，实例代码如下：

//block1.c
#include <stdio.h>
int main (){
  ^{printf("Hello, World!\n");}();
  return 0;
}

解析命令：clang -rewrite-objc block1.c即可在当前目录创建一个名为block1.cpp的文件：

image.png 该文件就是block在C语言中的实现，关键代码如下：

struct __block_impl {
  void *isa;//block的isa指针
  int Flags;
  int Reserved;
  void *FuncPtr;//函数指针
};

struct __main_block_impl_0 {
//block的实现
  struct __block_impl impl;//FuncPtr保存函数指针，所以impl是实际的函数指针
  struct __main_block_desc_0* Desc;//block的附加信息，包括结构体的大小，需要capture和dispose的变量列表等
//构造函数
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) {
    impl.isa = &_NSConcreteStackBlock;
    //未开启arc，开启arc时，block应该是_NSConcreteGlobalBlock
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
printf("Hello, World!\n");
}

static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;//保存结构体的大小。每个block会capture一些变量，这些变量会加到结构体__main_block_impl_0中，使其体积变大。
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};

int main (){
    ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA))();
//函数_main_block_func_0，block中impl中保存了其地址(指针)
  return 0;
}

开启arc时，block应该是_NSConcreteGlobalBlock！！！

1.2 NSConcreteStackBlock

我们另外新建一个名为"block2.c"的文件：

#include <stdio.h>

int main (){
   int a = 100;
   void (^block2)(void) = ^{
     printf("%d\n",a);
   };
   block2();
   return 0;
}

转换后的关键代码如下：

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  int a; //block中定义了同名变量，用来保存外部传入的变量。所以，在block内部修改变量a，不会影响外部的实际变量a
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _a, int flags=0) : a(_a) {//给block中同名变量赋值
    impl.isa = &_NSConcreteStackBlock;//分配在栈上的实例
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
//实际执行的函数，block保存了函数的地址(指针)
  int a = __cself->a; // bound by copy

     printf("%d\n",a);
   }

static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;//多了一个变量a，结构体变大了
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};
int main (){
   int a = 100;
   void (*block2)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, a));
//将外部的变量a作为形参传入
   ((void (*)(__block_impl *))((__block_impl *)block2)->FuncPtr)((__block_impl *)block2);
   return 0;
}

我们修改上面的源码，在变量前面增加__block关键字：

#include <stdio.h>

int main (){
   __block int i = 1024;
   void (^block3)(void) = ^{
     printf("%d\n",i);
       i = 1023;
   };
   block3();
   return 0;
}

生成的关键代码如下，与之前的差异还是比较大的：

//新增了一个结构体，用来保存我们要capture并且修改的变量i
struct __Block_byref_i_0 {
  void *__isa; //带有isa，说明它也是一个变量
__Block_byref_i_0 *__forwarding; //指向外部的变量
 int __flags;
 int __size;
 int I;
};

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __Block_byref_i_0 *i; // 引用了__Block_byref_i_0指针，可以起到修改外部变量的作用
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_i_0 *_i, int flags=0) : i(_i->__forwarding) {//外部变量赋值给内部变量的__forwarding指针，这样可以通过修改__forwarding来修改外部变量
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  __Block_byref_i_0 *i = __cself->i; // bound by ref

     printf("%d\n",(i->__forwarding->i));
       (i->__forwarding->i) = 1023; //通过__forwarding指针，修改外部的变量
   }
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->i, (void*)src->i, 8/*BLOCK_FIELD_IS_BYREF*/);}//修改内部变量i的引用计数

static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->i, 8/*BLOCK_FIELD_IS_BYREF*/);}//修改内部变量i的引用计数

static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
//block需要负责__Block_byref_i_0结构体相关的内存管理，所以__main_block_desc_0中增加了copy和dispose函数指针，用于在调用前后修改响应变量的引用计数
  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 (){
   __attribute__((__blocks__(byref))) __Block_byref_i_0 i = {(void*)0,(__Block_byref_i_0 *)&i, 0, sizeof(__Block_byref_i_0), 1024};
//(__Block_byref_i_0 *)&I，传入的是外部变量的指针
   void (*block3)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_i_0 *)&i, 570425344));
   ((void (*)(__block_impl *))((__block_impl *)block3)->FuncPtr)((__block_impl *)block3);
   return 0;
}

1.3 NSConcreteMallocBlock

NSConcreteMallocBlock类型的block通常不会在源码中直接出现，只有当一个block被调用其copy方法的时候，系统才会将这个block复制到堆中，从而产生NSConcreteMallocBlock类型的block。

看似最为神秘的NSConcreteMallocBlock其实就是一个block被copy，代码示例如下： stack malloc

NSConcreteMallocBlock会持有对象：

- (void)viewDidLoad {
    [super viewDidLoad];
    
    NSObject *object = [[NSObject alloc] init];
    NSLog(@"最初的引用计数%lu", object.retainCount);
    void(^block)(void) = Block_copy(^(){
        NSLog(@"在block中的引用计数%lu",object.retainCount);
    });
    NSLog(@"block的类型%@",block);
    block();
    NSLog(@"执行后的引用计数%lu",object.retainCount);
    Block_release(block);
    NSLog(@"释放后的引用计数%lu",object.retainCount);
}

需要设置上述文件支持mrc：

image.png
在arc下直接打印引用计数：CFGetRetainCount((__bridge CFTypeRef)(obj)))
上述代码段打印结果如下： image.png
当我们不使用Block_copy，即：

    void(^block)(void) =^(){
        NSLog(@"在block中的引用计数%lu",object.retainCount);
    };

这是代码段打印结果如下： image.png

由上可知：只要这个NSConcreteMallocBlock存在，内部对象的引用计数就会+1。

block的copy和release位于block.h头文件中： block.h image.png

扩展：block_copy

2、block内部数据结构

上述的block源码都是基于clang编译器转换后的代码，而从苹果的llvm项目的开源代码中，我们可以看到block的数据结构定义：

blockRuntime
block
对应的结构体定义如下：

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


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

一个block实例实际上由6部分构成：

1. isa指针，所有对象都有该指针，用于实现对象相关的功能
2. flags，用于按bit位表示一些block的附加信息
3. reserved，保留变量
4. invoke，函数指针，指向具体的block实现的函数调用地址，相当于clang编译器下的impl，命名不一样而已！
5. descriptor，表示该block的附加描述信息，主要是size大小，以及copy和dispose函数的指针
6. variables，capture过来的变量，block能够访问它外部的局部变量，就是因为将这些变量(或变量的地址)复制到了结构体中
   该数据结构和clang分析出来的结构实际上是一样的，仅仅是结构体的嵌套方式不一样。比如，下面两个结构体的嵌套方式不一样，但是在内存上是完全一样的，原因是结构体本身并不带有任何额外的附加信息：

struct SampleA {
    int a;
    int b;
    int c;
};

struct SampleB{
   int a;
   struct Part1 {
          int b;
   };
   struct Part2{
         int c;
   };
}

3、注意事项

3.1 避免循环引用

由于block会复制外部的变量，所以如果不注意，会比较容易造成循环引用：

UIViewController *__weak weakSelf = self;
self.contentView.selectedBlock = ^(UITableView *tableView, NSIndexPath *indexPath){
      [weakSelf  someMethod];
};

3.2 ARC对block类型的影响

在ARC开启的情况下，将只会有NSConcreteGlobalBlock和NSConcreteMallocBlock类型的block，原本的NSConcreteStackBlock的block会被NSConcreteMallocBlock类型的block替代，在苹果的官方文档中也提到，当把栈中的block返回时，就不需要调用copy方法了：

        int i = 1024;
        NSLog(@"%@",^{//直接打印stack
            NSLog(@"%d\n", i); 
        });
        void (^block1)(void) = ^{//创建后返回，malloc
            NSLog(@"%d\n", i);
        };
//        block1();
        NSLog(@"%@", block1);

打印结果如下：

image.png