015-iOS底层原理-block

引言-“毒鸡汤”

一个好的iOS开发,block必不可少,都会用,但是block的底层原理,我们确都是“浅尝辄止”,满足开发就好。人们总说“俗话说”,但是很多俗话说,不都是前人一步一个坑结结实实的踩了,才总结出来的一句话。那么俗话说“逆水行舟,不进则退”,是否也可以用在开发上?我觉得可以。薪水可以变,但是时间不等人。技术深度(广度)应该是至少跑赢时间(可能大盘看多了,收益跑赢大盘这句话就常挂嘴边)。
希望每一位开发者,都应该具备“危机意识”,在有限的时间,学到更多的技术。
话不多说,今天这个文章,是探索block的底层原理。

本文Demo

block 底层结构

【1】普通block

按照我们探索类的内存时,用到的探索方式,首先查看编译成底层c++的代码是怎么样的。 在main.m中设计代码如下:

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        int a = 1001;
        NSString *str = @"百事可乐";
        void (^qlBlock)(void) = ^{
            NSLog(@"a = %d -- str = %@",a,str);
        };
        
        qlBlock();
    }
    return 0;
}

打开终端,通过xcrun指令将main.m转成main.cpp文件:

xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m -o main.cpp

打开main.cpp,拉到最底下,找到main函数。将括号内的类型转换删除,得到精简代码如下:

int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 
        int a = 1001;
        NSString *str = (NSString *)&__NSConstantStringImpl__var_folders_wv_3h_d7hqj7zz300r8bmzy6_y00000gn_T_main_2abb7f_mi_0;
        // __main_block_impl_0函数
        void (*qlBlock)(void) = __main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA, a, str, 570425344);

        qlBlock->FuncPtr(qlBlock);
    }
    return 0;
}

1、void (*qlBlock)(void)赋值为一个函数调用__main_block_impl_0 ()
2、搜索__main_block_impl_0找到block的底层实际上也是一个结构体,并且__main_block_impl_0 ()block的构造函数,源码如下:

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  int a; // 将block外部的变量a捕获成为自己的成员变量
  NSString *str; // 将block外部的变量str捕获成为自己的成员变量
  // 构造函数:
  // 参数1、void *fp:传的是函数__main_block_func_0(),该函数就是block的执行代码块 ^{ },这个fp传给了 FuncPtr,在qlBlock->FuncPtr(qlBlock);中调用
  // 参数2、struct __main_block_desc_0 *desc:block的信息结构体
  // 参数3、4 外部捕获的变量,a(_a), str(_str) 分别表示_a赋值给a,_str赋值给str
  // 
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _a, NSString *_str, int flags=0) : a(_a), str(_str) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

3、qlBlock->FuncPtr(qlBlock);调起block,FuncPtr已经在前面的构造函数中赋值为__main_block_func_0 ()函数。因此,此处调的就是这个函数,并把block自己传进去。该block已捕获了外部变量a,str

【2】外部变量加上 __block关键字

我们将外部变量a和str分别加上__block关键字,并在block执行块中修改a和str,main.m代码设计如下:

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        __block int a = 1001;
        __block NSString *str = @"百事可乐";
        void (^qlBlock)(void) = ^{
            a = 2002;
            str = @"可口可乐";
            NSLog(@"a = %d -- str = %@",a,str);
        };
        qlBlock();
    }
    return 0;
}

打开终端,通过xcrun指令将main.m转成main.cpp文件:

xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m -o main.cpp

打开main.cpp,拉到最底下,找到main函数。将括号内的类型转换删除,得到精简代码如下:

