关于Block你所该知道的一切

一、 block 的分类#

全局 block 、 堆 block 、 栈 block 。

1.1 NSGlobalBlock 全局 block#

位于全局区
未捕获任何变量或只捕获全局静态变量

未捕获任何变量#

1
<__NSGlobalBlock__: 0x100004030>

只捕获全局静态变量#

1.2 堆 block#

位于堆区
在 block 内部使用 局部变量 或者 OC属性 ，并且赋值给 强引用 或者 Copy修饰 的变量

1
<__NSMallocBlock__: 0x1007049e0>

1.3 栈 block#

位于栈区
在 block 内部使用 局部变量 或者 OC属性 ，但 不 赋值给 强引用 或者 Copy修饰 的变量

1
<__NSStackBlock__: 0x7ffeefbff378>

1.4 面试题（一）#

下面输出的结果会是什么样？

1
NSObject *obj = [NSObject new];
2
NSLog(@"%ld", CFGetRetainCount((__bridge CFTypeRef)(obj)));
3

4
void (^blockA)(void) = ^{
5
    NSLog(@"%ld", CFGetRetainCount((__bridge CFTypeRef)(obj)));
6
};
7
blockA();
8

9
void (^ __weak blockB)(void) = ^{
10
    NSLog(@"%ld", CFGetRetainCount((__bridge CFTypeRef)(obj)));
11
};
12
blockB();
13

14
void (^blockC)(void) = [blockB copy];
15
blockC();

这里涉及到关于 block类型 的底层知识，我们到最后在进行解析。

1.5 面试题（二）#

下面输出的结果会是什么样？

1
int num = 0;
2
void (^ __weak blockA)(void) = nil;
3
{
4
    void (^ __weak blockB)(void) = ^{
5
        NSLog(@"%d", num);
6
    };
7
    blockA = blockB;
8
    NSLog(@"=");
9
}
10
blockA();

1.6 面试题（三）#

下面输出的结果会是什么样？

1
int num = 0;
2
void (^ __weak blockA)(void) = nil;
3
{
4
    void (^ blockB)(void) = ^{
5
        NSLog(@"%d", num);
6
    };
7
    blockA = blockB;
8
    NSLog(@"=");
9
}
10
blockA();

二、堆、栈block的生命周期#

这里结合 二、三面试题 来进行探索。

2.1 面试题二解读#

很可能有同学会给出只会打印 = 的答案。这就是对于 堆、栈block的生命周期 理解的不够深入。正确的输出如下

为什么呢？关键是对 blockB 的生命周期理解错误。一般会这么理解：

这里先不讲为什么，我们再看下 面试题三。

2.2 面试题三解读#

这里发生了野指针访问崩溃了。

2.3 堆 block 的生命周期#

在大括号内部下断点可以看到，这时 blockB 为 堆block 且有值。

赋值给 blockA 。

出了大括号后 blockA 为空了，说明 blockB 释放掉了。

因为作为 存储在堆上 的 堆block 其生命周期仅存在于大括号内部。

2.4 栈 block 的生命周期#

那么 面试题二 中的 blockB 的生命周期又是怎样的呢？

blockB 为 栈block 。

赋值给 blockA 。

出了大括号的作用域了， blockA 的地址依旧没变，说明 blockB 没有被释放。

因为作为 存储在栈中 的 栈block 其生命周期与 调用栈 相同。函数调用栈结束后释放。

三、捕获变量的底层实现#

3.1 普通变量的捕获#

1
int num = 1;
2
void (^block)(void) = ^{
3
    NSLog(@"%d", num);
4
};
5
block();

我们将上面的代码还原成 C++ ：

1
struct __block_impl {
2
  void *isa;
3
  int Flags;
4
  int Reserved;
5
  void *FuncPtr;
6
};

block 的本质是一个结构体 __main_block_impl_0 ，如果有需要捕获的变量，结构体内部会生成一个成员用来存储，例子中是 int num;
__main_block_func_0 保存的是 block 的具体需要执行的函数
__block_impl 是 block 的具体具体的一些数据，如函数等
__main_block_desc_0 是描述 block 特征的一个数据结构

