谈Objective-C Block的实现

最新推荐文章于 2021-06-02 16:35:57 发布
最新推荐文章于 2021-06-02 16:35:57 发布
阅读量355 收藏
点赞数
分类专栏： Objective-C 文章标签： Objective-C

前言

这里 有关于 block 的 5 道测试题，建议你阅读本文之前先做一下测试。

先介绍一下什么是闭包。在 wikipedia 上，闭包的定义) 是:

In programming languages, a closure is a function or reference to a function together with a referencing environment—a table storing a reference to each of the non-local variables (also called free variables or upvalues) of that function.

翻译过来，闭包是一个函数（或指向函数的指针），再加上该函数执行的外部的上下文变量（有时候也称作自由变量）。

block 实际上就是 Objective-C 语言对于闭包的实现。block 配合上 dispatch_queue，可以方便地实现简单的多线程编程和异步编程，关于这个，我之前写过一篇文章介绍：《使用 GCD》。

本文主要介绍 Objective-C 语言的 block 在编译器中的实现方式。主要包括：

  1. block 的内部实现数据结构介绍
  2. block 的三种类型及其相关的内存管理方式
  3. block 如何通过 capture 变量来达到访问函数外的变量

实现方式

数据结构定义

block 的数据结构定义如下（图片来自 这里)：

对应的结构体定义如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

struct Block_descriptor {
    unsigned long int reserved;
    unsigned long int size;
    void (*copy)(void *dst, void *src);
    void (*dispose)(void *);
};

struct Block_layout {
    void *isa;
    int flags;
    int reserved;
    void (*invoke)(void *, ...);
    struct Block_descriptor *descriptor;
    /* Imported variables. */
};

通过该图，我们可以知道，一个 block 实例实际上由 6 部分构成：

  1. isa 指针，所有对象都有该指针，用于实现对象相关的功能。
  2. flags，用于按 bit 位表示一些 block 的附加信息，本文后面介绍 block copy 的实现代码可以看到对该变量的使用。
  3. reserved，保留变量。
  4. invoke，函数指针，指向具体的 block 实现的函数调用地址。
  5. descriptor， 表示该 block 的附加描述信息，主要是 size 大小，以及 copy 和 dispose 函数的指针。
  6. variables，capture 过来的变量，block 能够访问它外部的局部变量，就是因为将这些变量（或变量的地址）复制到了结构体中。

该数据结构和后面的 clang 分析出来的结构实际是一样的，不过仅是结构体的嵌套方式不一样。但这一点我一开始没有想明白，所以也给大家解释一下，如下 2 个结构体 SampleA 和 SampleB 在内存上是完全一样的，原因是结构体本身并不带有任何额外的附加信息。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

struct SampleA {
    int a;
    int b;
    int c;
};

struct SampleB {
    int a;
    struct Part1 {
        int b;
    };
    struct Part2 {
        int c;
    };
};

在 Objective-C 语言中，一共有 3 种类型的 block：

  1. _NSConcreteGlobalBlock 全局的静态 block，不会访问任何外部变量。
  2. _NSConcreteStackBlock 保存在栈中的 block，当函数返回时会被销毁。
  3. _NSConcreteMallocBlock 保存在堆中的 block，当引用计数为 0 时会被销毁。

我们在下面会分别来查看它们各自的实现方式上的差别。

研究工具：clang

为了研究编译器是如何实现 block 的，我们需要使用 clang。clang 提供一个命令，可以将 Objetive-C 的源码改写成 c 语言的，借此可以研究 block 具体的源码实现方式。该命令是

1

clang -rewrite-objc block.c

NSConcreteGlobalBlock 类型的 block 的实现

我们先新建一个名为 block1.c 的源文件：

1
2
3
4
5
6
7

#include <stdio.h>

int main()
{
    ^{ printf("Hello, World!\n"); } ();
    return 0;
}

