Block原理分析详解

2024年4月16日 134次阅读来源: huang303513

1 基本说明

Block一直是OC的一个重点、难点、黑科技。Block在日常项目中经常使用，他的实现方式和一般的oc代码不一样。同时也很容易出现使用不慎的情况。我们知道OC的本质是C语言+runtime。runtime中的具体实现完全就是汇编加上C语言。而且我们发现大部分都是通过结构体实现的。我们可以通过clang -rewrite-objc main.m 这种命令把包含Block的main.m函数反编译(注意：这里所说的反编译并不是真正的反编译，只是把OC源码转换为对等的C++源码)为为C++的具体实现。下面我就会通过这个命令来分析一下Block转换以后的源码。下面所有列子中转换前的代码都在main.m中，替换后的代码都在mainX.cpp中.

2 void (*block)(void)类型解析

我们先看一下转换以前的代码。顶一个一个block。只定义一个变量i并且赋值为1。对应的文件为mainX.cpp。

int main() {
    void (^blk)(void) = ^(){
        int i = 1;
    };
    blk();
    return 0;
}

下面是转换以后的代码。

struct __block_impl {
    void *isa;
    int Flags;
    int Reserved;
    void *FuncPtr;
};

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {

        int i = 1;
}

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

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

int main() {
    
    void (*blk)(void) = (  (void (*)())  &  __main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA)  );
    
    ((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
    
    return 0;
}

上面是我截取的关键部分源码，其他还有很多辅助性的代码，这里我们就不用管了。看这段代码我们发现一个简单的block的转换成C++以后增加了很多代码：

main函数入口，我们可以发现这个函数里面主要初始化了一个__main_block_impl_0的结构体。并且调用结构体的FuncPtr方法。
__main_block_impl_0结构体。这个结构体有一个__block_impl和__main_block_desc_0结构体。以及一个初始化函数。
__block_impl结构体。这个结构体有四个变量。其中我们可以发现有两个很关键的isa和FuncPtr。
__main_block_desc_0结构体。这个结构体包含了两个size_t类型的属性，主要用于记录Block的内存大小。
__main_block_func_0静态方法，我们发现这个方法就是BLock的具体实现。

2.1具体流程分析

首先main函数代码。

int main() {
    void (*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
    ((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
    return 0;
}

我们把它具体简化以后如下：

    struct __main_block_impl_0 tmp = __main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA);
    struct __main_block_impl_0 *blk = &tmp; 
    (*blk->impl.FuncPtr)(blk);

1首先初始化一个__main_block_impl_0结构体变量。并且传入的参数是__main_block_func_0指向结构体的具体实现。__main_block_desc_0_DATA是__main_block_desc_0结构体的一个变量，主要目的是指定结构体的大小。
2 把tmp的地址赋值给blk指针。
3 通过blk找到他的impl属性，然后再通过impl这个__block_impl变量获取FuncPtr函数的地址。然后传入blk的指针作为参数。从而实现OC中的blk();这句话。

接下来我们看一下__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;
    }
};

这个结构体主要有一个初始化函数，通过传入结构体具体实现的函数指针fp，记录大小描述信息的参数desc，已经一个标记为flags。通过他来初始化__block_impl和__main_block_desc_0。

__block_impl这个结构体我们从他的结构发现和OC的类结构体有点像。他的isa属性其实就是OC的isa属性有异曲同工的作用，用于指向结构体的具体类型。FuncPtr函数指针就是指向Block具体实现的函数。

3 int (*block)(int)类型解析

废话少说，上代码。通过代码我们发现和上面那种没有什么区别。主要是__main_block_func_0函数的实现多了返回值和多了一个参数。具体看代码注释。

int main() {
    int (^blk)(int i) = ^(int i){
        int result =  i + 1;
        return result;
    };
    blk(3);
    return 0;
}
//==============上面是反编译以前的代码==================
struct __block_impl {
    void *isa;//isa表明结构体类型。
    int Flags;
    int Reserved;
    void *FuncPtr;//指向函数指针
};
//这个结构体及时Block反编译以后生成的主要结构。
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;//表示这个Block是存储于栈上。
    impl.Flags = flags;
    impl.FuncPtr = fp;//函数指针赋值
    Desc = desc;
  }
};
//这个函数就是Block的具体实现，并且添加了一个默认实现。
static int __main_block_func_0(struct __main_block_impl_0 *__cself, int i) {
    int result = i + 1;
    return result;
}
//Block的描述信息
static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
};
//__main_block_desc_0的一个实例，其中Block_size初始化为__main_block_impl_0结构体的大小。
struct __main_block_desc_0 __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};