这段代码中做了些什么呢？

一、创建 block ：

1、调用 __main_block_impl_0 的 构造函数

2、传入 __main_block_func_0 函数 和 __main_block_desc_0_DATA 的地址 和 变量 num

3、指定 block 类型：impl.isa = &_NSConcreteStackBlock; （这里的堆block对应的是 _NSConcreteStackBlock ）

4、存储标志位： impl.Flags = flags;

5、存储函数： impl.FuncPtr = fp;

6、描述内容赋值： Desc = desc;

二、执行 block ：

1、获取 __main_block_func_0 函数： ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)

2、将 block 作为参数传入： ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);

三、执行函数 __main_block_func_0 ：

1、从 __main_block_impl_0 中取出变量 num ： int num = __cself->num;

2、执行 NSLog ： NSLog((NSString *)&__NSConstantStringImpl__var_folders_py_7v1wvf813z5bmw0hr97yplwc0000gn_T_main_e543c2_mi_1, num);

3.2 __block 普通变量的捕获#

1
__block int num = 0;
2
void (^block)(void) = ^{
3
    num ++;
4
    NSLog(@"%d", num);
5
};
6
block();

将上面的代码转为 C++

我们发现多了几种数据类型： __Block_byref_num_0 、 __main_block_copy_0 、 __main_block_dispose_0 。

加了 __block 的变量，这里被用 __Block_byref_num_0 数据结构包装了一下，这里传入的 num 也是通过地址的形式传入的。

3.3 捕获实例变量#

不活实例变量和 3.2 没有什么区别。

1
NSNumber *num = @100;
2
void (^block)(void) = ^{
3
    NSLog(@"%@", num);
4
};
5
block();

3.4 全局 block#

1
static const NSString *string = @"aaaaaaa";
2
int main(int argc, const char * argv[]) {
3
    @autoreleasepool {
4
        void (^block)(void) = ^{
5
            NSLog(@"%@", string);
6
        };
7
        block();
8
    }
9
}

3.5 栈 block#

1
int num = 0;
2
void (^ __weak block)(void) = ^{
3
    NSLog(@"%d", num);
4
};
5
block();

这里还原 C++ 你可能会遇到包错：

1
error: cannot create __weak reference because the current deployment target does not support weak references
2
        void (^ __attribute__((objc_ownership(weak))) block)(void)

加上一些参数即可：

1
clang -rewrite-objc -fobjc-arc -fobjc-runtime=ios-13.0.0 main.m -o main.cpp

这里发现 __weak 实际是用 __attribute__((objc_ownership(weak))) 进行了包装，这里还没有什么更有用的线索，我们先继续探究。

3.6 _NSConcreteStackBlock#

相信细心的你一定能发现一个问题，不论什么类型的 block ，还原出的 C++ 底层源码中都是 impl.isa = &_NSConcreteStackBlock; 看名字是个 栈 block 。和实际运行打断点运行时看到的不一样啊。下面我们就来分析一下这里发生了什么。

四、运行时 block 类型的确定#

由于这里并没有什么具体线索，我们通过下断点，并打开汇编。这里是一个 全局block 。

4.1 进入汇编断点#

4.2 objc_retainBlock#

