Block原理详解

Block详解

Block在OC中占有很重要的地位，在苹果各个底层库里面也有大量运用，所以就很有必要了解它的构成、原理。Block是开源的，这是下载地址。这里以libclosure-67为基础。

简介

在data.c文件中，定义了6种类型的block，分别为：

  • void * _NSConcreteStackBlock[32] = { 0 };
  • void * _NSConcreteMallocBlock[32] = { 0 };
  • void * _NSConcreteAutoBlock[32] = { 0 };
  • void * _NSConcreteFinalizingBlock[32] = { 0 };
  • void * _NSConcreteGlobalBlock[32] = { 0 };
  • void * _NSConcreteWeakBlockVariable[32] = { 0 };

他们是一个void *类型的数组，占用256个字节，他们在内存中是连续分布的，值都为0。在iOS环境中只会用到_NSConcreteStackBlock、_NSConcreteGlobalBlock、_NSConcreteMallocBlock3个，其他3个是在GC环境中用到。在编译阶段赋初值只会用到_NSConcreteStackBlock、_NSConcreteGlobalBlock，_NSConcreteMallocBlock是在运行时调用_objc_retainBlock -> _Block_copy用到的。

_NSConcreteGlobalBlock

在编译阶段基本上都会被初始化为_NSConcreteStackBlock，只有在以下情况中，block会初始化为_NSConcreteGlobalBlock：

  • 未捕获外部变量
    在编译的时候，clang会检查是否有引用外部变量，如果没有就被设置为_NSConcreteGlobalBlock。

  • 当需要布局（layout）的变量的数量为0
    static修饰的变量，它的layout的数量就为0

先来定义一个最简单的block，通过rewrite看一下它的底层实现。

void (^log)(void) = ^(){};   log();
/*转化后*/  
void (*log)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
    ((void (*)(__block_impl *))((__block_impl *)log)->FuncPtr)((__block_impl *)log);

可以看到block是一个函数指针变量，它的值是__main_block_impl_0的地址。

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) {}
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)};

再看__main_block_impl_0，它其实就是一个结构体，初始化的时候给impl、Desc赋值，然后取这个新生成的结构体地址赋值给block，同时还生成了一个__main_block_func_0的函数，再把这个函数赋值为impl.FuncPtr。block的调用直接拿到FuncPtr，然后执行__main_block_func_0函数。

这样看起来挺详细的，也符合正常的代码逻辑，但是运行的时候真的是这样的吗？
通过hopper查看它的可执行文件，查看定义block的那个函数，发现block变成___block_literal_global.52变量，执行体变成了___globalBlock_block_invoke函数，而且在调用block之前还调用了objc_retainBlock函数，函数体执行完后，又调了objc_storeStrong函数。

下面所有的汇编都是通过hopper查看的，是x86的架构，但是我也都有在xcode运行查看at&t的汇编，逻辑是一致。

                     _globalBlock:
...
0000000100001d48         lea        rax, qword [___block_literal_global.52]
0000000100001d4f         mov        rdi, rax                                    
0000000100001d52         call       imp___stubs__objc_retainBlock
0000000100001d57         mov        qword [rbp+var_8], rax
0000000100001d5b         mov        rax, qword [rbp+var_8]
0000000100001d5f         mov        rdi, rax
0000000100001d62         call       qword [rax+0x10]
...                                  
0000000100001d70         call       imp___stubs__objc_storeStrong
...

再看下___block_literal_global.52的定义，发现它第一个值为__NSConcreteGlobalBlock，第三个值为___globalBlock_block_invoke函数的地址，这跟block的结构体 定义完全符合。同时也跟xcode的反汇编一致。

objc_retainBlock方法很简单，就是调用_Block_copy，看它的源码会知道，如果aBlock->flags & BLOCK_IS_GLOBAL直接把传进来的block再返回，相当于什么都没做。

这里还有一个问题，在运行时通过xcode查看这个block时，发现它的isa不是__NSConcreteGlobalBlock，而是__NSGlobalBlock__，这是啥呢？它从哪被改变了呢？

NSGlobalBlock