int main() {
    //int (*blk)(int i) = ((int (*)(int))&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
    //上面一行转换为下面两行等价
    struct __main_block_impl_0 tmp = __main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA);
    struct __main_block_impl_0 *blk = &tmp;
    
    //int blkRerurn = ((int (*)(__block_impl *, int))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk, 3);
    //下面一行是上面一行的简化版
    (*blk->impl.FuncPtr)(blk,3);
    return 0;
}

4 带__block变量的void (*block)(void)类型解析

我们发现加入一个带__block标志位的变量以后，代码复杂了很多。具体如下：

多了__Block_byref_i_0结构体。这个结构体就是__block变量i直接生成的。
多了两个函数__main_block_copy_0和__main_block_dispose_0。这两个函数主要用于处理block复制的时候，对应的__block变量i的处理。
__main_block_impl_0结构体多了一个__Block_byref_i_0类型的属性i。这个i就是对应于block里面的变量。
__main_block_desc_0结构体多了两个函数。copy和dispose。在初始化结构体的时候，传入上面新增的两个函数作为参数。
每个__block变量都回生成一个对应的结构体，并且作为__main_block_impl_0结构体的属性。

通过对结构体__main_block_impl_0的初始化函数和__main_block_func_0方法的分析。我们可以得到如下结论：

__block变量i在转换为c语言后直接转换为一个__Block_byref_i_0类型的结构体。
__main_block_impl_0结构体中的i指针用于存储__block结构体变量，也就是block里面的那个i对象。
block外面的那个i其实是block里面的i变量通过i->__forwarding->i来获取的。当我们在block里面改变i的值的时候，其实是间接的通过i->__forwarding->i来改变。其中第一个i是block里面的变量。第二个i是block外边的变量。这样就解释了为什么block里面改变i的值block外面的i改变的原因。
非block类型的变量在block里面是直接引用，不会生成专门的结构体。

同时我们也注意到__main_block_copy_0和__main_block_dispose_0这两个函数，我们虽然不能找到他的具体实现，不过可以根据上下文做一下具体的猜测：

//当我们复制block的时候。分别传入两个block的block变量的指针，然后做处理。
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {
    _Block_object_assign((void*)&dst->one, (void*)src->one, 8);
}
//当我们销毁一个block后，估计会调用这个函数的block变量的指针，做销毁操作
static void __main_block_dispose_0(struct __main_block_impl_0*src) {
    _Block_object_dispose((void*)src->one, 8);
}

完整代码如下：

#include "stdio.h"
#define NORMAL
typedef void (^Block)();
int main() {
    @autoreleasepool {
        __block int i = 1;
        Block block1 = ^(){
            i =  2;
            printf("%d",i);
        };
        block1();
    }
    return 0;
}
//==============上面是反编译以前的代码==================
typedef void (*Block)();

struct __block_impl {
    void *isa;
    int Flags;
    int Reserved;
    void *FuncPtr;
};
//这个结构体是专门为了__block变量i生成的。
struct __Block_byref_i_0 {
  void *__isa;
__Block_byref_i_0 *__forwarding;
 int __flags;
 int __size;
 int i;
};
//多了一个__Block_byref_i_0变量
struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __Block_byref_i_0 *i; // 多了一个i属性。block变量
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_i_0 *_i, int flags=0) : i(_i->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
//Block的具体实现。从这里我们发现为啥改变i的值的猫腻。
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  __Block_byref_i_0 *i = __cself->i; // bound by ref

            (i->__forwarding->i) = 2;
            printf("%d",(i->__forwarding->i));
        }
//用于管理i变量的声明周期。复制一个block的时候，复制他对应的i变量。
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*/);
}
//多了两个指针函数、
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*);
};
//实例变量
 struct __main_block_desc_0 __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0), __main_block_copy_0, __main_block_dispose_0};