1、block的结构体
struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __Block_byref_a_0 *a; // by ref
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_a_0 *_a, int flags=0) : a(_a->__forwarding) { // 将 _a-> __forwarding赋值给a
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
2、main函数
int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 
        __Block_byref_a_0 a = {0,&a, 0, sizeof(__Block_byref_a_0), 1001};
        // __main_block_impl_0()
        void (*qlBlock)(void) = (__main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA, &a, 570425344));
        // 调用
        qlBlock->FuncPtr)(qlBlock);
    }
    return 0;
}
3、生成的a结构体
struct __Block_byref_a_0 {
    void *__isa;
    __Block_byref_a_0 *__forwarding;
    int __flags;
    int __size;
    int a;
};
4、block执行的代码块
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {// 传入block自己
    // 获取block生成的并赋值好的a
    __Block_byref_a_0 *a = __cself->a; // bound by ref
    // 结构体a通过__forwarding获取结构体a内部的成员变量a,并进行修改
    (a->__forwarding->a) = 2002;
    
    NSLog((NSString *)&__NSConstantStringImpl__var_folders_wv_3h_d7hqj7zz300r8bmzy6_y00000gn_T_main_6d01e1_mi_0,(a->__forwarding->a));
}

由编译后的源码可知,
1、外部变量加了__block后,block对外部变量的捕获,不再是单纯的生成与之对应的成员变量,而是在内部生成__Block_byref_a_0 *a的结构体指针变量。
2、在main函数中,先将外部的__block int a编译后,生成一个结构体__Block_byref_a_0(其内部如上3、生成的a结构体,该结构体内部生成一个对应的int a,用于接收外部int a的初始值1001,同时将外部int a的地址&a赋值给__forwarding),初始化赋值代码:__Block_byref_a_0 a = {0,&a, 0, sizeof(__Block_byref_a_0), 1001};
3、到此为止,生成的结构体a的__forwarding为外部int a的地址,
block结构体内部的*a与外部变量a所指向的内存空间是同一个,捕获的外部变量会随着block生成的对应成员变量改变而改变。

block 底层结构小结

1、block的本质是一个结构体;
2、block的定义,是通过block的结构体内部的构造函数,对block内部的impl、desc进行赋值。
3、结构体impl内部有4个成员变量:isa、Flags、Reserved、FuncPtr,在block构造函数赋值时,将isa赋值为默认的NSConcreteStackBlock地址(此为编译阶段,运行时这个isa会赋值成真实类型),FuncPtr 的赋值是定义的block执行代码块。
4、block捕获外部变量,是在block内部生成对应的成员变量,并通过构造函数将捕获的变量赋值给内部生成的成员变量--(值拷贝)
5、block捕获的外部变量,如果用__block修饰,则不再是将值传给block内部生成的变量,而是将外部变量的地址传给内部成员变量,达到你动我动的效果--(指针拷贝)

block 源码

1、在苹果官网Source Browser下载libclosure-79,解压打开Blocks工程。
2、在原来的objc工程main.m中,定一个最简单的block,并打上断点,运行到断点后,打开汇编(Debug--Debug Workflow -- Always Show Disassembly)。


3、在汇编中,查看block的类型,以及将要call的符号

4、点击step into,进入到objc_retainBlock函数中,可看到将要访问_Block_copy此函数即可将 stack block 复制成 malloc block

5、继续点击step into会回到main的汇编。因此_Block_copy是我们继续探索的函数符号。打开1的Blocks工程。全局搜索_Block_copy,源码如下(注意看注释)