通过 libobjc.A.dylib`objc_retainBlock: 发现它在 libobjc 中。

在 oc 源码中定位到了相关代码，但更进一步调用的 _Block_copy 并没有找到，我们继续回到汇编，继续执行下一步。

4.3 _Block_copy#

这例进入了 _Block_copy 的汇编，发现它是 libsystem_blocks 中的，我们来 libclosure 中寻找一下线索，找到了下面的源码。

1
void *_Block_copy(const void *arg) {
2
    struct Block_layout *aBlock;
3

4
    if (!arg) return NULL;
5

6
    // The following would be better done as a switch statement
7
    aBlock = (struct Block_layout *)arg;
8
    if (aBlock->flags & BLOCK_NEEDS_FREE) {
9
        /// 根据标志位判断，需要释放
10
        // latches on high
11
        latching_incr_int(&aBlock->flags);
12
        return aBlock;
13
    }
14
    else if (aBlock->flags & BLOCK_IS_GLOBAL) {
15
        /// 根据标志位判断，为一个 全局block 直接返回
16
        return aBlock;
17
    }
18
    else {
19
        // 是一个 堆 block 就进行 copy 开辟空间的操作，拷贝到了堆上
20
        struct Block_layout *result =
21
            (struct Block_layout *)malloc(aBlock->descriptor->size);
22
        if (!result) return NULL;
23
        memmove(result, aBlock, aBlock->descriptor->size); // bitcopy first
24
#if __has_feature(ptrauth_calls)
25
        // Resign the invoke pointer as it uses address authentication.
26
        result->invoke = aBlock->invoke;
27
#endif
28
        result->flags &= ~(BLOCK_REFCOUNT_MASK|BLOCK_DEALLOCATING);    // XXX not needed
29
        result->flags |= BLOCK_NEEDS_FREE | 2;  // logical refcount 1
30
        _Block_call_copy_helper(result, aBlock);
31
        // Set isa last so memory analysis tools see a fully-initialized object.
32
        // 设置 isa 为 堆block
33
        result->isa = _NSConcreteMallocBlock;
34
        return result;
35
    }
36
}

五、汇编验证 block 的类型转换#

5.1 全局block#

一直来到 _Block_copy 内，读取 x0 寄存器 （ARM64下，x0这时存的是消息的接收者）。

进入 _Block_copy 时，就已经标识为全局block 了。

我们发现输出了这样数据结构 signature invoke ，后面再具体看他们代表了什么。

1
<__NSGlobalBlock__: 0x1006f8028>
2
 signature: "v8@?0"
3
 invoke   : 0x1006f5edc (/private/var/containers/Bundle/Application/49DA1CBF-A462-4433-80DE-19721201954A/BlockÊé¢Á¥¢.app/BlockÊé¢Á¥¢`__41-[ViewController touchesBegan:withEvent:]_block_invoke)

5.2 堆block#

进入 _Block_copy 时，显示的是栈block 。

1
<__NSStackBlock__: 0x16d6651b8>
2
 signature: "v8@?0"
3
 invoke   : 0x10279de90 (/private/var/containers/Bundle/Application/A3A281E1-1993-4E28-8F30-3EED05043A20/BlockÊé¢Á¥¢.app/BlockÊé¢Á¥¢`__41-[ViewController touchesBegan:withEvent:]_block_invoke)

和源码所写的一样，这里进行了 malloc ：

在 _Block_copy return 之前我们再看一下 x0 ：

这里已经变成了堆block

1
<__NSMallocBlock__: 0x281030ab0>
2
 signature: "v8@?0"
3
 invoke   : 0x10279de90 (/private/var/containers/Bundle/Application/A3A281E1-1993-4E28-8F30-3EED05043A20/BlockÊé¢Á¥¢.app/BlockÊé¢Á¥¢`__41-[ViewController touchesBegan:withEvent:]_block_invoke)

_block 捕获变量的变化#

进入 _Block_copy 时：

1
<__NSStackBlock__: 0x16b21d1a0>
2
 signature: "v8@?0"
3
 invoke   : 0x104be5da0 (/private/var/containers/Bundle/Application/76397764-704E-4CA4-80F3-D94500849B81/BlockÊé¢Á¥¢.app/BlockÊé¢Á¥¢`__41-[ViewController touchesBegan:withEvent:]_block_invoke)
4
 copy     : 0x104be5e04 (/private/var/containers/Bundle/Application/76397764-704E-4CA4-80F3-D94500849B81/BlockÊé¢Á¥¢.app/BlockÊé¢Á¥¢`__copy_helper_block_e8_32r)
5
 dispose  : 0x104be5e3c (/private/var/containers/Bundle/Application/76397764-704E-4CA4-80F3-D94500849B81/BlockÊé¢Á¥¢.app/BlockÊé¢Á¥¢`__destroy_helper_block_e8_32r)

在 _Block_copy return 之前

1
<__NSMallocBlock__: 0x2823a83f0>
2
 signature: "v8@?0"
3
 invoke   : 0x100825da0 (/private/var/containers/Bundle/Application/D167E1D0-2772-42C4-83F1-819FC7250D2D/BlockÊé¢Á¥¢.app/BlockÊé¢Á¥¢`__41-[ViewController touchesBegan:withEvent:]_block_invoke)
