浓厚解构iOS的block闭包实现原理

在iOS4出来后,苹果公司在OC中出产了block机制(也许更已经有了)。并且在继承的版本中大量的加大和行使了这项技艺,比如对视图动画API的改版,比如GCD技术等等。block技术并不是怎么新技巧,他的实质就是闭包功能在iOS上的实现而已。而闭包效能在其他许多言语中都有落实,比如JAVA中接口的匿名实现。用闭包可以解决这个履行逻辑和上下文环境解耦的现象,倘若从设计情势的角度来考虑的话闭包就是一种策略格局(Strategy)的实现。

本文并不追究怎样采用block,而是讨论OC的block机制是何许实现的。从代码的角度来说block的面世和大家从来基于函数和类措施的编程形式不太一样,有时候仍旧不佳去明白,因为他能够在我们的代码块中定义代码块,而且新定义的代码块又不会按函数内的吩咐顺序去实施。大家得以大胆的考虑,淌倘使要你去实现一套block机制,你会怎么去做?这也是本文要探讨的事物,唯有你通晓了OC实现block的内幕,你才可以更好的采用她。

写这篇小说来分析原理时自己隐去了有的细节,而且有些结构体的定义也和实事求是的有差异,不过总体是无可非议的,目标是为着更好的问询到实质的东西。大家先来看上边一段含有block的OC代码:

//文件test.m
#import <Foundation/Foundation.h>
void test()
{
    //下面分别定义各种类型的变量
     int a = 10;                       //普通变量
    __block int b = 20;                //带__block修饰符的block普通变量
    NSString *str = @"123"; 
    __block NSString *blockStr = str;  //带__block修饰符的block OC变量
    NSString *strongStr = @"456";      //默认是__strong修饰的OC变量
    __weak NSString *weakStr = @"789"; //带__weak修饰的OC变量

  //定义一个block块并带一个参数
    void (^testBlock)(int) = ^(int c){
         int  d = a + b + c;
         NSLog(@"d=%d, strongStr=%@, blockStr=%@, weakStr=%@", d, strongStr, blockStr, weakStr);
     };

    a = 20;  //修改值不会影响testBlock内的计算结果
    b = 40;  //修改值会影响testBlock内的计算结果。
    testBlock(30);  //执行block代码。
}

下边的代码片段中,我们独家定义了:

  • 不带修饰符的主旨项目变量a
  • 带__block修饰符的block变量b和blockStr
  • 默认带__strong修饰符的变量strongStr
  • 带__weak修饰符的变量weakStr

那些修饰符关键字的使用会对block块内的代码在运作时发出不同的影响。就地点的代码片段而言当我们在编译时,编译器到底做了怎样处理?倘使可以领会到编译器的编译过程,那么对大家精晓其实现机制就特别有协理。幸好我们可以凭借命令来探望那一个当中的长河,您可以打开终端控制台,并到test.m文件所在的路径下执行如下的通令:

   clang  -rewrite-objc  test.m

clang那些命令会在平等目录下发出一个test.cpp的文件。这么些文件是OC代码的C++实现版本,因为我们精晓C++是不襄助闭包技术的,因而你可以因而查阅test.cpp这一个文件来打听到OC中的闭包技术到底是哪些用函数和协会体来实现的。(注意下面的通令执行时会报错,指示不协理__weak类型的概念,我当下从不找到解决方法,暂时是把
__weak修饰符去掉)
。我们得以先来探望test.cpp的部分实现:

struct __Block_byref_b_0 {
  void *__isa;
__Block_byref_b_0 *__forwarding;
 int __flags;
 int __size;
 int b;
};
struct __Block_byref_blockStr_1 {
  void *__isa;
__Block_byref_blockStr_1 *__forwarding;
 int __flags;
 int __size;
 void (*__Block_byref_id_object_copy)(void*, void*);
 void (*__Block_byref_id_object_dispose)(void*);
 NSString *blockStr;
};