通过查找一些资料，发现是在CoreFoundation动态库__CFInitialize方法里面进行改变的。然后通过hopper查看它的信息发现，__NSGlobalBlock是一个类，继承于NSBlock，我又查询了下__NSGlobalBlock__，它也是个类，在libsystem_blocks.dylib动态库里面，继承于__NSGlobalBlock。

我再通过调式runtime源码，看到__CFMakeNSBlockClasses这个方法会处理__NSConcreteGlobalBlock，再看它的汇编，它会把data.c6种block都处理掉，这里看下__NSConcreteGlobalBlock的流程。

/*伪代码*/
Class __NSStackBlock = _objc_lookUpClass(“__NSGlobalBlock”);
objc_initializeClassPair_internal(__NSGlobalBlock, “__NSGlobalBlock__”, &__NSConcreteGlobalBlock, &__NSConcreteGlobalBlock+0x80);

这段代码作用就是把__NSConcreteGlobalBlock的地址空间赋值为class，通过参数赋值内容，其中类名是__NSGlobalBlock__。

这样一来都清楚了，在APP启动的时候都把对应的类赋值到他们的地址空间，所以哪怕isa还是那6种类型，但是地址里面存的东西变成了相对应的类。

_NSConcreteStackBlock

block被初始化成_NSConcreteStackBlock类型，说明肯定有引用外部变量，外部变量又分为基础变量和自定义变量（对象）这2种情况，它们对block的处理也都不同。

基础变量捕获

因为rewrite不准，所以接下来都以汇编为例，但是它可做为参考。
直接上引用基础变量block的汇编:

;stackBasicBlock:
...
000000010000157c         lea        rcx, qword [___block_descriptor_tmp.10]
0000000100001583         lea        rdx, qword [___stackBasicBlock_block_invoke]
000000010000158a         mov        rsi, qword [__NSConcreteStackBlock_100002010]
0000000100001591         mov        dword [rbp+var_4], 0xa
;开始构建block
0000000100001598         mov        qword [rbp+var_38], rsi
000000010000159c         mov        dword [rbp+var_30], 0xc0000000
00000001000015a3         mov        dword [rbp+var_2C], 0x0
00000001000015aa         mov        qword [rbp+var_28], rdx
00000001000015ae         mov        qword [rbp+var_20], rcx
00000001000015b2         mov        edi, dword [rbp+var_4]
00000001000015b5         mov        dword [rbp+var_18], edi
00000001000015b8         mov        rdi, rax                                    
; argument "instance" for method imp___stubs__objc_retainBlock
00000001000015bb         call       imp___stubs__objc_retainBlock
...
; 执行block
00000001000015ba         call       qword [rax+0x10]
...                                  
; argument "value" for method imp___stubs__objc_storeStrong
00000001000015df         lea        rax, qword [rbp+var_10]
00000001000015e3         mov        rdi, rax                                    
; argument "addr" for method imp___stubs__objc_storeStrong
00000001000015e6         call       imp___stubs__objc_storeStrong
...

前几行把block_descriptor、block_invoke、__NSConcreteStackBlock移动到寄存器，接下来开始把相关的变量移动到内存，然后调用objc_retainBlock拷贝block从栈上到堆上，最后再调用
objc_storeStrong进行销毁block。

因为基础变量是没有_Block_descriptor_2的，所以直接都返回了，不会再调用它的copy方法。

自定义变量捕获

在编译阶段，block的flags的值一般为BLOCK_HAS_COPY_DISPOSE、BLOCK_IS_GLOBAL、BLOCK_HAS_SIGNATURE，如果为BLOCK_HAS_COPY_DISPOSE，都还会生成___copy_helper_block_:、___destroy_helper_block_:方法，用于拷贝和销毁捕获变量。