然后在命令行中输入clang -rewrite-objc block1.c即可在目录中看到 clang 输出了一个名为 block1.cpp 的文件。该文件就是 block 在 c 语言实现，我将 block1.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

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

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 void __main_block_func_0(struct __main_block_impl_0 *__cself) {
    printf("Hello, World!\n");
}

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 (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA) ();
    return 0;
}

下面我们就具体看一下是如何实现的。__main_block_impl_0 就是该 block 的实现，从中我们可以看出：

  1. 一个 block 实际是一个对象，它主要由一个 isa 和 一个 impl 和 一个 descriptor 组成。
  2. 在本例中，isa 指向 _NSConcreteGlobalBlock， 主要是为了实现对象的所有特性，在此我们就不展开讨论了。
  3. 由于 clang 改写的具体实现方式和 LLVM 不太一样，并且这里没有开启 ARC。所以这里我们看到 isa 指向的还是_NSConcreteStackBlock。但在 LLVM 的实现中，开启 ARC 时，block 应该是 _NSConcreteGlobalBlock 类型，具体可以看 《objective-c-blocks-quiz》 第二题的解释。
  4. impl 是实际的函数指针，本例中，它指向 __main_block_func_0。这里的 impl 相当于之前提到的 invoke 变量，只是 clang 编译器对变量的命名不一样而已。
  5. descriptor 是用于描述当前这个 block 的附加信息的，包括结构体的大小，需要 capture 和 dispose 的变量列表等。结构体大小需要保存是因为，每个 block 因为会 capture 一些变量，这些变量会加到 __main_block_impl_0 这个结构体中，使其体积变大。在该例子中我们还看不到相关 capture 的代码，后面将会看到。

NSConcreteStackBlock 类型的 block 的实现

我们另外新建一个名为 block2.c 的文件，输入以下内容：

1
2
3
4
5
6
7
8
9
10
11

#include <stdio.h>

int main() {
    int a = 100;
    void (^block2)(void) = ^{
        printf("%d\n", a);
    };
    block2();

    return 0;
}

用之前提到的 clang 工具，转换后的关键代码如下：

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

struct __main_block_impl_0 {
    struct __block_impl impl;
    struct __main_block_desc_0* Desc;
    int a;
    __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _a, int flags=0) : a(_a) {
        impl.isa = &_NSConcreteStackBlock;
        impl.Flags = flags;
        impl.FuncPtr = fp;
        Desc = desc;
    }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
    int a = __cself->a; // bound by copy
    printf("%d\n", a);
}

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()
{
    int a = 100;
    void (*block2)(void) = (void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, a);
    ((void (*)(__block_impl *))((__block_impl *)block2)->FuncPtr)((__block_impl *)block2);

    return 0;
}

在本例中，我们可以看到：

  1. 本例中，isa 指向 _NSConcreteStackBlock，说明这是一个分配在栈上的实例。
  2. main_block_impl_0 中增加了一个变量 a，在 block 中引用的变量 a 实际是在申明 block 时，被复制到 main_block_impl_0 结构体中的那个变量 a。因为这样，我们就能理解，在 block 内部修改变量 a 的内容，不会影响外部的实际变量 a。
  3. main_block_impl_0 中由于增加了一个变量 a，所以结构体的大小变大了，该结构体大小被写在了 main_block_desc_0 中。

我们修改上面的源码，在变量前面增加 __block 关键字：

1
2
3
4
5
6
7
8
9
10
11
12

#include <stdio.h>

int main()
{
    __block int i = 1024;
    void (^block1)(void) = ^{
        printf("%d\n", i);
        i = 1023;
    };
    block1();
    return 0;
}

生成的关键代码如下，可以看到，差异相当大：

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

struct __Block_byref_i_0 {
    void *__isa;
    __Block_byref_i_0 *__forwarding;
    int __flags;
    int __size;
    int i;
};

