1.Block是什么

Block是带有自动变量的匿名函数，是C语言的一个扩充功能。Block本质上也是一个OC对象，内部也有一个isa指针，其内部封装了函数调用以及函数调用环境。

Block的定义：

return_type:表示返回的对象/关键字等(可以是void，并省略)
blockName:表示block的名称
var_type:表示参数的类型(可以是void，并省略)
varName:表示参数名称

return_type (^blockName)(var_type) = ^return_type (var_type varName) {
    // ...
};
typedef return_type (^BlockTypeName)(var_type);
@property(nonatomic, copy)return_type (^blockName) (var_type);

关于Block的用法这里不介绍太多，这篇文章主要分析下Block的原理。

二、不截获变量的Block

先来看一个最简单的Block形式：

int(^blockName)(int, int) = ^int(int a, int b){
    return a + b;
}
blockName(3, 5);

通过clang rewrite命令方式改写后：

int(*blockName)(int, int) = ((int (*)(int, int))&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
((int (*)(__block_impl *, int, int))((__block_impl *)blockName)->FuncPtr)((__block_impl *)blockName, 3, 5); 

我们省略掉类型转换后的代码是这样的:

int(*blockName)(int, int) = &__main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA));
(blockName->FuncPtr)(blockName, 3, 5); 

1. 可以看出blockName其实就是__main_block_impl_0类型的对象。
2. __main_block_impl_0通过FuncPtr调用该Block。
   首先先看下__block_impl和__main_block_desc_0这两个结构体：

// block_impl，保存着isa指针和函数地址
struct __block_impl{
    void *isa; // isa指针
    int Flags; // 标记位
    int Reserved;
    void *FuncPtr; // 
}

// block描述
static struct __main_block_desc_0{
    size_t reserved;
    size_t Block_size;
}   __main_block_desc_0_DATA = {0, sizeof(struct __main_block_impl_0)};

接下来是blockName的实现，第一个参数为__main_block_impl_0结构体：

static int __main_block_func_0(struct __main_block_impl_0 *__cself, int a, int b){
    return a +b;
}

最后__main_block_impl_0将上面三个封装起来，就是一个自定义Block了，__main_block_impl_0的定义如下:

struct __main_block_impl_0{
    struct __block_impl impl;
    struct __main_block_desc_0* Desc;
    __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0){
        impl.isa = &_NSConcreteStackBlock;
        impl.Flags = flags;
        impl.FuncPtr = fp;
        Desc = desc;
    }
};

通过__main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA))初始化之后，__main_block_impl_0变成了这样：

{
  impl.isa = &_NSConcreteStackBlock;
  impl.Flags = 0;
  impl.FuncPtr = __main_block_func_0;
  Desc = &__main_block_desc_0_DATA;
}

调用Block的时候最终调用到FuncPtr对应的函数。

三、截获临时变量的Block

int c = 10;
static int d = 5;
int(^blockName)(int, int) = ^int(int a, int b){
    NSLog(@"c:%d, d:%d", c, d);
    return a + b;
}
blockName(3, 5);

这个Block截获了临时变量c和静态变量d，看看不截获变量的Block有何不一样。
首先还是用rewrite以下：

int c = 10;
static int d = 5;
int(*blockName)(int, int) = ((int (*)(int, int))&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, c, &d, 0));
((int (*)(__block_impl *, int, int))((__block_impl *)blockName)->FuncPtr)((__block_impl *)blockName, 3, 5); 

这里可以看出初始化__main_block_func_0的时候，c是传值，而d的则是引用的形式。
__main_block_impl_0的定义：

struct __main_block_impl_0{
    struct __block_impl impl;
    struct __main_block_desc_0* Desc;
    int c;
    int *d;
    __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _c, int *_d, int flags=0) : c(_c), d(_d){
        impl.isa = &_NSConcreteStackBlock;
        impl.Flags = flags;
        impl.FuncPtr = fp;
        Desc = desc;
    }
};

可以看到，结构体里面多了c和d，因为d是静态变量，是一直存在的，所以可以用指针的方式引用。
Block的函数实现：

static int __main_block_func_0(struct __main_block_impl_0 *__cself, int a, int b){
    int c = __cself->c;
    int *d = __cself->d;
    NSLog(@"c:%d, d:%d", c, *d);
    return a +b;
}

通过这个我们就明白了第一个参数的作用，用来获取__main_block_impl_0里面的变量。

四、截获类对象的Block

截获对象的Block：

TestClass *testClass = [TestClass new];
testClass.a = 1；
int(^blockName)(int, int) = ^int(int a, int b){
    NSLog(@"class.a:%d", testClass.a);
    return a + b;
}
blockName(3, 5);

rewrite之后：

int(*blockName)(int, int) = ((int (*)(int, int))&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, testClass, 570425344));
((int (*)(__block_impl *, int, int))((__block_impl *)blockName)->FuncPtr)((__block_impl *)blockName, 3, 5); 

这里testClass是传地址进去的，我们可以猜想Block中也应该用指针引用了该对象。看下__main_block_func_0的实现：