enum {
    BLOCK_DEALLOCATING =      (0x0001),  // runtime  正在 dealloc
    BLOCK_REFCOUNT_MASK =     (0xfffe),  // runtime  引用计数掩码，即从第 1 ~ 15 位是用来存引用计数的，第 0 位上面已经被用了
    BLOCK_NEEDS_FREE =        (1 << 24), // runtime  需要释放，即它现在在堆上
    BLOCK_HAS_COPY_DISPOSE =  (1 << 25), // compiler 是否有 copy / dispose 函数，copy 和 dispose 在 desc 中
    BLOCK_HAS_CTOR =          (1 << 26), // compiler: helpers have C++ code block 有 C++ 的构造器
    BLOCK_IS_GC =             (1 << 27), // runtime  用了 GC，这个不用管，GC 已经被淘汰
    BLOCK_IS_GLOBAL =         (1 << 28), // compiler 是否处于全局区
    BLOCK_USE_STRET =         (1 << 29), // compiler: undefined if !BLOCK_HAS_SIGNATURE
                                         //    返回值是否在栈上，如果没有签名，则它一定是 0
    BLOCK_HAS_SIGNATURE  =    (1 << 30), // compiler 是否有签名，签名是描述 block 的参数和返回值的一个字符串
    BLOCK_HAS_EXTENDED_LAYOUT=(1 << 31)  // compiler 是否有扩展布局
};

这里定义一个捕获外部对象的block，看一下相关的汇编代码，跟基础变量引用有什么不一样。

;_stackClassBlock:
...
;生成block结构
0000000100001669         lea        rax, qword [___block_descriptor_tmp.16]
0000000100001670         lea        rsi, qword [___stackClassBlock_block_invoke]
0000000100001677         mov        rdi, qword [__NSConcreteStackBlock_100002010]
000000010000167e         lea        rcx, qword [rbp+var_38]
0000000100001682         add        rcx, 0x20
0000000100001686         mov        qword [rbp+var_38], rdi
000000010000168a         mov        dword [rbp+var_30], 0xc2000000
0000000100001691         mov        dword [rbp+var_2C], 0x0
0000000100001698         mov        qword [rbp+var_28], rsi
000000010000169c         mov        qword [rbp+var_20], rax
00000001000016a0         mov        rax, qword [rbp+var_8]
00000001000016a4         mov        rdi, rax    
                                
; argument "instance" for method imp___stubs__objc_retain
00000001000016a7         mov        qword [rbp+var_40], rcx
00000001000016ab         call       imp___stubs__objc_retain
00000001000016b0         lea        rcx, qword [rbp+var_38]
00000001000016b4         mov        qword [rbp+var_18], rax
00000001000016b8         mov        rdi, rcx               
                     
; argument "instance" for method imp___stubs__objc_retainBlock
; 里面会调用___copy_helper_block_ 调用objc_storeStrong 增加外部变量引用计数
00000001000016bb         call       imp___stubs__objc_retainBlock
00000001000016c0         mov        qword [rbp+var_10], rax
00000001000016c4         mov        rax, qword [rbp+var_10]
00000001000016c8         mov        rcx, rax
00000001000016cb         mov        rdi, rcx

;调用block
00000001000016ce         call       qword [rax+0x10]
...                                   
; 释放block 会调用___destroy_helper_block_方法 再次objc_storeStrong 减少外部变量引用计数                      
; argument "addr" for method imp___stubs__objc_storeStrong
00000001000016ff         mov        dword [rbp+var_44], eax
0000000100001702         call       imp___stubs__objc_storeStrong
0000000100001707         xor        eax, eax
0000000100001709         mov        esi, eax                                    
; 释放外部变量 减少引用计数                                 
; argument "addr" for method imp___stubs__objc_storeStrong
0000000100001712         call       imp___stubs__objc_storeStrong
0000000100001717         xor        eax, eax
0000000100001719         mov        esi, eax                                    
; 释放外部变量                          
; argument "addr" for method imp___stubs__objc_storeStrong
0000000100001722         call       imp___stubs__objc_storeStrong
...

外部对象引用变量比基础变量多了拷贝和销毁2步，而且在拷贝block之前还retain了外部变量，所以销毁的时候，objc_storeStrong会走4次，1次block，3次外部变量。

在_objc_retainBlock方法调用的时候，会调用Block_descriptor_2的copy方法，是_copy_helper_block_方法，它是动态生成的。它会调用_objc_storeStrong，旧值为一个地址，它的内容为0，新值为外部变量。

变量修饰符