//入口
int main() {
    //自动释放池，这里暂不管他
     {__AtAutoreleasePool __autoreleasepool;
         
#ifdef NORMAL
     __attribute__((__blocks__(byref))) __Block_byref_i_0 i;
     i = {(void*)0,(__Block_byref_i_0 *)&i, 0, sizeof(__Block_byref_i_0), 1};
         
      Block block1 = ((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 *)block1)->FuncPtr)((__block_impl *)block1);
#else
         //定义一个__Block_byref_i_0结构体变量。并且初始化
         __Block_byref_i_0 i;
         i = {(void*)0,(__Block_byref_i_0 *)&i, 0, sizeof(__Block_byref_i_0), 1};
       //定义一个__main_block_impl_0结构体变量，同时传入i的指针
        __main_block_impl_0 tmp = __main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_i_0 *)&i, 570425344);
         //把结构体变量的指针赋值给block1对象
        Block block1 = &tmp;
         //调用解耦固体。就是OC里面的`block1()`
         ((*block1->impl)->FuncPrt)(block1);
#endif
    }
    return 0;
}

5 带全局变量、静态全局变量、局部全局变量类型的Block解析

从转换以前和转换以后的代码比较。发现__block变量和上面一样，这里就不做具体分析了。但是对于几个非__block变量则有不同情况：

全局变量global_val和静态全局变量static_global_val转换以前和转换以后调用方式没有任何区别。
局部静态变量static_val会作为结构体__main_block_impl_0的一个属性。并且这个属性是局部静态变量的一个指针。
当改变局部静态变量的值的时候，我们通过__main_block_impl_0结构体的static_val属性拿到静态局部变量的指针，然后直接赋值。
Block直接截取的值静态局部变量的指针。然后对指针操作。

int global_val = 1;
static int static_global_val = 2;
int main() {
    @autoreleasepool {
        __block int one = 1;
        static int static_val = 2;
        Block block1 = ^(){
            one =  2;
            global_val = global_val + 1;
            static_global_val = static_global_val + 1;
            static_val = static_val + 1;
            printf("%d--%d--%d--%d",one,global_val,static_global_val,static_val);
        };
        block1();
    }
    return 0;
}
//==============上面是反编译以前的代码==================

typedef void (*Block)();
//全局变量和静态全局变量的用法没有任何转变。
int global_val = 1;
static int static_global_val = 2;
struct __block_impl {
    void *isa;
    int Flags;
    int Reserved;
    void *FuncPtr;
};

struct __Block_byref_one_0 {
  void *__isa;
__Block_byref_one_0 *__forwarding;
 int __flags;
 int __size;
 int one;
};

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  int *static_val;//局部静态变量的指针作为结构体的一个属性
  __Block_byref_one_0 *one; // by ref
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int *_static_val, __Block_byref_one_0 *_one, int flags=0) : static_val(_static_val), one(_one->__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_one_0 *one = __cself->one; // bound by ref
  int *static_val = __cself->static_val; // bound by copy
    (one->__forwarding->one) = 2;
    global_val = global_val + 1;
    static_global_val = static_global_val + 1;
    (*static_val) = (*static_val) + 1;
    printf("%d--%d--%d--%d",(one->__forwarding->one),global_val,static_global_val,(*static_val));
}

static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {
    _Block_object_assign((void*)&dst->one, (void*)src->one, 8/*BLOCK_FIELD_IS_BYREF*/);
}

static void __main_block_dispose_0(struct __main_block_impl_0*src) {
    _Block_object_dispose((void*)src->one, 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() {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 
        __attribute__((__blocks__(byref))) __Block_byref_one_0 one = {(void*)0,(__Block_byref_one_0 *)&one, 0, sizeof(__Block_byref_one_0), 1};
        static int static_val = 2;
        
        //Block block1 = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, &static_val, (__Block_byref_one_0 *)&one, 570425344));
        //上面这行转换为下面这行
        __main_block_impl_0 tmp = __main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, &static_val, (__Block_byref_one_0 *)&one, 570425344);
        Block block1 = (void (*)())&tmp;
        
        ((void (*)(__block_impl *))((__block_impl *)block1)->FuncPtr)((__block_impl *)block1);
    }
    return 0;
}

6 总结

通过测试、我发现同一种类型的Block实例变量，会分别生成对应的__main_block_impl_X,__main_block_func_X,__main_block_desc_X,__main_block_copy_X,__main_block_dispose_X。但是会共用相同的__block_impl。如果多个Block(不管是不是同一种类型)使用同一个__block变量，则会共享相同的__Block_byref_YYY_X结构体。

把一个Block变量赋值给另一个Block变量。则相当于被复制的Block变量有两个引用，并不会生成一套对应的结构体。

判断Block是不是同一种类型，只与返回变量、参数类型相关。与通过宏定义的名字无关。

源码链接源码地址。博客地址

    原文作者：huang303513
    原文地址: https://segmentfault.com/a/1190000009043868
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。