4
 copy     : 0x100825e04 (/private/var/containers/Bundle/Application/D167E1D0-2772-42C4-83F1-819FC7250D2D/BlockÊé¢Á¥¢.app/BlockÊé¢Á¥¢`__copy_helper_block_e8_32r)
5
 dispose  : 0x100825e3c (/private/var/containers/Bundle/Application/D167E1D0-2772-42C4-83F1-819FC7250D2D/BlockÊé¢Á¥¢.app/BlockÊé¢Á¥¢`__destroy_helper_block_e8_32r)

这里的数据结构又发生了变化，多了 copy dispose 。

5.3 栈block#

通过查看调用栈，我们发现并没有调用 objc_retainBlock 。没有进行 _Block_copy 操作。

六、 Block_layout 结构分析#

6.1 isa#

block 的类型：全局、堆、栈

6.2 flags#

这些标志位都标明了不同的使用时间，有 运行时：runtime 有 编译期：compiler

1
// Values for Block_layout->flags to describe block objects
2
enum {
3
    /// 正在释放
4
    BLOCK_DEALLOCATING =      (0x0001),  // runtime
5
    /// 引用计数掩码
6
    BLOCK_REFCOUNT_MASK =     (0xfffe),  // runtime
7
    /// 需要释放
8
    BLOCK_NEEDS_FREE =        (1 << 24), // runtime
9
    /// 是否拥有拷贝辅助函数 有的话就有 Block_descriptor_2
10
    BLOCK_HAS_COPY_DISPOSE =  (1 << 25), // compiler
11
    /// 是否拥有 block 析构函数
12
    BLOCK_HAS_CTOR =          (1 << 26), // compiler: helpers have C++ code
13
    /// 标志是否有垃圾回收 MAC
14
    BLOCK_IS_GC =             (1 << 27), // runtime
15
    /// 是否是 全局block
16
    BLOCK_IS_GLOBAL =         (1 << 28), // compiler
17
    /// 和 BLOCK_HAS_SIGNATURE 对应
18
    BLOCK_USE_STRET =         (1 << 29), // compiler: undefined if !BLOCK_HAS_SIGNATURE
19
    /// 有签名 有的话就有 Block_descriptor_3
20
    BLOCK_HAS_SIGNATURE  =    (1 << 30), // compiler
21
    /// 有拓展 Layout
22
    BLOCK_HAS_EXTENDED_LAYOUT=(1 << 31)  // compiler
23
};

6.3 reserved#

保留字段

6.4 invoke#

函数指针，即block中具体需要执行的内容。

6.5 descriptor#

这里我们在看下其中的 Block_descriptor

这里就和我们之前输出的内容对应上了：

1
<__NSMallocBlock__: 0x2823a83f0>
2
 signature: "v8@?0"
3
 invoke   : 0x100825da0 (/private/var/containers/Bundle/Application/D167E1D0-2772-42C4-83F1-819FC7250D2D/BlockÊé¢Á¥¢.app/BlockÊé¢Á¥¢`__41-[ViewController touchesBegan:withEvent:]_block_invoke)
4
 copy     : 0x100825e04 (/private/var/containers/Bundle/Application/D167E1D0-2772-42C4-83F1-819FC7250D2D/BlockÊé¢Á¥¢.app/BlockÊé¢Á¥¢`__copy_helper_block_e8_32r)