通过上面2种情况，发现block有2点限制，1个是block定义后，在block执行前改变外部变量的值，block里面没有同步到，另外一个是在block执行体里面不能修改外部变量的值，原因是在编译阶段，对外部变量引用是拷贝操作，一旦block定义过了，就定死了，但是对于对象变量，可以修改对象内部空间的内容，因为对象的地址没有变，这就限制了很多使用的场景，那有没有办法解决上面2种情况呢？ 答案是用static和__block修饰符来修饰外部变量。

static修饰符

static修饰的变量是静态局部变量，它的初始值必须是编译期常量，如果有初始化，那么会存储在Section __data段，如果没有初始化，那么会存储在Section __bss段。static修饰的变量会一直占用空间，不会释放，所以它的地址在编译过后，永远不会变，变的只是里面存储的内容。

; Section __data
; Range: [0x100002388; 0x10000238c[ (4 bytes)
; File offset : [9096; 9100[ (4 bytes)
;   S_REGULAR

_stackStaticBasicBlock.num:
0000000100002388         dd         0x00000005   

; Section __bss
; Range: [0x100002390; 0x1000023a0[ (16 bytes)
; No data on disk
; Flags: 0x1
;   S_ZEROFILL

_stackClassBlock.per:
0000000100002390         dq         0x0000000000000000                          
_stackStaticClassBlock.per:
0000000100002398         dq         0x0000000000000000

在static修饰基础变量里面可以看到，变量有初始值，放在__data段，在修饰对象变量里面可以看到，变量没初始值，放在__bss段，因为对象的本质就是一个结构体指针，所以修饰对象的空间都是占8个字节，在运行期，往里面存储对象alloc出来的地址。这2个段，代码区都可以访问，所以说在block执行体里面也可以访问，不用捕获，直接操作static对象的地址就行，这样一来block的那2个问题也都可以解决掉，可以在任意地方去修改，去访问最新的值。

stackStaticBasicBlock:
...
00000001000017f8         lea        rax, qword [___block_literal_global.21]
00000001000017ff         mov        rdi, rax                                    
; argument "instance" for method imp___stubs__objc_retainBlock
0000000100001802         call       imp___stubs__objc_retainBlock

0000000100001807         mov        qword [rbp+var_8], rax
000000010000180b         mov        dword [_stackStaticBasicBlock.num], 0xa
0000000100001815         mov        rax, qword [rbp+var_8]
0000000100001819         mov        rdi, rax
;执行block
000000010000181c         call       qword [rax+0x10]
000000010000181f         xor        ecx, ecx
0000000100001821         mov        esi, ecx                                    
...                                 
; argument "addr" for method imp___stubs__objc_storeStrong 
000000010000182a         call       imp___stubs__objc_storeStrong
...

在上面也说过，没有引用外部和static修饰外部变量的都是_NSConcreteGlobalBlock类型，从上面汇编也能看出来。汇编前面都很容易理解，就是最后为啥要调objc_storeStrong来进行销毁呢？全局block编译完成后是存储在__const里面的，肯定不会销毁啊，我又debug了一把，想起来block一开始运行就变成了一个对象了，它有自定义release方法，所以会调用自定义的方法，但是这个方法呢，是空的，直接return了，所以说相当于啥都没干，但是呢，他把用到的栈空间给赋值为了0了。

上面的汇编是捕获基础变量的，但是跟对象是差不多的，区别是把alloc出来的地址赋值static变量，然后调用了一次objc_release，把原来的变量地址内容给release掉，不过一般里面都为0，所以也相当于什么都没做。

-[__NSGlobalBlock release]:
0000000000094390         push       rbp                                         
0000000000094391         mov        rbp, rsp
0000000000094394         pop        rbp
0000000000094395         ret

__block修饰符

__block修饰符就是为了解决block那2个场景而推出的，里面的实现也比较复杂(看汇编看了1天)，其实思想挺简单，就是用Block_byref结构对外部变量又包装了一层，然后把它的地址赋值给block内存地址后8位，他们的内存结构都是在运行期赋值到栈空间里面的。

__block修饰基础变量

因为__block修饰基本变量和自定义变量在编译期和运行期流程不太一样，所以这里先看基础变量，还是先上汇编代码。

_stackBlockBasicBlock:
...
;开始构建Block_byref结构
0000000100001998         mov        qword [rbp+var_20], 0x0
00000001000019a0         lea        rax, qword [rbp+var_20]
00000001000019a4         mov        qword [rbp+var_18], rax
00000001000019a8         mov        dword [rbp+var_10], 0x20000000
00000001000019af         mov        dword [rbp+var_C], 0x20
00000001000019b6         mov        dword [rbp+var_8], 0xa
;开始构建block结构
00000001000019bd         mov        rcx, qword [__NSConcreteStackBlock_100002010]
00000001000019c4         mov        qword [rbp+var_50], rcx
00000001000019c8         mov        dword [rbp+var_48], 0xc2000000
00000001000019cf         mov        dword [rbp+var_44], 0x0
00000001000019d6         lea        rcx, qword [___stackBlockBasicBlock_block_invoke]
00000001000019dd         mov        qword [rbp+var_40], rcx
00000001000019e1         lea        rcx, qword [___block_descriptor_tmp.23]
00000001000019e8         mov        qword [rbp+var_38], rcx
;把上面构建Block_byref的地址赋值到block的后8位
00000001000019ec         mov        qword [rbp+var_30], rax
；调objc_retainBlock方法
00000001000019f0         lea        rdi, qword [rbp+var_50]                     
; argument "instance" for method imp___stubs__objc_retainBlock
00000001000019f4         call       imp___stubs__objc_retainBlock
;给__block修饰变量赋值1 不是在栈上 已经copy过了，是在堆上了
00000001000019f9         mov        qword [rbp+var_28], rax
00000001000019fd         mov        rax, qword [rbp+var_18]
0000000100001a01         mov        dword [rax+0x18], 0x1
...
;调用block
0000000100001a18         call       rcx
...                                  
; argument "addr" for method imp___stubs__objc_storeStrong
0000000100001a2a         call       imp___stubs__objc_storeStrong
...                                  
; argument #1 for method imp___stubs___Block_object_dispose
0000000100001a3b         call       imp___stubs___Block_object_dispose
...

上面总的block结构已在xcode上验证，如下图:

blockaddress

上面的重点是objc_retainBlock这个方法，之后会调用_Block_copy方法。这个方法在runtime.c文件里面，在这里简单分析一下。

void *_Block_copy(const void *arg) {
    struct Block_layout *aBlock;
    if (!arg) return NULL;
    aBlock = (struct Block_layout *)arg;
    if (aBlock->flags & BLOCK_NEEDS_FREE) {
        // latches on high
        latching_incr_int(&aBlock->flags);
        return aBlock;
    } else if (aBlock->flags & BLOCK_IS_GLOBAL) {
        return aBlock;
    } else {
        // Its a stack block.  Make a copy.
        struct Block_layout *result = malloc(aBlock->descriptor->size);
        if (!result) return NULL;
        memmove(result, aBlock, aBlock->descriptor->size); 
        // reset refcount
        result->flags &= ~(BLOCK_REFCOUNT_MASK|BLOCK_DEALLOCATING);    // XXX not needed
        result->flags |= BLOCK_NEEDS_FREE | 2;  // logical refcount 1
        _Block_call_copy_helper(result, aBlock);
        // Set isa last so memory analysis tools see a fully-initialized object.
        result->isa = _NSConcreteMallocBlock;
        return result;
    }
}

通过flags的与运算，判断block的类型，如果是BLOCK_IS_GLOBAL就直接返回。之后就是在堆上开辟aBlock->descriptor->size大小的空间，memmove这个方法会把从aBlock地址开始的size大小内容move到result地址的起始位置，这样就把栈上的内容拷贝到堆上面了。

_Block_call_copy_helper方法会通过_Block_descriptor_2拿到它的copy方法进行调用，也就是编译时动态生成的__copy_helper_block_方法。

___copy_helper_block_:
...
;处理参数，rdi是堆上block存储Block_byref地址的地址 rsi就是栈上Block_byref的地址
0000000100001ac8         mov        edx, 0x8
0000000100001acd         mov        qword [rbp+var_8], rdi
0000000100001ad1         mov        qword [rbp+var_10], rsi
0000000100001ad5         mov        rsi, qword [rbp+var_10]
0000000100001ad9         mov        rdi, qword [rbp+var_8]
0000000100001add         add        rdi, 0x20                                   
...                    
0000000100001ae5         call       imp___stubs___Block_object_assign
...

_Block_object_assign会根据传入flags的不同，进行不同的处理，这里的flags表示的是引用外部变量的类型。flags是第三个参数，对应的是rdx，在这里是8，对应的是__block类型，所以调用_Block_byref_copy，参数是栈上的Block_byref的地址，返回的是堆上的地址，再赋值给堆上block的相应值。

enum {
    //外部变量类型 flags值
    BLOCK_FIELD_IS_OBJECT   =  3,  // id, NSObject, __attribute__((NSObject)), block, ...
    BLOCK_FIELD_IS_BLOCK    =  7,  // a block variable
    BLOCK_FIELD_IS_BYREF    =  8,  // the on stack structure holding the __block variable
    BLOCK_FIELD_IS_WEAK     = 16,  // declared __weak, only used in byref copy helpers
    BLOCK_BYREF_CALLER      = 128, // called from __block (byref) copy/dispose support routines.
};

对外部变量的拷贝是通过_Block_byref_copy函数处理的，这个函数的flags的处理有点不太理解，意思知道，但是实现细节不太明白？这里不看汇编了，直接看代码。

static struct Block_byref *_Block_byref_copy(const void *arg) {
    //传进的来是栈上的Block_byref地址
    struct Block_byref *src = (struct Block_byref *)arg;
    //引用计数为0时
    if ((src->forwarding->flags & BLOCK_REFCOUNT_MASK) == 0) {
        // 开辟空间
        struct Block_byref *copy = (struct Block_byref *)malloc(src->size);
        copy->isa = NULL;
        // byref value 4 is logical refcount of 2: one for caller, one for stack
        //看注释 引用计数是2 因为栈上的forwarding也引用它了
        copy->flags = src->flags | BLOCK_BYREF_NEEDS_FREE | 4;
        copy->forwarding = copy; // patch heap copy to point to itself
        src->forwarding = copy;  // patch stack to point to heap copy
        copy->size = src->size;
        //外部变量需要拷贝了走这个  不是Block_byref 是外部变量
        if (src->flags & BLOCK_BYREF_HAS_COPY_DISPOSE) {
            // Trust copy helper to copy everything of interest
            // If more than one field shows up in a byref block this is wrong XXX
            struct Block_byref_2 *src2 = (struct Block_byref_2 *)(src+1);
            struct Block_byref_2 *copy2 = (struct Block_byref_2 *)(copy+1);
            copy2->byref_keep = src2->byref_keep;
            copy2->byref_destroy = src2->byref_destroy;

            if (src->flags & BLOCK_BYREF_LAYOUT_EXTENDED) {
                struct Block_byref_3 *src3 = (struct Block_byref_3 *)(src2+1);
                struct Block_byref_3 *copy3 = (struct Block_byref_3*)(copy2+1);
                copy3->layout = src3->layout;
            }
            (*src2->byref_keep)(copy, src);
        }
        else {
            //外部变量不需要拷贝 也就是基础变量 直接拷贝外部变量的值 到堆上
            memmove(copy+1, src+1, src->size - sizeof(*src));
        }
    }
    //已经在堆上  增加引用计数
    else if ((src->forwarding->flags & BLOCK_BYREF_NEEDS_FREE) == BLOCK_BYREF_NEEDS_FREE) {
        latching_incr_int(&src->forwarding->flags);
    }
    //返回copy地址
    return src->forwarding;
}

这里需要注意的是struct Block_byref结构里面是没有外部变量的，所以在memmove调用的时候把copy和src指针都加1，指向外部变量的地址，src->size - sizeof(*src)也就是外部变量的所占空间大小。

__block修饰自定义变量

对于修饰自定义变量，在编译期，会增加4个方法，有2个Block_descriptor_2的copy、dispose方法，在编译的时候会把他们指向新增加的2个方法，___copy_helper_block和___destroy_helper_block。还有2个是拷贝和销毁外部变量的方法，___Block_byref_object_copy_、___Block_byref_object_dispose_。

先来看下__block修饰自定义变量这一行在汇编是什么样的？

_stackBlockClassBlock:
...
;开始在栈上构建__block的包装层 也就是Block_byref 占用了0x30字节
0000000100001b2b         mov        qword [rbp+var_30], 0x0   ;isa变量
0000000100001b33         lea        rax, qword [rbp+var_30]    
0000000100001b37         mov        qword [rbp+var_28], rax   ;forwarding变量
0000000100001b3b         mov        dword [rbp+var_20], 0x32000000  ;flags变量
0000000100001b42         mov        dword [rbp+var_1C], 0x30  ;size变量
0000000100001b49         lea        rax, qword [___Block_byref_object_copy_]
0000000100001b50         mov        qword [rbp+var_18], rax   ;变量copy函数地址
0000000100001b54         lea        rax, qword [___Block_byref_object_dispose_]
0000000100001b5b         mov        qword [rbp+var_10], rax   ;变量dispose函数地址
0000000100001b5f         lea        rax, qword [rbp+var_8]
0000000100001b63         mov        rdi, qword [objc_cls_ref_Person]            
; argument "instance" for method _objc_msgSend
0000000100001b6a         mov        rsi, qword [0x1000022f8]                    
; @selector(alloc), argument "selector" for method _objc_msgSend
0000000100001b71         mov        rcx, qword [_objc_msgSend_100002020]
0000000100001b78         mov        qword [rbp+var_78], rax
0000000100001b7c         mov        qword [rbp+var_80], rcx
调用alloc方法 通过_objc_msgSend
0000000100001b80         call       rcx                                         
; _objc_msgSend
0000000100001b82         mov        rsi, qword [0x100002300]                    ; @selector(init)
0000000100001b89         mov        rdi, rax
0000000100001b8c         mov        rax, qword [rbp+var_80]
；调用init方法  通过_objc_msgSend
0000000100001b90         call       rax
；把生成自定义变量的堆地址 赋值给Block_byref 最后8位
0000000100001b92         mov        qword [rbp+var_8], rax

跟修饰基础变量不一样，多了自定义变量的拷贝销毁函数的地址，而且最后8位是自定义变量的堆地址。block的构建跟修饰基础变量一样，也是把Block_byref它的地址，赋值到block的后8位，占用40个字节，在Block_descriptor_1里面有对应的字节数。

接下来的步骤跟__block修饰基础变量一样，不过在_Block_byref_copy方法里面，会进入if (src->flags & BLOCK_BYREF_HAS_COPY_DISPOSE)这个判断条件，然后调用___Block_byref_object_copy_方法。

struct Block_byref_2 {
    // requires BLOCK_BYREF_HAS_COPY_DISPOSE
    void (*byref_keep)(struct Block_byref *dst, struct Block_byref *src);
    void (*byref_destroy)(struct Block_byref *);
};

看了Block_byref_2它的数据结构，一下子也都对应上了。

_Block_copy
    _Block_copy_internal
        malloc
        memmove
        _Block_call_copy_helper
            _Block_descriptor_2
            _Block_object_assign
                _Block_byref_assign_copy
                    _Block_allocator
                        malloc
                _Block_memmove
                    memmove
                _Block_assign
_objc_storeStrong
    _objc_release
        _Block_release
             _Block_call_dispose_helper
                 _Block_descriptor_2
                 _Block_object_dispose
                     _Block_byref_release
             _Block_destructInstance
             _Block_deallocator = free
_Block_object_dispose
    _Block_byref_release
        _Block_deallocator = free

外部变量捕获

block是一个执行块，那么肯定有和外部变量交互的情况，这里简单改下block，看看它的实现又有那些改变。

int num = 10;
void (^log)(int a) = ^(int x){
    x = num;
};
log(5);    
/*转化后*/    
int num = 10;
    void (*log)(int a) = ((void (*)(int))&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, num));
    ((void (*)(__block_impl *, int))((__block_impl *)log)->FuncPtr)((__block_impl *)log, 5);

可以看到block直接把外部变量num传进去了，再看下__main_block_impl_0结构。

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  int num;
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _num, int flags=0) : num(_num) 
  ...
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself, int x) {
  int num = __cself->num; // bound by copy
  x = num;
}

__main_block_impl_0结构体增加了一个外部变量，然后__main_block_func_0执行体通过__cself参数拿到变量。从这里能够看出，在定义block的时候，已经把外部变量传进去了，再改变外部变量，block里面外部变量的值也不会改变的。

那有没有办法解决这个问题呢？答案是外部变量用static修饰就行了，如static int num = 10;。

static int num = 10;
void (*log)(int a) = ((void (*)(int))&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, &num));

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  int *num;
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int *_num, int flags=0) : num(_num) 
  ...
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself, int x) {
    int *num = __cself->num; // bound by copy
    x = (*num);
}