struct __test_block_impl_0 {
  struct __block_impl impl;
  struct __test_block_desc_0* Desc;
  int a;
  NSString *strongStr;
  NSString *weakStr;
  __Block_byref_b_0 *b; // by ref
  __Block_byref_blockStr_1 *blockStr; // by ref
  __test_block_impl_0(void *fp, struct __test_block_desc_0 *desc, int _a, NSString *_strongStr, NSString *_weakStr, __Block_byref_b_0 *_b, __Block_byref_blockStr_1 *_blockStr, int flags=0) : a(_a), strongStr(_strongStr), weakStr(_weakStr), b(_b->__forwarding), blockStr(_blockStr->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __test_block_func_0(struct __test_block_impl_0 *__cself, int c) {
  __Block_byref_b_0 *b = __cself->b; // bound by ref
  __Block_byref_blockStr_1 *blockStr = __cself->blockStr; // bound by ref
  int a = __cself->a; // bound by copy
  NSString *strongStr = __cself->strongStr; // bound by copy
  NSString *weakStr = __cself->weakStr; // bound by copy



        int d = a + (b->__forwarding->b) + c;

        NSLog((NSString *)&__NSConstantStringImpl__var_folders_d6_rtk49g5s52g_m2sgrvm0b5q00000gn_T_main_5b81f9_mi_3, d, strongStr, (blockStr->__forwarding->blockStr), weakStr);

    }
static void __test_block_copy_0(struct __test_block_impl_0*dst, struct __test_block_impl_0*src) {_Block_object_assign((void*)&dst->b, (void*)src->b, 8/*BLOCK_FIELD_IS_BYREF*/);_Block_object_assign((void*)&dst->strongStr, (void*)src->strongStr, 3/*BLOCK_FIELD_IS_OBJECT*/);_Block_object_assign((void*)&dst->blockStr, (void*)src->blockStr, 8/*BLOCK_FIELD_IS_BYREF*/);_Block_object_assign((void*)&dst->weakStr, (void*)src->weakStr, 3/*BLOCK_FIELD_IS_OBJECT*/);}

static void __test_block_dispose_0(struct __test_block_impl_0*src) {_Block_object_dispose((void*)src->b, 8/*BLOCK_FIELD_IS_BYREF*/);_Block_object_dispose((void*)src->strongStr, 3/*BLOCK_FIELD_IS_OBJECT*/);_Block_object_dispose((void*)src->blockStr, 8/*BLOCK_FIELD_IS_BYREF*/);_Block_object_dispose((void*)src->weakStr, 3/*BLOCK_FIELD_IS_OBJECT*/);}

static struct __test_block_desc_0 {
  size_t reserved;
  size_t Block_size;
  void (*copy)(struct __test_block_impl_0*, struct __test_block_impl_0*);
  void (*dispose)(struct __test_block_impl_0*);
} __test_block_desc_0_DATA = { 0, sizeof(struct __test_block_impl_0), __test_block_copy_0, __test_block_dispose_0};
void test()
{


    int a = 10;
    __attribute__((__blocks__(byref))) __Block_byref_b_0 b = {(void*)0,(__Block_byref_b_0 *)&b, 0, sizeof(__Block_byref_b_0), 20};
    NSString *str = (NSString *)&__NSConstantStringImpl__var_folders_d6_rtk49g5s52g_m2sgrvm0b5q00000gn_T_main_5b81f9_mi_0;
    __attribute__((__blocks__(byref))) __Block_byref_blockStr_1 blockStr = {(void*)0,(__Block_byref_blockStr_1 *)&blockStr, 33554432, sizeof(__Block_byref_blockStr_1), __Block_byref_id_object_copy_131, __Block_byref_id_object_dispose_131, str};
    NSString *strongStr = (NSString *)&__NSConstantStringImpl__var_folders_d6_rtk49g5s52g_m2sgrvm0b5q00000gn_T_main_5b81f9_mi_1;
     NSString *weakStr = (NSString *)&__NSConstantStringImpl__var_folders_d6_rtk49g5s52g_m2sgrvm0b5q00000gn_T_main_5b81f9_mi_2;

    void (*testBlock)(int) = ((void (*)(int))&__test_block_impl_0((void *)__test_block_func_0, &__test_block_desc_0_DATA, a, strongStr, weakStr, (__Block_byref_b_0 *)&b, (__Block_byref_blockStr_1 *)&blockStr, 570425344));

    a = 20;
    (b.__forwarding->b) = 40;
    ((void (*)(__block_impl *, int))((__block_impl *)testBlock)->FuncPtr)((__block_impl *)testBlock, 30);

}
static struct IMAGE_INFO { unsigned version; unsigned flag; } _OBJC_IMAGE_INFO = { 0, 2 };

地点的代码对于一些同学来说也许太过别扭了!可是并未涉嫌,我把地点的代码举办简化和拍卖,并去掉了部分说不上的东西,然后简化为如下的代码:

//  每个block变量都会生成一个和OC类内存结构兼容的结构体。下面是_block int b 的结构体定义:
struct Block_b {
    void *isa;    //固定为NULL
    Block_b *forwarding;  //指向真正的block对象变量。
    int flags;
    int size; //结构体的size
    int b;   //保存代码中定义的变量值。
};

//每个block变量都会生成一个和OC类内存结构兼容的结构体。下面是 __block NString *blockStr 的结构体定义:
struct Block_blockStr {
    void *isa;  //固定为NULL
    Block_blockStr *forwarding;  //指向真正的block对象变量
    int flags;
    int size;  //结构体的size
    NSString * blockStr;  //保存代码中定义的变量值。
};


//每个block块都会生成一个和OC类内存结构兼容的结构体和一个描述这个block块信息描述的结构体
struct Block_testBlock {
    //所有block块的固定部分,这也是一个OC类的内存结构。
    Class isa;  //block的OC类型
    int flags;
    int reserved;
    void *funcPtr;       //block块函数的地址。
    Block_testBlock_Desc* desc;   //block的描述信息。

    //所有在block代码块内引用的外部数据都会成为结构体内的数据成员。
    int a;
    NSString * strongStr;
    NSString * __weak weakStr;
    Block_b *b;
    Block_blockStr *blockStr;

    //结构体的构造函数。
    Block_testBlock(void *_funcPtr, Block_testBlock_Desc *_desc, int _a, NSString * _strongStr, NSString * _weakStr, struct Block_b *_b, Block_blockStr *_blockStr, int _flags)
    {
        isa = &_NSConcreteStackBlock;  //根据具体的block类型赋值。
        flags = _flags;
        reserved = 0;
        funcPtr = _funcPtr;
        desc = _desc;
        a = _a;
        strongStr = _strongStr;
        weakStr = _weakStr;
        b = _b->forwarding;  //b保存真实的block变量的地址。
        blockStr = _blockStr->forwarding;  //blockStr保存真实的block变量的地址。
    }
};

//block块信息描述的结构体定义,主要有block对象的尺寸,以及block中函数的参数信息,也就是参数的签名信息。并生成一个全局的常量对象_testBlock_desc_DATA
struct Block_testBlock_Desc {
    unsigned long reserved;
    unsigned long size; //块的尺寸
    void *rest[1];    //块的参数签名信息
}_testBlock_desc_DATA = {0, sizeof(Block_testBlock), "v12@?0i8"};


//这部分是block块函数体的定义部分,可以看出block的代码块都转化为了普通的函数,并且函数会默认增加一个隐藏的__cself参数,用来指向block对象本身。
static void testBlockfn(Block_testBlock *__cself, int c) {

    //还原函数体内引用外部的数据对象和变量。
    Block_b *b = __cself->b;
    Block_blockStr *blockStr = __cself->blockStr;
    int a = __cself->a;
    NSString *__strong strongStr = __cself->strongStr;
    NSString *__weak weakStr = __cself->weakStr;

    //int d = a + b + c;
    int d = a + b->forwarding->b + c;  //注意这里block变量使用方式。

    //NSLog(@"d=%d, strongStr=%@, blockStr=%@, weakStr=%@", d, strongStr, blockStr, weakStr);
    NSLog(@"d=%d, strongStr=%@, blockStr=%@, weakStr=%@", d, strongStr, blockStr->forwarding->blockStr, weakStr);

}

void test()
{
    int a = 10;

    //__block int b = 20;
    Block_b b = {nil, &b, 0, sizeof(struct Block_b), 20};

    // __block NSString *blockStr = @"123";
    Block_blockStr blockStr = {nil, &blockStr, 33554432, sizeof(Block_blockStr), @"123"};

    NSString *strongStr = @"456";

   __weak NSString *weakStr = @"789";

    //每个在代码中的block块都会生成对应的OC block对象,这里面用构造函数初始化这个block对象。
    Block_testBlock testBlock(&testBlockfn, &_testBlock_desc_DATA, a, strongStr, weakStr, &b, &blockStr, 570425344);

    a = 20;   //这个不会影响到block块内执行时a的值。
    // b = 40; 这个赋值会影响到block块内执行时b的值。
    b.forwarding->b = 40;  //注意__block类型变量的值的更新方式。

    //执行block块其实就是执行block对象里面的函数。
   //testBlock(30);
    testBlock.funcPtr(&testBlock, 30);
}

先看函数test内的贯彻部分,大家发现装有带 __block修饰符的变量的概念由:

     __block int b = 20;
     __block NSString *blockStr = @"123"; 

变为了:

    Block_b b = {nil, &b, 0, sizeof(struct Block_b), 20};
    Block_blockStr blockStr = {nil, &blockStr, 33554432, sizeof(Block_blockStr), @"123"};

也就是说所有定义为__block类型的变量,在编译时都会化为一个个block对象变量。在编译时系统会为各种带__block修饰的变量生成一个和OC类内存结构相当的结构体:

//  每个block变量都会生成一个和OC类内存结构兼容的结构体。下面是_block int b 的结构体定义:
struct Block_b {
    void *isa;
    Block_b *forwarding;  //指向真正的block对象变量。
    int flags;
    int size;  //结构体的size。
    int b;   //保存代码中定义的变量。
};

//每个block变量都会生成一个和OC类内存结构兼容的结构体。下面是 __block NString *blockStr 的结构体定义:
struct Block_blockStr {
    void *isa;
    Block_blockStr *forwarding;  //指向真正的block对象变量。
    int flags;
    int size;
    NSString * blockStr;  //保存代码中定义的变量。
};

下边的六个结构体都有一定的格式,而且也和OC类的内存结构非常。也就是说当定义__block修饰的变量时,系统会把他转化为一个OC对象。
为何要把__block定义的变量转变为OC对象呢?这么些是和__block这些首要字所抒发的意趣是千篇一律的,也就是概念为__block类型的变量是不会在block代码块内爆发副本的,而是保持唯一性。每个block对象变量的isa都固定设置为nil;
而forwarding则是指向真正操作的block对象变量,如若某个block对象变量只是在一个栈block对象里面被利用则这时候forwarding是指向block对象变量自己,而尽管那些block对象变量在一个堆block对象里面被选取则这时候forwarding则是指向一个堆block对象变量的地方。

再来看test函数中的block块的概念部分。从代码中能够发现原本在2018正版葡京赌侠诗,代码中定义的block块,被拆分为了block对象和大局函数两局部来促成。因而可以见见在iOS内享有定义的block代码块系统在编译时都会转接为个OC对象(NSBlock类是用来讲述block代码块的OC类,系统一共襄助栈block:NSStackBlock,堆block:NSMallocBlock,全局block:NSGlobalBlock三系列型的block。具体的细节和出入不在本文展开,请我们自行检索有关的素材。)。由此在编译时大家会为各种block代码块都生成一个和OC类兼容的结构体,在我们的例子里面的社团体定义如下:

//每个block块都会生成一个和OC类兼容的结构体。
struct Block_testBlock {
    //前面5个数据成员在所有block定义中都相同,并且和OC兼容。
    Class isa;
    int flags;
    int reserved;
    void *funcPtr;   //block块的全局函数的地址。
    Block_testBlock_Desc* desc;   //block的描述。

    //所有在block代码块引用的外部数据都会成为结构体的同名数据成员。
    int a;
    NSString * strongStr;
    NSString * __weak weakStr;
    Block_b *b;
    Block_blockStr *blockStr;

    //结构体的构造函数。
    Block_testBlock(void *_funcPtr, Block_testBlock_Desc *_desc, int _a, NSString * _strongStr, NSString * _weakStr, struct Block_b *_b, Block_blockStr *_blockStr, int _flags)
    {
        isa = &_NSConcreteStackBlock;  //根据具体的block类型赋值。
        flags = _flags;
        reserved = 0;
        funcPtr = _funcPtr;
        desc = _desc;
        a = _a;
        strongStr = _strongStr;
        weakStr = _weakStr;
        b = _b->forwarding;  //其实就是指向自己
        blockStr = _blockStr->forwarding;
    }
};

//每个block块的描述信息结构体,主要是保存block的尺寸,以及block中函数的参数信息。
struct Block_testBlock_Desc {
    unsigned long reserved;
    unsigned long size; //块的尺寸
    void *rest[1];    //块的参数签名信息
}_testBlock_desc_DATA = {0, sizeof(Block_testBlock), "v12@?0i8"};

可以看到我们定义的block代码块都会生成2个结构体:

  • Block_testBlock用来保存block的信息以及block内部要用到的保有数据。所有block对象结构体的前5个数据成员都是同一的,也就是和OC类的内存结构是匹配的。其中的isa用来保存block的类信息,那些中的类音讯会基于block所处的地点的不比而不同。而后边的5个数据成员就是在block代码块内采用外部对象的副本。正是因为各个block对象在编译时保留了代码块内尔(Nell)y用代码块外的目的的副本,所以大家才能在连续代码执行时亦可访问到这么些音信。

  • Block_testBlock_Desc用来叙述这几个block的size以及block方法的参数的签署音信。

下边就是Block_testBlock 实例的构造方法:

  //每个在代码中的block块都会生成对应的OC  block对象,这里面构造函数初始化这个block对象。
    Block_testBlock testBlock(&testBlockfn, &_testBlock_desc_DATA, a, strongStr, weakStr, &b, &blockStr, 570425344);

下边能够看看,一旦在代码中冒出了block代码块,编译时就会建立一个block对象,然后将block对象关系的函数代码地址、以及利用的外侧的数码作为block对象的构造函数的参数来创立这些block对象。

说到底我们再来考察block代码的全局函数的贯彻:

//这部分是block代码函数体的定义部分,可以看见函数默认增加一个隐藏的__cself参数。
static void testBlockfn(Block_testBlock *__cself, int c) {

    //还原函数体内引用外面的变量。
    Block_b *b = __cself->b;
    Block_blockStr *blockStr = __cself->blockStr;
    int a = __cself->a;
    NSString *__strong strongStr = __cself->strongStr;
    NSString *__weak weakStr = __cself->weakStr;


    //int d = a + b + c;
    int d = a + (b->forwarding->b) + c;

    //NSLog(@"d=%d, strongStr=%@, blockStr=%@, weakStr=%@", d, strongStr, blockStr, weakStr);
    NSLog(@"d=%d, strongStr=%@, blockStr=%@, weakStr=%@", d, strongStr, blockStr->forwarding->blockStr, weakStr);

}

下边的代码片段中,可以看出block块全局函数除了定义的int类型参数外,还扩展了一个隐形的参数__cself用来指向block对象。然后在函数体的最先位置把利用的外表数据的副本还原到函数的栈内。这也是为什么我们能在block代码块内用到外面的多少的由来了。这里大家需要更加观看这一个副本的含义:

  • 对于主旨类型a的副本来说就是全然的内存拷贝,因而在block代码块内更新这些数据是不会影响到外面,同时外面的换代也不会潜移默化到内部了。

  • 对此目标类型的strongStr和weakStr而言这一个副本只是指针的正片而不是所指对象的正片,因而在block代码块内可以读取最新的性质和装置新的属性值。

  • 对于__block类型的靶子的话,你会意识他也是指针的正片,所以也不会爆发多份内存副本,同时能够见见对__block类型数据的读取和设置我们都是直接来完成的,由此这里代码块内更新数据能影响外面,同时外面的换代也能影响内部。

好了,所有我要介绍的情节就到这里了,上边就是iOS的block的中间贯彻机制。我相信通过自我下面的介绍可以让您询问到了block在编译时所做的工作,以及可以了解到__block,
__weak, __strong各类修饰符的意思和距离。


终极欢迎大家访问我的github站点,关注欧阳表弟2013

相关文章