struct __main_block_impl_0{
    struct __block_impl impl;
    struct __main_block_desc_0* Desc;
    TestClass *testClass;
    __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, TestClass *_testClass, int flags=0) : testClass(_testClass){
        impl.isa = &_NSConcreteStackBlock;
        impl.Flags = flags;
        impl.FuncPtr = fp;
        Desc = desc;
    }
};

static int __main_block_func_0(struct __main_block_impl_0 *__cself, int a, int b){
    TestClass *testClass = __cself->testClass;
    NSLog(@"class.a:%d", testClass.a);
    return a +b;
}

跟我们的猜测一样，这样的话Block会把截获到的对象给引用起来，如果该对象有引用该Block的话，那就会造成循环引用。截获到对象的时候，__main_block_desc_0描述是有点不一样的：

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

static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {
    _Block_object_assign((void*)&dst->testClass, (void*)src->testClass, 3/*BLOCK_FIELD_IS_OBJECT*/);
}

static void __main_block_dispose_0(struct __main_block_impl_0*src) {
    _Block_object_dispose((void*)src->testClass, 3/*BLOCK_FIELD_IS_OBJECT*/);
} 

这里的__main_block_desc_0多了copy和dispose两个函数指针，其作用是：
copy和dispose函数中传入的都是__main_block_impl_0结构体本身。
copy本质就是__main_block_copy_0函数，__main_block_copy_0函数内部调用_Block_object_assign函数，_Block_object_assign中传入的是TestClass对象的地址，TestClass 对象，以及8，会将TestClass对象强引用起来。
dispose本质就是__main_block_dispose_0函数，__main_block_dispose_0函数内部调用_Block_object_dispose函数，_Block_object_dispose函数传入的参数是TestClass对象，以及8，结束强引用。

五、截获__weak修饰的变量的Block

为了避免上述所说的循环引用问题，我们一般会在Block传入weak修饰的对象，那么通过weak修饰的变量又是如何在Block中存放的呢？

TestClass *testClass = [TestClass new];
testClass.a = 1；
__weak TestClass *weakClass = testClass;
int(^blockName)(int, int) = ^int(int a, int b){
    NSLog(@"class.a:%d", weakClass.a);
    return a + b;
}
blockName(3, 5);

通过clang rewrite要加上架构才支持weak修饰符，clang -rewrite-objc -fobjc-arc -fobjc-runtime=ios-11.0.0 main.m，改写后的代码如下：

struct __main_block_impl_0{
    struct __block_impl impl;
    struct __main_block_desc_0* Desc;
    TestClass *__weak weakClass;
    __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, TestClass *__weak _weakClass, int flags=0) : weakClass(_weakClass){
        impl.isa = &_NSConcreteStackBlock;
        impl.Flags = flags;
        impl.FuncPtr = fp;
        Desc = desc;
    }
};

static int __main_block_func_0(struct __main_block_impl_0 *__cself, int a, int b){
    TestClass *__weak weakClass = __cself->weakClass;
    NSLog(@"class.a:%d", weakClass.a);
    return a +b;
}

可以看到，__main_block_impl_0和__main_block_func_0中都是以weak修饰符形式存在的，这样就不会强引用起来，也能解决循环引用的问题。

六、截获__block修饰的变量的Block

最后来看下__block修饰符，我们知道通过__block修饰后，可以更改截获到的变量的值。

__block int c = 1;
__weak TestClass *weakClass = testClass;
int(^blockName)(int, int) = ^int(int a, int b){
    c = 2;
    return a + b;
}
blockName(3, 5);

// clang重写后
__attribute__((__blocks__(byref))) __Block_byref_c_0 c = {(void *)0, (__Block_byref_c_0 *)&c, 0, sizeof(__Block_byref_c_0), 1};
int(*blockName)(int, int) = ((int (*)(int, int))&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_c_0 *)&c, 570425344));
((int (*)(__block_impl *, int, int))((__block_impl *)blockName)->FuncPtr)((__block_impl *)blockName, 3, 5); 

我们定义了__block int c = 1，但通过编译器改写后，变成了__Block_byref_c_0 c = {0, (__Block_byref_c_0 *)&c, 0, sizeof(__Block_byref_c_0), 1};，这里面的__Block_byref_c_0定义如下：

struct __Block_byref_c_0{
    void *__isa;
    __Block_byref_c_0 *__forwarding // 初始化默认指向自己;
    int __flags;
    int __size;
    int c;
};

__main_block_impl_0的定义以及Block函数：

struct __main_block_impl_0{
    struct __block_impl impl;
    struct __main_block_desc_0* Desc;
    __Block_byref_c_0 *c;
    __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_c_0 *_c, int flags=0) : c(_c->__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 a, int b){
    __Block_byref_c_0 *c = __cself->c;
    (c->__forwarding->c) = 2;
    return a +b;
}

通过__block修饰后，c已经不是一个变量了，而是一个__Block_byref_c_0对象，对象中保存了这个值，修改的话也是通过这个对象进行修改。

参考资料：

1. Block-ABI-Apple
2. iOS中Block的用法，举例，解析与底层原理