用static修改外部变量后，捕获变量时，赋值的是它的指针。block执行体里面用到外部变量时，是通过地址获取它的值，所以哪怕定义block后再改变外部变量的值，函数里面也是最新的值。

__Block修饰符

block函数捕获外部变量后，那能改变它的值吗？正常的捕获是不能改变的，除非用修饰符来修饰外部变量，如上面介绍的static，还有接下来介绍的__block。

 __block int num = 10;
void (^log)(int a) = ^(int x){
    x = num;
    num = 100;
};
num = 1;
log(5);
/*转化后*/
__attribute__((__blocks__(byref))) __Block_byref_num_0 num = {(void*)0,(__Block_byref_num_0 *)&num, 0, sizeof(__Block_byref_num_0), 10};
    void (*log)(int a) = ((void (*)(int))&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_num_0 *)&num, 570425344));
    (num.__forwarding->num) = 1;
    ((void (*)(__block_impl *, int))((__block_impl *)log)->FuncPtr)((__block_impl *)log, 5);

__block转化成了__attribute__((__blocks__(byref)))，但是不知道它的作用是什么，网上我也没查到相关资料。

通过gcc -dM -E - < /dev/null命令查看，可以看到有#define __block __attribute__((__blocks__(byref)))。

int类型转化成了__Block_byref_num_0，然后后面就是给它的初始化，block捕获外部变量是__Block_byref_num_0变量的指针。