struct __main_block_impl_0 {
    struct __block_impl impl;
    struct __main_block_desc_0* Desc;
    __Block_byref_i_0 *i; // by ref
    __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;
    }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
    __Block_byref_i_0 *i = __cself->i; // bound by ref

    printf("%d\n", (i->__forwarding->i));
    (i->__forwarding->i) = 1023;
}

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

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*);
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0), __main_block_copy_0, __main_block_dispose_0};

int main()
{
    __attribute__((__blocks__(byref))) __Block_byref_i_0 i = {(void*)0,(__Block_byref_i_0 *)&i, 0, sizeof(__Block_byref_i_0), 1024};
    void (*block1)(void) = (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);
    return 0;
}

从代码中我们可以看到：

  1. 源码中增加一个名为 __Block_byref_i_0 的结构体，用来保存我们要 capture 并且修改的变量 i。
  2. main_block_impl_0 中引用的是 Block_byref_i_0 的结构体指针，这样就可以达到修改外部变量的作用。
  3. __Block_byref_i_0 结构体中带有 isa，说明它也是一个对象。
  4. 我们需要负责 Block_byref_i_0 结构体相关的内存管理，所以 main_block_desc_0 中增加了 copy 和 dispose 函数指针，对于在调用前后修改相应变量的引用计数。

NSConcreteMallocBlock 类型的 block 的实现

NSConcreteMallocBlock 类型的 block 通常不会在源码中直接出现，因为默认它是当一个 block 被 copy 的时候，才会将这个 block 复制到堆中。以下是一个 block 被 copy 时的示例代码 (来自 这里)，可以看到，在第 8 步，目标的 block 类型被修改为 _NSConcreteMallocBlock。

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

static void *_Block_copy_internal(const void *arg, const int flags) {
    struct Block_layout *aBlock;
    const bool wantsOne = (WANTS_ONE & flags) == WANTS_ONE;

    // 1
    if (!arg) return NULL;

    // 2
    aBlock = (struct Block_layout *)arg;

    // 3
    if (aBlock->flags & BLOCK_NEEDS_FREE) {
        // latches on high
        latching_incr_int(&aBlock->flags);
        return aBlock;
    }

    // 4
    else if (aBlock->flags & BLOCK_IS_GLOBAL) {
        return aBlock;
    }

    // 5
    struct Block_layout *result = malloc(aBlock->descriptor->size);
    if (!result) return (void *)0;

    // 6
    memmove(result, aBlock, aBlock->descriptor->size); // bitcopy first

    // 7
    result->flags &= ~(BLOCK_REFCOUNT_MASK);    // XXX not needed
    result->flags |= BLOCK_NEEDS_FREE | 1;

    // 8
    result->isa = _NSConcreteMallocBlock;

    // 9
    if (result->flags & BLOCK_HAS_COPY_DISPOSE) {
        (*aBlock->descriptor->copy)(result, aBlock); // do fixup
    }

    return result;
}

变量的复制

对于 block 外的变量引用，block 默认是将其复制到其数据结构中来实现访问的，如下图所示（图片来自 这里）：

对于用 __block 修饰的外部变量引用，block 是复制其引用地址来实现访问的，如下图所示（图片来自 这里）：

LLVM 源码

在 LLVM 开源的关于 block 的实现源码，其内容也和我们用 clang 改写得到的内容相似，印证了我们对于 block 内部数据结构的推测。

ARC 对 block 类型的影响

在 ARC 开启的情况下，将只会有 NSConcreteGlobalBlock 和 NSConcreteMallocBlock 类型的 block。

原本的 NSConcreteStackBlock 的 block 会被 NSConcreteMallocBlock 类型的 block 替代。证明方式是以下代码在 XCode 中，会输出 <__NSMallocBlock__: 0x100109960>。在苹果的 官方文档 中也提到，当把栈中的 block 返回时，不需要调用 copy 方法了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

#import <Foundation/Foundation.h>

int main(int argc, const char * argv[])
{
    @autoreleasepool {
        int i = 1024;
        void (^block1)(void) = ^{
            printf("%d\n", i);
        };
        block1();
        NSLog(@"%@", block1);
    }
    return 0;
}

