To Be Defined

0%

深入解构iOS的Block闭包实现原理

发表于 更新于 分类于

在iOS4出来后，苹果公司在OC中推出了block机制(也许更早就有了)。并且在后续的版本中大量的推广和使用了这项技术，比如对视图动画API的改版，比如GCD技术等等。block技术并不是什么新技术，他的本质就是闭包功能在iOS上的实现而已。而闭包功能在其他很多语言中都有实现，比如JAVA中接口的匿名实现。用闭包可以解决那些执行逻辑和上下文环境解耦的场景，如果从设计模式的角度来考虑的话闭包就是一种策略模式(Strategy)的实现。

本文并不探讨如何应用block，而是探讨OC的block机制是如何实现的。从代码的角度来说block的出现和我们平时基于函数和类方法的编程方式不太一致，有时候甚至不好去理解，因为他可以在我们的代码块中定义代码块，而且新定义的代码块又不会按函数内的指令顺序去执行。我们可以大胆的设想，如果是要你去实现一套block机制，你会怎么去做？这也是本文要探讨的东西，只有你知道了OC实现block的内幕，你才能够更好的利用他。

写这篇文章来分析原理时我隐去了一些细节，而且有些结构体的定义也和真实的有差异，但是总体是正确的，目的是为了更好的了解到本质的东西。我们先来看下面一段含有block的OC代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//文件test.m
#import 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的部分实现:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
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
};

上面的代码对于某些同学来说也许太过晦涩了！ 不过没有关系， 我把上面的代码进行简化和处理， 并去掉了一些次要的东西， 然后简化为如下的代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
//  每个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修饰符的变量的定义由：

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

变为了：

1
2
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类内存结构兼容的结构体：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//  每个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类兼容的结构体，在我们的例子里面的结构体定义如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
//每个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对象在编译时保存了代码块内使用代码块外的对象的副本，所以我们才能在后续代码执行时能够访问到这些信息。
  • Block_testBlock_Desc用来描述这个block的size以及block方法的参数的签名信息。

下面就是Block_testBlock 实例的构造方法：

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

上面可以看出，一旦在代码中出现了block代码块，编译时就会建立一个block对象，然后将block对象关联的函数代码地址、以及使用的外面的数据作为block对象的构造函数的参数来创建这个block对象。

最后我们再来考察block代码的全局函数的实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//这部分是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各种修饰符的意义和差别。

原文链接