struct __Block_byref_num_0 {
  void *__isa;
__Block_byref_num_0 *__forwarding;
 int __flags;
 int __size;
 int num;
};
struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __Block_byref_num_0 *num; // by ref
      __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_num_0 *_num, int flags=0) : num(_num->__forwarding) 
    ...
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself, int x) {
    __Block_byref_num_0 *num = __cself->num; // bound by ref
    x = (num->__forwarding->num);
    (num->__forwarding->num) = 100;
}
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src)
{
    _Block_object_assign((void*)&dst->num, (void*)src->num, 8/*BLOCK_FIELD_IS_BYREF*/);
}
static void __main_block_dispose_0(struct __main_block_impl_0*src) {
    _Block_object_dispose((void*)src->num, 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};

__Block_byref_num_0是一个结构体，__forwarding是一个指向本身类型的指针。
通过__main_block_impl_0的初始化，可以看到num变量的值是外部传过来_num指针的__forwarding变量。因为__forwarding还是指向num的地址，所以其实相当于直接传入外部变量的地址。

__block还发生了一些改变：
1、生成了__main_block_copy_0、__main_block_dispose_0函数。
2、__main_block_desc_0结构体多了copy、dispose函数指针，值是上面2个函数。

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 199,830评论 5赞 468
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 83,992评论 2赞 376
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 146,875评论 0赞 331
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 53,837评论 1赞 271
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 62,734评论 5赞 360
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,091评论 1赞 277
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 37,550评论 3赞 390
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,217评论 0赞 254
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 40,368评论 1赞 294
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,298评论 2赞 317
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,350评论 1赞 329
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,027评论 3赞 315
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 38,623评论 3赞 303
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,706评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 30,940评论 1赞 255
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 42,349评论 2赞 346
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 41,936评论 2赞 341