深切解构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块的概念部分。从代码中得以窥见原本在代码中定义的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