// Copy, or bump refcount, of a block.  If really copying, call the copy helper if present.
void *_Block_copy(const void *arg) {
    // block的真实结构Block_layout
    struct Block_layout *aBlock;

    if (!arg) return NULL;
    
    // The following would be better done as a switch statement
    aBlock = (struct Block_layout *)arg;
    // 如果是释放状态,没必要进行下一步处理,直接返回aBlock
    if (aBlock->flags & BLOCK_NEEDS_FREE) {
        // latches on high
        latching_incr_int(&aBlock->flags);
        return aBlock;
    }
    else if (aBlock->flags & BLOCK_IS_GLOBAL) {
        // 如果是global类型的block,直接返回。
        return aBlock;
    }
    else {
        // 如果不是global block,那么只有两种情况:1、栈block(StackBlock),2、堆block(MallocBlock)
        // 在编译阶段,暂时会将block标记成栈block,是因为在编译阶段,若是对block进行malloc开辟内存的话,会增加编译器的压力
        // 来到运行时(runtime),block捕获了外部变量,则需要将栈block 的大小,malloc(size)开辟一个内存空间
        // Its a stack block.  Make a copy.
        size_t size = Block_size(aBlock);
        struct Block_layout *result = (struct Block_layout *)malloc(size);
        if (!result) return NULL;
        // 开始copy
        memmove(result, aBlock, size); // bitcopy first
#if __has_feature(ptrauth_calls)
        // Resign the invoke pointer as it uses address authentication.
        // invoke的copy
        result->invoke = aBlock->invoke;

#if __has_feature(ptrauth_signed_block_descriptors)
        if (aBlock->flags & BLOCK_SMALL_DESCRIPTOR) {
            uintptr_t oldDesc = ptrauth_blend_discriminator(
                    &aBlock->descriptor,
                    _Block_descriptor_ptrauth_discriminator);
            uintptr_t newDesc = ptrauth_blend_discriminator(
                    &result->descriptor,
                    _Block_descriptor_ptrauth_discriminator);

            result->descriptor =
                    ptrauth_auth_and_resign(aBlock->descriptor,
                                            ptrauth_key_asda, oldDesc,
                                            ptrauth_key_asda, newDesc);
        }
#endif
#endif
        // reset refcount
        // 重置refcount和配置flags
        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.
        // 将block类型标记为堆block(MallocBlock)
        result->isa = _NSConcreteMallocBlock;
        return result;
    }
}

6、通过源码可知流程如下:
a)oc定义的block 不 捕获外部变量 ---->编译器--->global block---->运行时--->return global block
b)oc定义的block捕获外部变量 ---->编译器--->stack block ---->运行时_Block_copy--->malloc block
7、block的底层结构为struct Block_layout结构体,源码如下(注意注释):