我个人认为这么做的原因是，由于 ARC 已经能很好地处理对象的生命周期的管理，这样所有对象都放到堆上管理，对于编译器实现来说，会比较方便。

参考链接

希望本文能加深你对于 block 的理解。我在学习中，查阅了以下文章，一并分享给大家。祝大家玩得开心～

zhuozai
关注
专栏目录
探究Objective-C中的block
Mac开发修炼之路
09-22 229
本文目录一、`block`的本质二、`block`的变量捕获机制变量捕获机制的猜想验证变量捕获机制猜想三、`block`的三种类型__NSGlobalBlock____NSStackBlock____NSMallocBlock__四、`block`的`copy`操作 本文将通过将OC代码转换为CPP代码的方式来探究Objective-C中block不同情况下的底层数据结构的情况。 一、block的本质 block的本质是一个封装了函数调用以及函数调用环境的OC对象。 以一个最简单的一个block的定义如下：
Objective-C runtime机制(2)——消息机制
无忘无往
06-04 3370
当我们用中括号[]调用OC函数的时候，实际上会进入消息发送和消息转发流程： 消息发送（Messaging），runtime系统会根据SEL查找对用的IMP，查找到，则调用函数指针进行方法调用；若查找不到，则进入消息转发流程，如果消息转发失败，则程序crash并记录日志。 SEL SEL被称之为消息选择器，它相当于一个key，在类的消息列表中，可以根据这个key，来查找到对应的消息实现...
block实现原理
01-14
iOS开发，block实现原理。深入讲解block实现原理以及讲解与内存管理之间的联系。
OC 中的3种BLOCK
心灵的流放地, 共同的精神家园
08-02 1467
http://www.cocoachina.com/applenews/devnews/2013/0802/6725.html 前言 这里有关于block的5道测试题，建议你阅读本文之前先做一下测试。   先介绍一下什么是闭包。在wikipedia上，闭包的定义)是:   In programming languages, a closure is a function or refe
谈Objective-C Block的实现（转载唐巧）
weixin_30636089的博客
06-24 185
谈Objective-C Block的实现（转载唐巧） 唐巧的技术博客 谈Objective-C Block的实现 JUL 28TH, 2013 前言 这里有关于block的5道测试题，建议你阅读本文之前先做一下测试。 先介绍一下什么是闭包。在wikipedia上，闭包的定义)是: In programming la...
block原理详细讲解（一）
梦想实践者的技术博客
10-10 1610
本系列博文总结自《Pro Multithreading and Memory Management for iOS and OS X with ARC》 如果您觉得我的博客对您有帮助，请通过关注我的新浪微博  MicroCai 支持我，谢谢！ block 顾名思义就是代码块，将同一逻辑的代码放在一个块，使代码更简洁紧凑，易于阅读，而且它比函数使用更方便，代码更美观，因而广受开发者欢
iOS进阶面试题----Block部分
热门推荐
寻亚楠的专栏
09-17 7万+
1 什么是block 对于闭包（block),有很多定义，其中闭包就是能够读取其它函数内部变量的函数，这个定义即接近本质又较好理解。对于刚接触Block的同学，会觉得有些绕，因为我们习惯写这样的程序main(){ funA();} funA(){funB();} funB(){.....}; 就是函数main调用函数A，函数A调用函数B... 函数们依次顺序执行，但现实中不全是这样的，例如项目经
iOS 开发 Object-C和JavaScript交互详解之OC与JS交互在JavaScriptCore中使用
高级软件开发工程师--周玉的博客
11-24 1182
JavaScriptCore简介JSCore全称为 JavaScriptCore，是苹果公司在iOS中加入的一个新的framework。该framework为OC与JS代码相互操作的提供了极大的便利。该工程默认是没有导入工程中的，需要我们手动添加。添加完成后，我们可以看到JavaScriptCore.h中包含以下5个主要的文件。#import "JSContext.h" #import "JSVal
亚信java笔试题-iOSResourceCollect:iOSResourceCollect/iOS资源收集
06-03
(唐巧)谈Objective-C Block的实现 0002 Block介绍（一）基础 0003 (青玉伏案)Objective-C中的Block(闭包) 0004 Block介绍（二）内存管理与其他特性 序号 已读 分类tag 0001 0002 0003 0004 0005 0006 0007 0008 0009...
Block实现原理与内存特性(v1.1)
03-20
Block实现原理与内存特性 博客原文: https://blog.csdn.net/wangyanchang21/article/details/79525394。
Block的实现
weixin_41473928的博客
04-03 190
参考文章 ibireme的博客文章 iOS 高级编程 本文属于原创，转载请注明出处 简介 Block截获自动变量相当于截获了变量的值，之后在Block外改变变量的值不会影响Block中的值 Block中截获的自动变量不能修改，修改会报错，修改要给变量加__block修饰符，在Block调用后，原变量的值也会改变，但被__block修饰符修饰的变量已经不是单纯的变量了 截获并更改对象不会报错，赋值...
Block实现原理
baitxaps的专栏
02-23 2221
一、首先来玩一玩Block int  test(int a){printf("test= %d\n",a);return a;} typedef int (^blk_t)(int); #pragma mark - Block测试1 - (void)testBlk2{          blk_t blk = ^int (int a){
iOS—Blocks的实现
qq_45836906的博客
06-02 723
Block的实质 Block是“带有自动变量值的匿名函数”。 我们可以通过clange -rewrite-objc 源代码文件名，将源代码转换为c++源代码。 先在main.m写一个简单的block 通过clang可转换为： struct __main_block_impl_0 { struct __block_impl impl; struct __main_block_desc_0* Desc; __main_block_impl_0(void *fp, struct __main
iOS中OC:block底层实现原理
whhit7447的专栏
08-22 804
Block是什么？苹果推荐的类型，效率高，在运行中保存代码。用来封装和保存代码，有点像函数，Block可以在任何时候执行。 Block和函数的相似性：（1）可以保存代码（2）有返回值（3）有形参（4）调用方式一样。 Block 底层实现 定义一个简单的block 我们再给a赋值为20，此时打印出来a 的值还是10 但当我们在第一次给a
Block的实现原理
寒流的专栏
04-11 3046
Block的实现原理这篇是记录根据网上的文章进行的实际操作。C函数的生成中间编译代码的编译方法是clang -rewrite-objc xxxx.c。由于编译文件中内容较多，这里我们只截取有关block的部分。首先，看看没有block的C函数以及编译后的结果：#include <stdio.h>int main(){ return 0; }编译代码中的block：这里我们可以看到一个bloc
Block 本质、实现原理、内存管理、循环引用、__block等
idealPC的专栏
02-21 1666
一、Block介绍 1.1概念： 将函数及其执行上下文封装起来的对象 底层用struct实现 1.2block实现原理： a .新建项目 代码放入file.m中 b.打开终端cd到项目目录下 c.敲clang -rewrite-objc file.m查看编译后的文件内容 本质是将OC重写为C后目录下多了个file.cpp文件 1）Block实际上是OC对于闭包（闭包是一个函数或指向函数的指针，再加上该函数执行的外部的上下文变量。）的实现。OC是对C语言的扩展，block的实现是基于函数和指向函数的
Block中__block实现原理
diaoju3333的博客
09-06 131
三.Block中__block实现原理 我们继续研究一下__block实现原理。 1.普通非对象的变量 先来看看普通变量的情况。 #import <Foundation/Foundation.h> int main(int argc, const char * argv[]) { __block int i = 0; void...
Objective-C Block详解：栈与堆的理解
"Objective-C中的Block" Objective-C中的Block是...Objective-C的Block提供了强大的代码封装和复用能力，是Objective-C语言中的一大亮点。通过理解和熟练使用Block，开发者可以编写出更加简洁、高效和易于维护的代码。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值