iOS-block本质是什么？

一: block的原理是怎样的?本质是什么?

• block本质上也是一个OC对象,因为它的内部也有个isa指针
• block是封装了函数调用以及函数调用环境的OC对象

接下来我们将通过底层源码来论证上诉两点.

首先我们写一个简单的block,通过clang编译器编译成C++代码,查看一下block的底层机构:

 

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        int age = 10;
        int height = 10;
        //声明block变量
        void(^myBlock)(void) = ^{
            NSLog(@"age is %d height is %d",age,height);
        };
        //调用block
        myBlock();
    }
    return 0;
}

通过clang编译器执行编译成C++代码:

 

xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m

clang编译器编译完后会得到一个.cpp格式的文件,这就是我们刚才转换的.m文件的底层代码.我们打开.cpp文件,差不多有三万多行代码,我们直接拖到最下面,找到block相关的代码.如下

一: block底层数据结构

// 一: block底层数据结构
struct __main_block_impl_0 {
    struct __block_impl impl; // 1: impl 结构体
    struct __main_block_desc_0* Desc; // 2: block描述信息的结构体
    int age; //3:捕获的外部变量
    int height;
    //4: 和结构体同名的构造函数 ( C++语法 , 类似于 OC 的init方法,返回一个结构体对象,类似于返回self)
    __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _age, int _height, int flags=0) : age(_age), height(_height) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

通过底层代码我们可以看到,block在底层中的数据结构是一个结构体,这个结构体有四个部分组成:

1: struct __block_impl

2: struct __main_block_desc_0

3: 捕获的外部变量

4:和block结构体同名的构造函数

我们找到struct __block_impl 结构体:

//struct __block_impl 结构体
struct __block_impl {
  void *isa; //指向 block 的类型
  int Flags;//按位表示block的附加信息
  int Reserved;//保留变量
  void *FuncPtr; //封装了执行 block 代码块的函数地址
};

然后我们再找到struct __main_block_desc_0 结构体 :

static struct __main_block_desc_0 {
  size_t reserved;//保留变量大小
  size_t Block_size;//block所占用的大小
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};

这3个结构体之间的关系就像下图这样:

 

我们在网上看到的一张很经典的block底层结构的图片就是把这两个结构体成员列表汇总进去得到的:(descriptor结构体中的copy 和 dispose 我们后面会讲到)

 

二:  main函数 （block 捕获局部变量（auto变量）捕获到内部 值传递）

// 1: main函数
int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
        int age = 10;
        int height = 10;
        //声明block变量
        void(*myBlock)(int ,int) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, age, height));
        //调用block
        ((void (*)(__block_impl *))((__block_impl *)myBlock)->FuncPtr)((__block_impl *)myBlock);
    }
    return 0;
}

这段底层代码中,声明block和调用block的部分涉及了太多的类型转换,不便于阅读理解,我们去掉类型转换的部分,简化如下:

// : main函数
int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
        int age = 10;
        int height = 10;
        //声明block
void(*myBlock)(void) = &__main_block_impl_0(//调用block数据结构中的同名的构造函
                                __main_block_func_0,//封装了block要执行的代码块的函数
                                &__main_block_desc_0_DATA,//block描述信息的结构体
                                age,//把局部变量当做参数传入
                                height
                                );
        //调用block
        myBlock->FuncPtr(myBlock);
    }
    return 0;
}

可以看到,我们在申明block的时候,调用block的构造函数,传入了四个参数,分别是__main_block_func_0 , __main_block_desc_0_DATA , age , height,我们对比着它的构造函数,看看它的内部都做了什么:

 

// block底层数据结构
struct __main_block_impl_0 {
    struct __block_impl impl; // 1: impl 结构体
    struct __main_block_desc_0* Desc; // 2: block描述信息的结构体
    int age;//3: 捕获的外部变量
    int height;
    //4: 同名的构造函数 ( C++语法 )
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _age, int _height, int flags=0) : age(_age), height(_height)  {
    impl.isa = &_NSConcreteStackBlock; //isa 指向了block的类型
    impl.Flags = flags;//按位表示block的一些附加信息,这里是0
    impl.FuncPtr = fp; // 封装了block要执行的代码块的函数
    Desc = desc; //block描述信息的结构体
  }
};

• 首先,构造函数的内部会给impl结构体的isa指针赋值,决定block的类型;
• 然后,再把传进来的__main_block_func_0传给了fp,又把fp赋值给了impl结构体的FuncPtr,__main_block_func_0这个函数指针指向封装了block代码块的函数地址;
• 最后,再把传进来的__main_block_desc_0_DATA结构体赋值给了Desc;
  
  其实这里还隐藏了一个很重要的一步,只是底层代码上没有体现出来:在构造函数的内部,会自动把传递进来_age,_height自动赋值给我们block内部的age,height,这就是block的捕获机制.

我们来分别看一下__main_block_func_0,__main_block_desc_0_DATA这两个结构体长什么样子:

• __main_block_func_0 结构体: block 真正要执行的代码块

// 封装了block要执行的代码块的函数
static void __main_block_func_0(struct __main_block_impl_0 *__cself, int a, int b) {

 NSLog((NSString *)&__NSConstantStringImpl__var_folders_5t_pxd6sp5x6rl9gnk21q2q934h0000gn_T_main_b680e8_mi_0,a,b);

        }

可以看到,就是我们.m中写的很简单的一句NSLog语句.说明block的代码块确实是封装成了一个函数去执行的.

• __main_block_desc_0_DATA:

 

static struct __main_block_desc_0 {
  size_t reserved;//保留变量的大小
  size_t Block_size;//block的大小
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};

这个结构体中主要就是一个size_t Block_size 存放了block的大小.

三、总结:

• block的底层就是一个struct _block_impl_0类型的结构体,这个结构体中包含一个isa指针,所以从更深的层次来说,block就是一个OC对象.

• block结构体中又包含impl和Desc结构体,impl结构体中有一个非常重要的成员FuncPtr,FuncPtr是一个指针,指向了封装了blcok代码块的函数,
  我们看到调用block的代码:myBlock()的底层实际上是这样子:myBlock->FuncPtr(myBlock);,可以看出调用block其实就是调用了FuncPtr()这个函数

• Desc结构体存放了block的大小

参考链接：https://www.jianshu.com/p/e6759404f9cd