5
 dispose  : 0x100825e3c (/private/var/containers/Bundle/Application/D167E1D0-2772-42C4-83F1-819FC7250D2D/BlockÊé¢Á¥¢.app/BlockÊé¢Á¥¢`__destroy_helper_block_e8_32r)

虽然 Block_layout 的内存结构中只有 Block_descriptor_1 ，但是通过解读源码，可以发现， Block_descriptor_2 和 Block_descriptor_3 的读取是通过内存平移实现的，具体有哪些数据可读则是根据 标识位 来判别。

Block_descriptor_1#

基础数据，一定有的

Block_descriptor_2#

COPY 相关字段，有 BLOCK_HAS_COPY_DISPOSE 标志位时有。

Block_descriptor_3#

签名相关数据，有 BLOCK_HAS_SIGNATURE 标志位时有。

七、 block 签名#

上面的 Block_descriptor_3 中咱们提到了签名。如上面例子输出的 signature: "v8@?0" 很眼熟，它其实是 Type Encodings 类型编码，我们在属性中有遇到过。

v8@?0
- v 表示返回值为空
- 8 表示参数的总大小
- @? 表示block，
- 0 表示从0号字节开始

具体可以对照官方文档

NSMethodSignature#

我们也可以通过 NSMethodSignature 来输出详细它的代表信息。

1
(lldb) po [NSMethodSignature signatureWithObjCTypes:"v8@?0"]
2
<NSMethodSignature: 0xac5982543c221e27>
3
    number of arguments = 1
4
    frame size = 224
5
    is special struct return? NO
6
    return value: -------- -------- -------- --------
7
        type encoding (v) 'v'
8
        flags {}
9
        modifiers {}
10
        frame {offset = 0, offset adjust = 0, size = 0, size adjust = 0}
11
        memory {offset = 0, size = 0}
12
    argument 0: -------- -------- -------- --------
13
        type encoding (@) '@?'
14
        flags {isObject, isBlock} // 是个对象，也是一个 block
15
        modifiers {}
16
        frame {offset = 0, offset adjust = 0, size = 8, size adjust = 0}
17
        memory {offset = 0, size = 8}

八、 __block 捕获变量的生命周期#

我们再来研究下捕获变量的原理，我们继续通过汇编探索。

这里会调用到 _Block_object_assign

我们找到相关源码：

8.1 捕获变量类型#

1
// Values for _Block_object_assign() and _Block_object_dispose() parameters
2
enum {
3
    // see function implementation for a more complete description of these fields and combinations
4
    /// 对象
5
    BLOCK_FIELD_IS_OBJECT   =  3,  // id, NSObject, __attribute__((NSObject)), block, ...
6
    /// block
7
    BLOCK_FIELD_IS_BLOCK    =  7,  // a block variable
8
    /// __block 修饰的变量
9
    BLOCK_FIELD_IS_BYREF    =  8,  // the on stack structure holding the __block variable
10
    ///
11
    BLOCK_FIELD_IS_WEAK     = 16,  // declared __weak, only used in byref copy helpers
12
    BLOCK_BYREF_CALLER      = 128, // called from __block (byref) copy/dispose support routines.
13
};

8.2 _Block_object_assign#

1
//
2
// When Blocks or Block_byrefs hold objects then their copy routine helpers use this entry point
3
// to do the assignment.
4
//
5
void _Block_object_assign(void *destArg, const void *object, const int flags) {
6
    const void **dest = (const void **)destArg;
7
    switch (os_assumes(flags & BLOCK_ALL_COPY_DISPOSE_FLAGS)) {
8
        // 一、 捕获的是对象
9
      case BLOCK_FIELD_IS_OBJECT:
10
        /*******
11
        id object = ...;
12
        [^{ object; } copy];
13
        ********/
14

15
        /**
16
        _Block_retain_object 的实现：
17
        static void (*_Block_retain_object)(const void *ptr) = _Block_retain_object_default;
18

19
        _Block_retain_object_default 的实现：
20
        static void _Block_retain_object_default(const void *ptr __unused) { }
21

22
        其实什么都没做
23
        */
24
        _Block_retain_object(object);
25

26
        // 指针拷贝，引用计数 +1
27
        *dest = object;
28
        break;
29

30
        // 二、 捕获的是 block
31
      case BLOCK_FIELD_IS_BLOCK:
32
        /*******
33
        void (^object)(void) = ...;
34
        [^{ object; } copy];
35
        ********/
36

37
        /**
38
        前文有关于 _Block_copy 的讲解么这里就不多说了
39
        */
40
        *dest = _Block_copy(object);
41
        break;
42

43
      case BLOCK_FIELD_IS_BYREF | BLOCK_FIELD_IS_WEAK:
44
      case BLOCK_FIELD_IS_BYREF:
45
      // 三、 捕获的是 __block / __weak __block 修饰的变量
46
        /*******
47
         // copy the onstack __block container to the heap
48
         // Note this __weak is old GC-weak/MRC-unretained.
49
         // ARC-style __weak is handled by the copy helper directly.
50
         __block ... x;
51
         __weak __block ... x;
52
         [^{ x; } copy];
53
         ********/
54

55
        *dest = _Block_byref_copy(object);
56
        break;
57

58
      case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_OBJECT:
59
      case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_BLOCK:
60
        /*******
61
         // copy the actual field held in the __block container
62
         // Note this is MRC unretained __block only.
63
         // ARC retained __block is handled by the copy helper directly.
64
         __block id object;
65
         __block void (^object)(void);
66
         [^{ object; } copy];
67
         ********/
68

69
        *dest = object;
70
        break;
71

72
      case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_OBJECT | BLOCK_FIELD_IS_WEAK:
73
      case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_BLOCK  | BLOCK_FIELD_IS_WEAK:
74
        /*******
75
         // copy the actual field held in the __block container
76
         // Note this __weak is old GC-weak/MRC-unretained.
77
         // ARC-style __weak is handled by the copy helper directly.
78
         __weak __block id object;
79
         __weak __block void (^object)(void);
80
         [^{ object; } copy];
81
         ********/
82

83
        *dest = object;
84
        break;
85

86
      default:
87
        break;
88
    }
89
}

8.3 _Block_byref_copy#

__Block 捕获外界变量的操作内存拷贝等

1
static struct Block_byref *_Block_byref_copy(const void *arg) {
2
    // 使用 Block_byref 结构转换一下
3
    struct Block_byref *src = (struct Block_byref *)arg;
4

5
    if ((src->forwarding->flags & BLOCK_REFCOUNT_MASK) == 0) {
6
        // 如果是通过引用计数管理的对象，就进行 malloc ，创建一个 copy
7
        // src points to stack
8
        struct Block_byref *copy = (struct Block_byref *)malloc(src->size);
9
        copy->isa = NULL;
10
        // byref value 4 is logical refcount of 2: one for caller, one for stack
11
        copy->flags = src->flags | BLOCK_BYREF_NEEDS_FREE | 4;
12

13
        /**
14
        统一 forwarding 指向 copy
15
        所以 __block 修饰的指向的是同一片内存空间
16
        */
17
        copy->forwarding = copy; // patch heap copy to point to itself
18
        src->forwarding = copy;  // patch stack to point to heap copy
19

20

21
        copy->size = src->size;
22

23
        if (src->flags & BLOCK_BYREF_HAS_COPY_DISPOSE) {
24
            // Trust copy helper to copy everything of interest
25
            // If more than one field shows up in a byref block this is wrong XXX
26
            struct Block_byref_2 *src2 = (struct Block_byref_2 *)(src+1);
27
            struct Block_byref_2 *copy2 = (struct Block_byref_2 *)(copy+1);
28
            copy2->byref_keep = src2->byref_keep;
29
            copy2->byref_destroy = src2->byref_destroy;
30

31
            if (src->flags & BLOCK_BYREF_LAYOUT_EXTENDED) {
32
                struct Block_byref_3 *src3 = (struct Block_byref_3 *)(src2+1);
33
                struct Block_byref_3 *copy3 = (struct Block_byref_3*)(copy2+1);
34
                copy3->layout = src3->layout;
35
            }
36

37
            /**
38
            捕获到了外部变量
39
            调用 byref_keep
40
            内存处理
41
            被捕获变量生命周期的保存
42
            */
43
            (*src2->byref_keep)(copy, src);
44
        }
45
        else {
46
            // Bitwise copy.
47
            // This copy includes Block_byref_3, if any.
48
            memmove(copy+1, src+1, src->size - sizeof(*src));
49
        }
50
    }
51
    // already copied to heap
52
    else if ((src->forwarding->flags & BLOCK_BYREF_NEEDS_FREE) == BLOCK_BYREF_NEEDS_FREE) {
53
        latching_incr_int(&src->forwarding->flags);
54
    }
55

56
    return src->forwarding;
57
}

这里我们遇到了用来包装捕获变量的 Block_byref 结构体，还有个一个 byref_keep 与生命周期相关的函数调用，但是他们的来源并没有什么线索，我们只能继续从 C++ 中寻找一些线索。

8.4 Block_byref#

其中除了 Block_byref 还有 Block_byref_2 ， Block_byref_3 。他们和前面的 Block_descriptor_1 一样，也是通过标志位区分，通过内存平移进行读写的

1
// __Block 修饰的结构体
2
struct Block_byref {
3
    void *isa;
4
    struct Block_byref *forwarding;
5
    volatile int32_t flags; // contains ref count
6
    uint32_t size;
7
};
8

9
// __Block 修饰的结构体 byref_keep 和 byref_destroy 函数 - 来处理里面持有对象的保持和销毁
10
struct Block_byref_2 {
11
    // requires BLOCK_BYREF_HAS_COPY_DISPOSE
12
    BlockByrefKeepFunction byref_keep;
13
    BlockByrefDestroyFunction byref_destroy;
14
};
15

16
// 拓展 layout
17
struct Block_byref_3 {
18
    // requires BLOCK_BYREF_LAYOUT_EXTENDED
19
    const char *layout;
20
};

8.5 通过 C++ 理解 Block_byref 结构#

位了更深入的理解 Block_byref 的结构，我们通过还原 C++ 找一下线索：

1
__block NSNumber *num = @100;
2
void (^block)(void) = ^{
3
    num = @101;
4
    NSLog(@"%@", num);
5
};
6
block();

1
/**
2
对应的 Block_byref 类型结构体
3
*/
4
struct __Block_byref_num_0 {
5
  void *__isa;
6
__Block_byref_num_0 *__forwarding;
7
 int __flags;
8
 int __size;
9
 void (*__Block_byref_id_object_copy)(void*, void*);
10
 void (*__Block_byref_id_object_dispose)(void*);
11
 NSNumber *num;
12
};
13

14
struct __main_block_impl_0 {
15
  struct __block_impl impl;
16
  struct __main_block_desc_0* Desc;
17
  __Block_byref_num_0 *num; // by ref
18
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_num_0 *_num, int flags=0) : num(_num->__forwarding) {
19
    impl.isa = &_NSConcreteStackBlock;
20
    impl.Flags = flags;
21
    impl.FuncPtr = fp;
22
    Desc = desc;
23
  }
24
};
25

26
...
27

28
int main(int argc, const char * argv[]) {
29
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
30

31
        // Block_byref 构造函数
32
        __attribute__((__blocks__(byref))) __Block_byref_num_0 num = {
33
            /**
34
            Block_byref 的
35
            void *isa;
36
            */
37
            (void*)0,
38
            /**
39
            Block_byref 的
40
            struct Block_byref *forwarding;
41
            */
42
            (__Block_byref_num_0 *)&num,
43
            /**
44
            Block_byref 的
45
            volatile int32_t flags;
46
            */
47
            33554432,
48
            /**
49
            Block_byref 的
50
            uint32_t size;
51
            */
52
            sizeof(__Block_byref_num_0),
53
            /**
54
            Block_byref_2 的
55
            BlockByrefKeepFunction byref_keep;
56
            */ __Block_byref_id_object_copy
57
            __Block_byref_id_object_copy_131,
58
            /**
59
            Block_byref_2 的
60
            BlockByrefDestroyFunction byref_destroy;
61
            */
62
            __Block_byref_id_object_dispose_131,
63
            // *num
64
            ((NSNumber *(*)(Class, SEL, int))(void *)objc_msgSend)(objc_getClass("NSNumber"), sel_registerName("numberWithInt:"), 100)
65
            };
66

67
        void (*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_num_0 *)&num, 570425344));
68
        ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
69

70
    }
71
    return 0;
72
}

byref_keep#

再次调用 _Block_object_assign （详见 8.2），这时传入的 flag 为 131 ，二进制为 1000 0011，而 BLOCK_FIELD_IS_OBJECT = 3 ，所以会执行 BLOCK_FIELD_IS_OBJECT 相关的分支，进行 拷贝 与 引用计数 + 1 。

1
static void __Block_byref_id_object_copy_131(void *dst, void *src) {
2
 _Block_object_assign((char*)dst + 40, *(void * *) ((char*)src + 40), 131);
3
}

byref_destroy#

调用 _Block_object_dispose 进行销毁

1
static void __Block_byref_id_object_dispose_131(void *src) {
2
 _Block_object_dispose(*(void * *) ((char*)src + 40), 131);
3
}

九、补充：面试题一解析#

这里是 1 应该都没什么疑问#

1
NSObject *obj = [NSObject new];
2
NSLog(@"%ld", CFGetRetainCount((__bridge CFTypeRef)(obj)));

这里为什么是 3 呢？#

1
void (^blockA)(void) = ^{
2
    NSLog(@"%ld", CFGetRetainCount((__bridge CFTypeRef)(obj)));
3
};
4
blockA();

这是引用了一个局部变量
- 内部创建了一个结构体对 obj 进行了 引用 ，引用计数+1
这个 block 被 强引用 ，它是一个 堆block
- 从上面的源码学习中我们得知， block 的类型是运行时确定的
- 而在这个过程中，进行了 _Block_copy，引用计数 +1
所以这里打印出了 3

为什么是 4#

1
void (^ __weak blockB)(void) = ^{
2
    NSLog(@"%ld", CFGetRetainCount((__bridge CFTypeRef)(obj)));
3
};
4
blockB();

这是引用了一个局部变量
- 内部创建了一个结构体对 obj 进行了 引用 ，引用计数+1
这个 block 被 弱引用 ，它是一个 栈block，引用计数不变

为什么是5#

1
void (^blockC)(void) = [blockB copy];
2
blockC();

将栈blockB 进行了 copy，引用计数 +1

总结#

__block 捕获变量进行了三重拷贝：

变量A 被 __block 修饰，就会被 blockB 从 栈 上 拷贝 到 堆 上
- _Block_copy
blockB 捕获 Block_byref C 并 拷贝
- _Block_object_assign - _Block_byref_copy
Block_byref C 对捕获的 变量A 进行拷贝
- _Block_object_assign - byref_keep

参考#

libclosure

一、 block 的分类#

1.1 NSGlobalBlock 全局 block#

未捕获任何变量#

只捕获全局静态变量#

1.2 堆 block#

1.3 栈 block#

1.4 面试题（一）#

1.5 面试题（二）#

1.6 面试题（三）#

二、 堆、栈block的生命周期#

2.1 面试题二解读#

2.2 面试题三解读#

2.3 堆 block 的生命周期#

2.4 栈 block 的生命周期#

三、 捕获变量的底层实现#

3.1 普通变量的捕获#

3.2 __block 普通变量的捕获#

3.3 捕获实例变量#

3.4 全局 block#

3.5 栈 block#

3.6 _NSConcreteStackBlock#

四、 运行时 block 类型的确定#

4.1 进入汇编断点#

4.2 objc_retainBlock#

4.3 _Block_copy#

五、 汇编验证 block 的类型转换#

5.1 全局block#

5.2 堆block#

_block 捕获变量的变化#

5.3 栈block#

六、 Block_layout 结构分析#

6.1 isa#

6.2 flags#

6.3 reserved#

6.4 invoke#

6.5 descriptor#

Block_descriptor_1#

Block_descriptor_2#

Block_descriptor_3#

七、 block 签名#

NSMethodSignature#

八、 __block 捕获变量的生命周期#

8.1 捕获变量类型#

8.2 _Block_object_assign#

8.3 _Block_byref_copy#

8.4 Block_byref#

8.5 通过 C++ 理解 Block_byref 结构#

byref_keep#

byref_destroy#

九、 补充：面试题一解析#

这里是 1 应该都没什么疑问#

这里为什么是 3 呢？#

为什么是 4#

为什么是5#

总结#

参考#

二、堆、栈block的生命周期#

三、捕获变量的底层实现#

四、运行时 block 类型的确定#

五、汇编验证 block 的类型转换#

九、补充：面试题一解析#