struct Block_layout {
    // isa的指向:也可以说是block的类型:1、global block;2、stack block;3、malloc block
    void * __ptrauth_objc_isa_pointer isa;
    // 标识
    volatile int32_t flags; // contains ref count
    int32_t reserved;
    // 执行函数
    BlockInvokeFunction invoke;
    // block的信息描述
    struct Block_descriptor_1 *descriptor;
    // imported variables
};
  • 7.1、结构体Block_layout的成员变量struct Block_description_1开始,往下都是为可选参数,也就是说,block的描述信息,可以在以下结构体中选择(但是具体如何设置,根据#define条件来配置,在哪儿配置,我们不得而知,然我们可以通过反推法来了解,即不知道setter,通过getter来了解):
#define BLOCK_DESCRIPTOR_1 1
struct Block_descriptor_1 {
    uintptr_t reserved;
    uintptr_t size;
};
#define BLOCK_DESCRIPTOR_2 1
struct Block_descriptor_2 {
    // requires BLOCK_HAS_COPY_DISPOSE
    BlockCopyFunction copy;
    BlockDisposeFunction dispose;
};
#define BLOCK_DESCRIPTOR_3 1
struct Block_descriptor_3 {
    // requires BLOCK_HAS_SIGNATURE
    const char *signature;
    const char *layout;     // contents depend on BLOCK_HAS_EXTENDED_LAYOUT
};
struct Block_descriptor_small {
    uint32_t size;
    int32_t signature;
    int32_t layout;
    /* copy & dispose are optional, only access them if
       Block_layout->flags & BLOCK_HAS_COPY_DIPOSE */
    int32_t copy;
    int32_t dispose;
};
  • 7.2 block desc的几种情况
  • 7.2.1 Block_descriptor_1:搜索_Block_get_descriptor,源码如下:
// getter 函数
static inline void *_Block_get_descriptor(struct Block_layout *aBlock)
{
    void *descriptor;
#if __has_feature(ptrauth_signed_block_descriptors)
    if (!(aBlock->flags & BLOCK_SMALL_DESCRIPTOR)) {
        descriptor =
                (void *)ptrauth_strip(aBlock->descriptor, ptrauth_key_asda);
    } else {
        uintptr_t disc = ptrauth_blend_discriminator(
                &aBlock->descriptor, _Block_descriptor_ptrauth_discriminator);
        descriptor = (void *)ptrauth_auth_data(
                aBlock->descriptor, ptrauth_key_asda, disc);
    }
#elif __has_feature(ptrauth_calls)
    descriptor = (void *)ptrauth_strip(aBlock->descriptor, ptrauth_key_asda);
#else
    descriptor = (void *)aBlock->descriptor;
#endif
    return descriptor;
}
// setter函数
static inline void _Block_set_descriptor(struct Block_layout *aBlock, void *desc)
{
    aBlock->descriptor = (struct Block_descriptor_1 *)desc;
}
  • 7.2.2 Block_descriptor_2:全局搜索Block_descriptor_2,源码如下(看下图解释):
static struct Block_descriptor_2 * _Block_descriptor_2(struct Block_layout *aBlock)
{
    uint8_t *desc = (uint8_t *)_Block_get_descriptor(aBlock);
    desc += sizeof(struct Block_descriptor_1);// 看下图解释
    return (struct Block_descriptor_2 *)desc;
}
  • 7.2.3 Block_descriptor_3:全局搜索Block_descriptor_3,源码如下(看上图解释):
    Block_descriptor_2存在,则指针偏移在desc的基础上,加上Block_descriptor_1的大小,再加上Block_descriptor_2的大小,即可得到Block_descriptor_3。(desc3 = desc + sizeOf(desc1) + sizeOf(desc2))
    Block_descriptor_2不存在,则指针偏移在desc的基础上,加上Block_descriptor_1的大小,即可得到Block_descriptor_3。(desc3 = desc + sizeOf(desc1) )
static struct Block_descriptor_3 * _Block_descriptor_3(struct Block_layout *aBlock)
{
    uint8_t *desc = (uint8_t *)_Block_get_descriptor(aBlock);
    desc += sizeof(struct Block_descriptor_1);
    if (aBlock->flags & BLOCK_HAS_COPY_DISPOSE) {
        desc += sizeof(struct Block_descriptor_2);
    }
    return (struct Block_descriptor_3 *)desc;
}

block 调试

1、未捕获外部变量:回到objc工程,在main.m添加如下代码,并添加断点:


2、捕获外部变量:

3、添加_Block_copy符号断点,运行时,先暂时关闭_Block_copy断点,因为在运行时会有一些系统的block会调用此函数进行复制,我们只需要在自定义的block断点停住时,把_Block_copy断点激活即可。打开Debug 汇编

3.1:我们通过lldb调试的指令register read读取寄存器的情况(真机的寄存器名字为x0,x1等),最终看到在_Block_copy函数内部的汇编block的类型的变化,对应上面的_Block_copy源码即可。

3.2:继续点击step over,一直回到main.m时,在block调用处打上断点。通过lldb调试的指令register read读取寄存器的情况,如图所示:

若外部变量为对象,则会多一个copy和dispose。即7.1中的block信息描述选择。

<__NSStackBlock__: 0x7ffeefbff428>
 signature: "v8@?0"
 invoke   : 0x1000038e0 (/Users/monan/Library/Developer/Xcode/DerivedData/LGProject-dyfiqisfsswhupfyzablyalixxxt/Build/Products/Debug/QLObjcTest`__main_block_invoke)
 copy     : 0x100003910 (/Users/monan/Library/Developer/Xcode/DerivedData/LGProject-dyfiqisfsswhupfyzablyalixxxt/Build/Products/Debug/QLObjcTest`__copy_helper_block_e8_32s)
 dispose  : 0x100003950 (/Users/monan/Library/Developer/Xcode/DerivedData/LGProject-dyfiqisfsswhupfyzablyalixxxt/Build/Products/Debug/QLObjcTest`__destroy_helper_block_e8_32s)

3.3:signature的值可参考前面的文章类的方法底层,是一样的。具体例子:lldb调试:[NSMethodSignature signatureWithObjCTypes:"v8@?0"];打印结果如下(注意注释):

(lldb) po [NSMethodSignature signatureWithObjCTypes:"v8@?0"];
<NSMethodSignature: 0x7afa2cf5db0b894b>
    number of arguments = 1
    frame size = 224
    is special struct return? NO
    return value: -------- -------- -------- --------
        type encoding (v) 'v'
        flags {}
        modifiers {}
        frame {offset = 0, offset adjust = 0, size = 0, size adjust = 0}
        memory {offset = 0, size = 0}
    argument 0: -------- -------- -------- --------
        type encoding (@) '@?' // 证明了block的encoding类型是`@?`
        flags {isObject, isBlock}
        modifiers {}
        frame {offset = 0, offset adjust = 0, size = 8, size adjust = 0}
        memory {offset = 0, size = 8}

block 捕获

【1】无__block修饰

  • 1.1 在main.m中设计代码如下:
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        NSObject *obj = [NSObject alloc];
        void (^ qlBlock)(void) = ^{
            NSLog(@"---%@---",obj);
        };
        qlBlock();
    }
    return 0;
}
  • 1.2 通过xcrun将源码编译成c/c++。
xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m -o main.cpp

将代码进行排版,清除一些类型强转,简化后的代码如下:

  • 1.3 从入口函数main()中可以看到,^{};最终翻译成函数__main_block_impl_0(),该函数的入参分析:
  • a)__main_block_func_0是一个函数指针,是block回调执行的代码块
  • b)(重点)&__main_block_desc_0_DATA是取结构体__main_block_desc_0的地址,该结构体赋值情况,即:
 __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0), __main_block_copy_0, __main_block_dispose_0};

具体对应的变量为:

size_t reserved = 0;
size_t Block_size = sizeof(struct __main_block_impl_0);
void (copy)(struct __main_block_impl_0, struct __main_block_impl_0) = __main_block_copy_0;
void (
dispose)(struct __main_block_impl_0*) = __main_block_dispose_0;

  • c)obj即我们定义的obj变量,obj作为参数传入block内部生成的obj变量,并将外部obj赋值给内部obj。由于obj是一个NSObject *的指针,此处obj传入相当于block生成的obj与外部的obj指向同一片堆空间。(block捕获外部变量的小结在上面的 block 底层结构小结
  • d)570425344数字参数,是一个暂时用不到的参数。暂不考虑。

【2】有__block修饰

我们在NSObject *obj前加入__block,然后 按照第【1】步的步骤,将main.m编译成c/c++。
将代码进行排版,清除一些类型强转,简化后的代码如下:

  • 2.1 与前面的无 __block 修饰的外部变量捕获相比,加了__block后,外部变量NSObject *obj逻辑编译成了一个结构体__Block_byref_obj_0 obj,该结构体源码如下:
  • 2.2 用__block修饰的外部遍历,block构造函数__main_block_impl_0传入的是&obj,也就是obj本身的地址,也就是说,外部的obj随着block内部的obj的变化而变化。
  • 2.3 无__block修饰的外部变量,block构造函数__main_block_impl_0传入的是obj,也就是obj指针指向的堆地址

【3】_Block_object_assign

  • 【3.1】 通过上面将block编译成c/c++文件的分析。我们可以看到在封装block信息描述的结构体desc中,传入了一__main_block_copy_0函数和一个__main_block_dispose_0函数。两个函数的实现如下:
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {
    _Block_object_assign(&dst->obj, src->obj, 8/*BLOCK_FIELD_IS_BYREF*/);
}

static void __main_block_dispose_0(struct __main_block_impl_0*src) {
    _Block_object_dispose(src->obj, 8/*BLOCK_FIELD_IS_BYREF*/);
}

_Block_object_assign()传入了三个参数:1、&dst->obj:目标block的obj地址;2、src->obj:原block的obj变量;3、8:BLOCK_FIELD_IS_BYREF,表示该对象用__block 修饰了。

The flags parameter of _Block_object_assign and _Block_object_dispose is set to
* BLOCK_FIELD_IS_OBJECT (3), for the case of an Objective-C Object,
* BLOCK_FIELD_IS_BLOCK (7), for the case of another Block, and
* BLOCK_FIELD_IS_BYREF (8), for the case of a __block variable.

即:

  • 捕获的外部变量为普通oc对象,则传入3;
  • 捕获的外部变量为其他block,则传入7;
  • 捕获的外部变量为用__block修饰的变量,则传入8;
  • 【3.2】 打开Blocks.xcodeproj工程,全局搜索_Block_object_assign,找到源码如下:
void _Block_object_assign(void *destArg, const void *object, const int flags) {
    const void **dest = (const void **)destArg;
    switch (os_assumes(flags & BLOCK_ALL_COPY_DISPOSE_FLAGS)) {
      case BLOCK_FIELD_IS_OBJECT:
    
        /*******
        id object = ...;
        [^{ object; } copy];
        ********/
        _Block_retain_object(object);
        *dest = object;
        break;

      case BLOCK_FIELD_IS_BLOCK:
        /*******
        void (^object)(void) = ...;
        [^{ object; } copy];
        ********/

        *dest = _Block_copy(object);
        break;
    
      case BLOCK_FIELD_IS_BYREF | BLOCK_FIELD_IS_WEAK:
      case BLOCK_FIELD_IS_BYREF:
        /*******
         // copy the onstack __block container to the heap
         // Note this __weak is old GC-weak/MRC-unretained.
         // ARC-style __weak is handled by the copy helper directly.
         __block ... x;
         __weak __block ... x;
         [^{ x; } copy];
         ********/

        *dest = _Block_byref_copy(object);
        break;
        
      case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_OBJECT:
      case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_BLOCK:
        /*******
         // copy the actual field held in the __block container
         // Note this is MRC unretained __block only. 
         // ARC retained __block is handled by the copy helper directly.
         __block id object;
         __block void (^object)(void);
         [^{ object; } copy];
         ********/

        *dest = object;
        break;

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

        *dest = object;
        break;

      default:
        break;
    }
}

分析:
通过flags & BLOCK_ALL_COPY_DISPOSE_FLAGS得到捕获的变量是什么类型,通过switch分支进行分类处理。

  • 3.2.1 case BLOCK_FIELD_IS_OBJECT: 如果捕获的变量是oc object ,则将捕获的object进行copy。(通过_Block_retain_object()回调给_Block_retain_object_default(),并将原block赋值给目标block*dest = object;
  • 3.2.2 case BLOCK_FIELD_IS_BLOCK: 如果捕获的对象是一个block,则走_Block_copy()函数,并将结果赋值给目标block。
  • 3.2.3(后面重点分析case BLOCK_FIELD_IS_BYREF : 如果捕获的变量是用__block修饰的或者__weak __block修饰的,将原block通过_Block_byref_copy()赋值给目标block。
  • 3.2.4 其余情况均是将原block直接赋值给目标block*dest = object;

【4】_Block_byref_copy

全局搜索_Block_byref_copy,得到源码如下:

static struct Block_byref *_Block_byref_copy(const void *arg) {
    struct Block_byref *src = (struct Block_byref *)arg;

    if ((src->forwarding->flags & BLOCK_REFCOUNT_MASK) == 0) {
        // src points to stack
        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
        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;

        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 {
            // Bitwise copy.
            // This copy includes Block_byref_3, if any.
            memmove(copy+1, src+1, src->size - sizeof(*src));
        }
    }
    // already copied to heap
    else if ((src->forwarding->flags & BLOCK_BYREF_NEEDS_FREE) == BLOCK_BYREF_NEEDS_FREE) {
        latching_incr_int(&src->forwarding->flags);
    }
    return src->forwarding;
}
  • 【4.1】判断语句if ((src->forwarding->flags & BLOCK_REFCOUNT_MASK) == 0),其中BLOCK_REFCOUNT_MASK引用计数相关的掩码。如果此处判断 == 0,说明引用计数为0,并没有将block copy到堆上。反之(src->forwarding->flags & BLOCK_REFCOUNT_MASK) != 0,则说明已经将原block copy到堆上。接着判断flags是否需要释放,需要释放则进行flags的重新赋值
    -【4.2】未copy到堆上,流程如图所示:

    -【4.3】判断语句if (src->flags & BLOCK_BYREF_HAS_COPY_DISPOSE)如果成立,说明已经捕获到了外部变量,具体如图所示:

【5】byref_keep

由上图我们可知byref_keep()是为了保存(保活)外部捕获变量的生命周期,如果不进行keep,则有可能会出现src为空了之后,开辟的空间的内容也被清空了。
byref_keep的源码为:

struct Block_byref_2 {
    // requires BLOCK_BYREF_HAS_COPY_DISPOSE
    BlockByrefKeepFunction byref_keep;
    BlockByrefDestroyFunction byref_destroy;
};

返回到main_byref.cpp文件中,找到struct __Block_byref_obj_0{}结构体,内部的copydispose函数分别赋值给了byref_keepbyref_destroy。也就是说在编译后的cpp文件中,在main函数里,__block修饰的NSObject *obj,编译所生成的结构体的赋值,__Block_byref_id_object_copy_131赋值给了结构体__Block_byref_obj_0copy函数;__Block_byref_id_object_dispose_131赋值给了__Block_byref_obj_0dispose函数。
也就是说:

byref_keep = __Block_byref_id_object_copy_131函数
byref_destroy = __Block_byref_id_object_dispose_131函数

由此可知,byref_keep函数的调用,是调用__Block_byref_obj_0copy函数。也就是把_Block_object_assign调用一遍,即

// (*src2->byref_keep)(copy, src);
static void __Block_byref_id_object_copy_131(void *dst, void *src) {
    _Block_object_assign(dst + 40, * (src + 40), 131);
}
  • a)dst:即byref_keep函数的第1个参数copy:新开辟的block(目标block)。
  • b)src:即byref_keep函数的第2个参数src:原来的block。
  • c)dst+40src + 40,是在目标block的首地址平移40字节,对应结构体__Block_byref_obj_0内存结构,平移40字节,得到的是NSObject *obj,计算方式如下:
struct __Block_byref_obj_0 {
    void *__isa; // 8
    __Block_byref_obj_0 *__forwarding;// 8
    int __flags;        // 4
    int __size;         // 4
    void (*__Block_byref_id_object_copy)(void*, void*);// 8
    void (*__Block_byref_id_object_dispose)(void*);// 8
    NSObject *obj;
};

_Block_object_assign(dst + 40, * (src + 40), 131);变成为_Block_object_assign(obj, * obj, 131);。由上面_Block_object_assign函数的源码可知,此刻的switch分支,走的就是BLOCK_FIELD_IS_OBJECT分支。
因此,block捕获__block修饰的外部变量,

总结

  • block的本质是一个结构体,并由结构体的构造函数初始化和赋值
  • block的类型有3种global blockstack blockmalloc block
  • block 不捕获外部变量则为 global block
  • block捕获外部变量编译时为stack block运行时_Block_copy后变成malloc block
  • 结构体impl内部有4个成员变量:isa、Flags、Reserved、FuncPtr,在block构造函数赋值时,将isa赋值为默认的NSConcreteStackBlock地址(此为编译阶段,运行时这个isa会赋值成真实类型),FuncPtr 的赋值是定义的block执行代码块。
  • block结构体中的Block_descriptor_1Block_byref一样内存是连续的可通过指针平移来获取对应位置的值。
    Block_descriptor_1---Block_descriptor_2---Block_descriptor_3内存是连续的,
    Block_byref---Block_byref_2---Block_byref_3内存是连续的
  • block捕获外部变量,是在block内部生成对应的成员变量,并通过构造函数将捕获的变量赋值给内部生成的成员变量 --(值拷贝)
  • 捕获用__block修饰的外部变量(指针拷贝)3层copy
    (a)将block从copy到
    (b)接着block捕获Block_byref结构体,并对其进行copy
    (c)Block_byref对内部的变量(本文为NSObject *obj)进行copy。

推荐阅读更多精彩内容