前言

在IOS开发中大家对block用的非常多，一般情况下仅仅停留在会用的层面，具体的block的底层是如何实现的是一概不知。也许很多人就问block会用不就行了，知道底层原理干什么。比如block是如何捕获变量的，block底层是什么类型。如果你了解它的底层原理就不会有这些疑问。作为一名程序开发者，不仅要知其然更要知其所以然

准备工作

• Objc-818.2
• libclosure-79

block类型

block主要有三种类型：全局block、堆区block和栈区block

全局block

案例代码如下

static int  b  = 100;
@implementation ViewController
- (void)viewDidLoad {
    [super viewDidLoad];
     void (^block)(void) = ^{
         NSLog(@"block----%d",b);
     };
    
     void (^block1)(void) = ^{
         NSLog(@"block1");
     };
   
     NSLog(@"block-----%@",block);
     NSLog(@"block1----%@",block1);
}
@end

2021-08-29 14:38:10.593203+0800 block原理[4061:834603] block-----<__NSGlobalBlock__: 0x104144090>
2021-08-29 14:38:10.593286+0800 block原理[4061:834603] block1----<__NSGlobalBlock__: 0x1041440b0>

__NSGlobalBlock__即全局block位于全局区，且在block内部不使用外部变量，或者只使用静态变量或者全局变量。这种情况下的block就是全局block

堆区block

案例代码如下

@implementation ViewController
- (void)viewDidLoad {
    [super viewDidLoad];
    int a = 10;
    void (^block)(void) = ^{
         NSLog(@"block----%d",a);
    };
    NSLog(@"block----%@",block);
}
@end

2021-08-29 14:45:41.421585+0800 block原理[4068:835893] block----<__NSMallocBlock__: 0x2831dc360>

__NSMallocBlock__即堆区block，显而易见位于堆区。在block内部使用外部变量或者OC属性，并且赋值给强引用或者copy修饰的变量

栈区block

案例代码如下

@implementation ViewController
- (void)viewDidLoad {
    [super viewDidLoad];
    int a = 10;
    void (^__weak block)(void) = ^{
         NSLog(@"block----%d",a);
    };
    NSLog(@"block----%@",block);
}
@end

2021-08-29 15:39:03.308085+0800 block原理[4148:850196] block----<__NSStackBlock__: 0x16dc85bf8>

__NSStackBlock__既栈区block，位于栈区，在block内部使用外部变量或者OC属性，但是不能赋值给强引用或者copy修饰的变量

block底层分析

block底层分析通过clang生成.cpp文件查看底层编译的源码

block捕获普通变量（非__block修饰）

• block捕获对象 创建一个NSObject对象在block内部使用。代码如下

int main(int argc, char * argv[]) {
NSString * appDelegateClassName;
@autoreleasepool {
    NSObject * obj  = [NSObject alloc];
    void (^ block)(void) = ^{
        NSLog(@"----%@",obj);
    };
    block();
}
return UIApplicationMain(argc, argv, nil, appDelegateClassName);
}

通过clang把main.m文件编译成main.cpp文件，移除main.cpp文件一些不重要的代码方便观看

block底层是一个结构体，在__main_block_impl_0结构提中又嵌套了两个结构体__block_impl和__main_block_desc_0

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

__block_impl结构体中的FuncPtr用来保存任务功能函数即__main_block_func_0函数的地址

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

__main_block_desc_0结构中的变量copy和dispose是非常重要的函数保存着__main_block_copy_0和__main_block_dispose_0函数地址。在block进行拷贝和释放时调用

• block捕获非对象类型

用int类型的变量进行实例探究。代码如下

int main(int argc, char * argv[]) {
    NSString * appDelegateClassName;
    @autoreleasepool {
        int a = 10;
        void (^ block)(void) = ^{
            NSLog(@"----%d",a);
        };
        block();
    }
    return UIApplicationMain(argc, argv, nil, appDelegateClassName);
}

通过clang把main.m文件编译成main.cpp文件，移除main.cpp文件一些不重要的代码方便观看

捕获非对象类型比如基本数据类型，__main_block_desc_0结构中是没有变量copy和dispose，这就意味着没有copy和dispose功能。这一点很重要，会影响block的三层拷贝

总结：main函数中和block操作相关的有两个步骤

• 对block的结构体进行初始化赋值，参数有__main_block_func_0任务功能函数，&__main_block_desc_0_DATA描述信息的函数地址以及外界的变量obj
  • block底层会被编译成一个结构体类型
  • block结构体此时自动生成了一个NSObject *__strong obj的变量，对结构体进行赋值时obj(_obj)通过C++方式给block结构体的obj赋值
  • 将__main_block_func_0赋值给block结构体中的变量__block_impl中的FuncPtr保存
  • 将&__main_block_desc_0_DATA赋值给block结构体中的变量__main_block_desc_0中的Desc保存
• 调用blcok结构体中__block_impl变量中的FuncPtr变量执行任务功能函数
  • FuncPtr 执行时会把blcok作为参数，因为要获取blcok中的objc变量
  • __main_block_func_0方法中使用的变量其实就是获取的blcok结构体中新生成的obj。结构体中的obj和外界变量的obj指向的同一片内存空间
• blcok的赋值和执行都是通过blcok内部的数据或者函数去执行，都是用blcok中保存的数据

问题：为什么普通的变量（不用__block修饰）在blcok内部不能进行修改

因为blcok内部的变量obj和外界变量obj指向的是同一块内存，如果此时blcok内部的变量obj重新指向一块内存即obj中地址发生改变，而此时外界的变量obj还是指向它开始指向的内存空间没有改变变。此时编译器不知道该用哪个obj造成代码有歧义，所以不能进行修改仅仅可读。这也就大家常说的值拷贝

block捕获__block修饰的变量

• block捕获__block修饰的对象类型

给变量obj添加__block修饰，并且在block内存进行修改。代码如下

 int main(int argc, char * argv[]) {
    NSString * appDelegateClassName;
    @autoreleasepool {
        __block NSObject * obj  = [NSObject alloc];
        void (^ block)(void) = ^{
            obj = [NSObject alloc];
            NSLog(@"----%@",obj);
        };
        block();
    }
    return UIApplicationMain(argc, argv, nil, appDelegateClassName);
}

通过clang把main.m文件编译成main.cpp文件，移除main.cpp文件一些不重要的代码方便观看

main.cpp中可以看出blcok捕获和调用流程和捕获非__block修饰的变量的流程基本一致，区别就是捕获变量的数据结构类型发生了改变

编译器会把__block修饰的变量底层编译成一个结构体__Block_byref_obj_0

struct __Block_byref_obj_0 {
  void *__isa;
__Block_byref_obj_0 *__forwarding;//__Block_byref_obj_0的地址默认赋值时指向自己
 int __flags;//标识
 int __size;//大小
 void (*__Block_byref_id_object_copy)(void*, void*);//copy方法
 void (*__Block_byref_id_object_dispose)(void*);//dispose方法
 NSObject *__strong obj;//对象的地址
};

编译器把__block修饰的变量底层编译成结构体时，会进行初始化赋值

• (__Block_byref_obj_0 *)&obj赋值给 __forwarding，其实就是__forwarding指向__Block_byref_obj_0地址。简单的说__Block_byref_obj_0中的__forwarding指向__Block_byref_obj_0
• __Block_byref_id_object_copy_131赋值给__Block_byref_id_object_copy
• __Block_byref_id_object_dispose_131赋值给__Block_byref_id_object_dispose
• 对象的地址赋值给变量 NSObject *__strong obj

blcok的结构体初始化赋值时，把变量的结构体__Block_byref_obj_0 obj的地址作为参数

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __Block_byref_obj_0 *obj; // by ref
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, 
  __Block_byref_obj_0 *_obj, int flags=0) : obj(_obj->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

此时把_obj->__forwarding赋值 __main_block_impl_0结构体中自动生成的变量__Block_byref_obj_0 *obj，也就意味着obj也是指向__Block_byref_obj_0结构体

(block)->FuncPtr(block)调用任务功能函数代码如下

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {

  __Block_byref_obj_0 *obj = __cself->obj; // bound by ref
  
 (obj->__forwarding->obj) = ((NSObject *(*)(id, SEL))(void *)objc_msgSend)
 ((id)objc_getClass("NSObject"), sel_registerName("alloc"));
 
 NSLog((NSString *)&__NSConstantStringImpl,(obj->__forwarding->obj)); 
}

• __Block_byref_obj_0 *obj = __cself- >obj把blcok结构体中的obj赋值给obj，也就是把__Block_byref_obj_0的地址赋值给了__Block_byref_obj_0 *obj
• obj->__forwarding指向的是__Block_byref_obj_0结构体的地址
• obj->__forwarding->obj就是__Block_byref_obj_0结构体中的NSObject *__strong obj变量
• obj->__forwarding->obj修改obj时，block内部和外部变量的指向没有改变，只是改变了外部和内部变量里面的obj，实际上访问到的obj就是同一个，不管这个obj有没有被修改

上面探究的是捕获的__block修饰的对象类型，下面探究下捕获非对象类型

• block捕获__block修饰的对象类型

用__block修饰的int类型变量进行实例探究。代码如下

 int main(int argc, char * argv[]) {
    NSString * appDelegateClassName;
    @autoreleasepool {
        __block int a = 10;
        void (^ block)(void) = ^{
            NSLog(@"----%d",a);
        };
        block();
    }
    return UIApplicationMain(argc, argv, nil, appDelegateClassName);
}

通过clang把main.m文件编译成main.cpp文件，移除main.cpp文件一些不重要的代码方便观看

block捕获__block修饰的对象类型，在__Block_byref_obj_0结构体中没有copy和dispose。这一点很重要会影响block的三层拷贝

总结：

• __block修饰的变量底层会生成一个__Block_byref_obj_0结构体
• __Block_byref_obj_0结构体中保存着对象的地址以及__Block_byref_obj_0地址
• blcok内部和外部的变量都是指向的__Block_byref_obj_0地址。而__Block_byref_obj_0中的变量obj发生改变时blcok内部和外部的变量仍然指向__Block_byref_obj_0地址，然后获取obj

__blcok修饰变量指示图

根据.cpp文件中变量的赋值和修改流程所画的图。只是为了更好的理解 __blcok修饰的变量为什么可以修改

block未捕获变量（全局或静态）

block未捕获变量和捕获全局变量以及静态变量是一样的

• block未捕获变量

 int main(int argc, char * argv[]) {
    NSString * appDelegateClassName;
    @autoreleasepool {
        
        void (^ block)(void) = ^{
        };
        block();
    }
    return UIApplicationMain(argc, argv, nil, appDelegateClassName);
}

通过clang把main.m文件编译成main.cpp文件，移除main.cpp文件一些不重要的代码方便观看

如果block未捕获变量，那么在block内部不会自动生成相应的变量，__main_block_desc_0结构体中没有copy和disponse函数

• block捕获全局或静态变量

static int  a  = 100;
int main(int argc, char * argv[]) {
    NSString * appDelegateClassName;
    @autoreleasepool {
        void (^ block)(void) = ^{
            NSLog(@"----%d",a);
        };
        block();
    }
    return UIApplicationMain(argc, argv, nil, appDelegateClassName);
}

通过clang把main.m文件编译成main.cpp文件，移除main.cpp文件一些不重要的代码方便观看

block捕获全局和静态变量和未捕获变量是一样的，此时只是使用了全局或静态变量而已

block底层探究

通过对main.cpp文件分析，大致理清楚了blcok的变量赋值以及block的调用。但是栈区blcok变成堆区blcok过程还不了解。下面通过汇编跟踪流程的方式进行探究

全局block的底层探究

给blcok的设置断点，如下图所示

图中block虽然没有值但是block中的变量和底层main.cpp文件中的block结构很相似。下面进行汇编调试

汇编中显示跳转到objc_retainBlock，直接给objc_retainBlock下符号断点。继续调试

• objc_retainBlock汇编中下一步会跳转到_Block_copy
• objc_retainBlock方法是在libobjc.A.dylib源码库中
• 真机情况下x0表示方法的第一个参数即消息的接收者。通过lldb调试发现此时的消息接收者是block。而且此时的block是一个全局block

给_Block_copy添加符号断点，继续调试

• _Block_copy方法在libsystem_blocks.dylib源码库中
• 通过lldb调试发现_Block_copy的消息接收者是block。此时的block仍然是一个全局block

_Block_copy汇编结束的位置会return一个返回值，_Block_copy中间过程的汇编比较多看起来比较吃力。但是不管_Block_copy中间过程做了什么，现在只需要它的返回值即可。真机情况下方法的返回值是存放在x0寄存器中的

全局block经过_Block_copy以后什么也没做，直接返回全局block

堆区block的底层探究

给blcok的设置断点，如下图所示

图中的block是大家常说堆区blcok，同样也会调用objc_retainBlock方法

图中所示此时的block不是堆区的block，而是栈区的block。带着这个疑问接着往下走

栈区block经过_Block_copy以后变成堆区block，栈区block和堆区block的地址不一样说明是在堆区新开辟的内存。然而堆区block里面的变量invoke、cpoy、disponse地址是一样的，于是大胆的猜测：栈区block在运行时会cpoy一份到堆区，形成一个新的堆区block然后返回。具体的过程要探究_Block_copy源码

栈区block的底层探究

给栈区blcok设置断点，如下图所示

图中显示栈区block并不会调用objc_retainBlock方法，也就不会调用_Block_copy方法

总结

• 全局block在运行时调用_Block_copy方法后，仍然是全局block
• 堆区block是由编译时的栈区block在运行时调用_Block_copy方法，生成新的堆区block
• 栈区blcok不会进行_Block_copy的操作

结论：如果block赋值给强引用或者copy修饰的变量，那么block会进行_Block_copy操作，如果是赋值给__weak修饰的变量则不会进行_Block_copy的操作

block的类型Block_layout结构体

通过.cpp文件和汇编对block的类型有个初步了解，但是不是很清晰。不同类型的blcok里面的变量也是有区别的， 只有通过底层源码去探究block类型。objc_retainBlock方法是在libobjc.A.dylib源码库中，在objc4-818.2源码中全局搜索objc_retainBlock

objc_retainBlock方法中调用了_Block_copy方法和汇编流程是相吻合的。全局搜索_Block_copy结果没有搜索到_Block_copy的相关实现。在汇编流程中得知_Block_copy方法在libsystem_blocks.dylib源码库中，但是该源码库并没有开源。经过开发者的不断探索在libclosure-79源码库中找到了_Block_copy方法实现

在_Block_copy方法中发现blcok的底层是一个Block_layout结构体

struct Block_layout {
    //block 的类型
    void * __ptrauth_objc_isa_pointer isa;  // 8 字节
    //用来标识`blcok`的信息是按位存储的，类似于对象中isa的`bits`
    volatile int32_t flags;// 4字节
    //保留字段
    int32_t reserved;// 4字节
    //函数指针，保存任务函数的实现地址 就是.cpp文件中的FuncPtr
    BlockInvokeFunction invoke; // 8字节
    //描述信息
    struct Block_descriptor_1 *descriptor;// 8字节
};

Block_layout结构体变量的含义

• isa：表示block的类型（栈、堆 、全局）
• flags：标识符类似于对象中isa的bits
• reserved：保留字段
• invoke：函数指针，保存任务函数的实现地址 就是.cpp文件中的FuncPtr函数
• descriptor：描述信息

flag标识

 // Values for Block_layout->flags to describe block objects
 enum {
    BLOCK_DEALLOCATING =      (0x0001),  // runtime
    BLOCK_REFCOUNT_MASK =     (0xfffe),  // runtime
    BLOCK_INLINE_LAYOUT_STRING = (1 << 21), // compiler

#if BLOCK_SMALL_DESCRIPTOR_SUPPORTED
    BLOCK_SMALL_DESCRIPTOR =  (1 << 22), // compiler
#endif

    BLOCK_IS_NOESCAPE =       (1 << 23), // compiler
    BLOCK_NEEDS_FREE =        (1 << 24), // runtime
    BLOCK_HAS_COPY_DISPOSE =  (1 << 25), // compiler
    BLOCK_HAS_CTOR =          (1 << 26), // compiler: helpers have C++ code
    BLOCK_IS_GC =             (1 << 27), // runtime
    BLOCK_IS_GLOBAL =         (1 << 28), // compiler
    BLOCK_USE_STRET =         (1 << 29), // compiler: undefined if !BLOCK_HAS_SIGNATURE
    BLOCK_HAS_SIGNATURE  =    (1 << 30), // compiler
    };

• 第1位 BLOCK_DEALLOCATING ： 释放标记，-般常用 BLOCK_NEEDS_FREE 做位与操作，一同传入 Flags，告知该 block 可释放
• 低16位 BLOCK_REFCOUNT_MASK：存储引用计数的值，是一个可选用参数
• 第24位 BLOCK_NEEDS_FREE：低16是否有效的标志，程序根据它来决定是否增加或是减少引用计数位的值
• 第25位 BLOCK_HAS_COPY_DISPOSE：是否拥有拷贝辅助函数(a copy helper function)
• 第26位 BLOCK_HAS_CTOR：是否拥有 block 析构函数
• 第27位 BLOCK_IS_GC：标志是否有垃圾回收;//OS X
• 第28位 BLOCK_IS_GLOBAL：标志是否是全局block
• 第30位 BLOCK_HAS_SIGNATURE：与BLOCK_USE_STRET相对，判断当前block是否拥有一个签名。用于runtime时动态调用

在这些标记位中BLOCK_HAS_COPY_DISPOSE和BLOCK_HAS_SIGNATURE这两个标记位特别重要

• BLOCK_HAS_COPY_DISPOSE表示是否有Block_descriptor_2
• BLOCK_HAS_SIGNATURE表示是否有BLOCK_DESCRIPTOR_3
• 为啥没有Block_descriptor_1的标记位，因为Block_descriptor_1是必须要有的
• 通过标记位可以判断Block_descriptor_1是必须有的，Block_descriptor_2和BLOCK_DESCRIPTOR_3是可选的

descriptor描述信息主要分为三类Block_descriptor_1、Block_descriptor_2和BLOCK_DESCRIPTOR_3

#define BLOCK_DESCRIPTOR_1 1
struct Block_descriptor_1 {
    uintptr_t reserved;//8字节
    uintptr_t size;//8字节
};

#define BLOCK_DESCRIPTOR_2 1
struct Block_descriptor_2 {
    // requires BLOCK_HAS_COPY_DISPOSE
    BlockCopyFunction copy;//8字节
    BlockDisposeFunction dispose;//8字节
};

#define BLOCK_DESCRIPTOR_3 1
struct Block_descriptor_3 {
    // requires BLOCK_HAS_SIGNATURE
    const char *signature;//8字节
    const char *layout;  //8字节   // contents depend on BLOCK_HAS_EXTENDED_LAYOUT
};

• Block_descriptor_1是结构体类型，其中reserved表示保留信息，size表示block大小
• Block_descriptor_2是结构体类型，其中copy存的是copy函数地址，dispose 存的是dispose函数地址
• Block_descriptor_3是结构体类型，其中signature表示签名信息，layout表示block的扩展布局

下面探究下descriptor的构造函数，究竟是如何获取descriptor的

struct Block_descriptor_1 *desc1 = layout->descriptor;
  
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);//地址偏移获取到descriptor_2
    return (struct Block_descriptor_2 *)desc;
}

static struct Block_descriptor_3 * _Block_descriptor_3(struct Block_layout *aBlock)
{
    uint8_t *desc = (uint8_t *)_Block_get_descriptor(aBlock);//descriptor_1的地址
    desc += sizeof(struct Block_descriptor_1);//地址偏移 descriptor_1大小
    if (aBlock->flags & BLOCK_HAS_COPY_DISPOSE) {//如果descriptor_2存在
        desc += sizeof(struct Block_descriptor_2);//继续地址偏移descriptor_2大小
    }
    return (struct Block_descriptor_3 *)desc;//得到descriptor_3地址
}

Block_descriptor_1是直接赋值，而Block_descriptor_2和Block_descriptor_3是通过地址偏移获取的。在结合上面的标志位再次验证Block_descriptor_1是必有的默认的，Block_descriptor_2和Block_descriptor_3是可选的，根据标记位判断

lldb验证Block_layout中变量

• 堆区block调试验证

int main(int argc, char * argv[]) {
    NSString * appDelegateClassName;
    @autoreleasepool {
        NSObject * obj  = [NSObject alloc];
        void (^ block)(void) = ^{
            NSLog(@"----%@",obj);
        };
        block();
    }
    return UIApplicationMain(argc, argv, nil, appDelegateClassName);
}

在_Block_copy汇编开始的位置或者ret位置进行调试

• flags的值是0x00000000c3000002，descriptor的值是0x0000000100390078，
• 打印descriptor中存储的信息得到size的值0x0000000000000028换算成10进制等于40是Block_layout结构体的大小。大家可能有疑问Block_layout结构体的大小不是32，因为捕获变量会在block内部生成一个新的变量，现在捕获的是一个指针类型所以Block_layout大小总共40个字节
• BLOCK_HAS_COPY_DISPOSE=(1 << 25)，flags & BLOCK_HAS_COPY_DISPOSE用来判断是否有Block_descriptor_2
• BLOCK_HAS_SIGNATURE=(1 << 30)，flags & BLOCK_HAS_SIGNATURE用来判断是否有Block_descriptor_3
• signature的值是0x000000010038ffa6，打印出的值是v8@?0

签名信息的补充

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

总结： lldb调试结果和上面源码探究到的结果相互验证

• 全局block调试验证

int main(int argc, char * argv[]) {
    NSString * appDelegateClassName;
    @autoreleasepool {
        void (^ block)(void) = ^{
           
        };
        block();
    }
    return UIApplicationMain(argc, argv, nil, appDelegateClassName);
}

在_Block_copy汇编开始的位置或者ret位置进行调试

• Block_layout结构体大小是0x0000000000000020转换成10进制32，因为没有捕获变量所以大小只有32
• 全局block没有Block_descriptor_2，有Block_descriptor_3
• 因为内存是连续的Block_descriptor_2没有，那么0x0000000104a03f9b就是Block_descriptor_3的起始位置

总结：通过lldb调试现在对Block_layout结构体有了详细的了解

blcok的三层拷贝

_Block_copy源码探究

void *_Block_copy(const void *arg) {
    struct Block_layout *aBlock;
    if (!arg) return NULL;
    // The following would be better done as a switch statement
    aBlock = (struct Block_layout *)arg;
    //block是否需要释放
    if (aBlock->flags & BLOCK_NEEDS_FREE) {
        // latches on high
        latching_incr_int(&aBlock->flags);
        return aBlock;
    }
    //如果是全局block直接返回
    else if (aBlock->flags & BLOCK_IS_GLOBAL) {
        return aBlock;
    }
    else {// 栈 - 堆 (编译期)//这里只能是栈block
         // 编译时期不能生成堆block 只能是栈block 只能进行通过_Block_copy进行开辟堆block
        // 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;
        //将aBlock拷贝到result中
        memmove(result, aBlock, size); // bitcopy first
#if __has_feature(ptrauth_calls)
        // Resign the invoke pointer as it uses address authentication.
        result->invoke = aBlock->invoke;
#if __has_feature(ptrauth_signed_block_descriptors)
//BLOCK_SMALL_DESCRIPTOR 是包含了Block_descriptor_1、Block_descriptor_2 和 Block_descriptor_3
//也是根据flags的标志位来判断的
        if (aBlock->flags & BLOCK_SMALL_DESCRIPTOR) {
             ...//省略 里面就是descriptor的拷贝赋值
        }
#endif
#endif
        // reset refcount
        result->flags &= ~(BLOCK_REFCOUNT_MASK|BLOCK_DEALLOCATING);    // XXX not needed
        result->flags |= BLOCK_NEEDS_FREE | 2;  // logical refcount 1
        //result:是在堆区创建的block  aBlock:外面传进来的栈的
        // 调用Block_descriptor_2`copy`方法
        _Block_call_copy_helper(result, aBlock);
       
        // Set isa last so memory analysis tools see a fully-initialized object.
        result->isa = _NSConcreteMallocBlock;//将isa设置位_NSConcreteMallocBlock即堆block
        return result;
    }
}

• 如果block需要释放，则直接释放
• 如果block是全局block，则不需要操作直接返回
• 因为堆block需要在堆区申请开辟内存，编译时并不会生成堆block，所以只能是栈block
• 通过malloc开辟新的内存
• 通过memmove将栈区block数据拷贝到新开辟的内存中
• 通过_Block_call_copy_helper调用Block_descriptor_2中的copy方法
• 将堆上block的isa设置为_NSConcreteMallocBlock

总结：_Block_copy将栈区的block拷贝一份到堆区

_Block_call_copy_helper源码探究

 static void _Block_call_copy_helper(void *result, struct Block_layout *aBlock)
{   // 获取`copy`函数的函数指针
    if (auto *pFn = _Block_get_copy_function(aBlock))
       // 调用copy方法
        pFn(result, aBlock);
}

• 通过_Block_get_copy_function方法获取copy函数的函数指针
• 然后调用copy函数

_Block_get_copy_function方法探究

//获取方法的指针
#define _Block_get_relative_function_pointer(field, type)      \
    ((type)((uintptr_t)(intptr_t)(field) + (uintptr_t)&(field)))
    
#define _Block_get_function_pointer(field)      \
    (field)
    
static inline __typeof__(void (*)(void *, const void *))
_Block_get_copy_function(struct Block_layout *aBlock)
{   //如果没有 Block_descriptor_2 表明没有 copy 方法返回 NULL
    if (!(aBlock->flags & BLOCK_HAS_COPY_DISPOSE))
        return NULL;
    //获取Block_descriptor_1的首地址
    void *desc = _Block_get_descriptor(aBlock);
    
#if BLOCK_SMALL_DESCRIPTOR_SUPPORTED
    //如果Block_descriptor_1，Block_descriptor_2，Block_descriptor_3 全都有
    if (aBlock->flags & BLOCK_SMALL_DESCRIPTOR) {
        struct Block_descriptor_small *bds =
                (struct Block_descriptor_small *)desc;
        return _Block_get_relative_function_pointer(
                bds->copy, void (*)(void *, const void *));
    }
#endif

    struct Block_descriptor_2 *bd2 =
            (struct Block_descriptor_2 *)((unsigned char *)desc +
                                          sizeof(struct Block_descriptor_1));
    return _Block_get_copy_fn(bd2);
}

// _Block_get_function_pointer 是个宏
// _Block_get_copy_fn 获取copy的函数指针
_Block_get_copy_fn(struct Block_descriptor_2 *desc)
{
    return (void (*)(void *, const void *))_Block_get_function_pointer(desc->copy);
}

• 判断是否有Block_descriptor_2，如果没有返回NULL
• 如果有Block_descriptor_2，根据不同的情况下去获取copy函数的函数指针

总结：_Block_call_copy_helper方法的作用就是获取copy函数指针，调用copy函数

注意：此时的copy函数是Block_descriptor_2中的copy函数

_Block_object_assign源码探究

main.cpp文件中block结构体初始化时，结构体中的descriptor是通过外面传进来参数进行赋值的

图中显示block结构体中的copy变量存储的就是__main_block_copy_0函数的地址，调用block结构体中的copy就是调用__main_block_copy_0函数

static void __main_block_copy_0(struct __main_block_impl_0*dst,
struct __main_block_impl_0*src) {
    _Block_object_assign((void*)&dst->obj, (void*)src->obj, 8/*BLOCK_FIELD_IS_BYREF*/);
}

• __main_block_copy_0函数中有两个参数dst和src，dst是堆区block，src是栈区block
• 在探究_Block_copy方法时_Block_call_copy_helper(result, aBlock)方法中调用了copy方法，result是堆区block，aBlock是栈区block
• __main_block_copy_0函数中调用了_Block_object_assign方法。_Block_object_assign有三个参数，前两个参数是block捕获的变量，第三个参数捕获变量的类型

探究下捕获变量的类型

enum {
    // see function implementation for a more complete description of these fields 
    and combinations
    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_FIELD_IS_OBJECT，变量类型是普通对象
• BLOCK_FIELD_IS_BLOCK，变量类型是block类型
• BLOCK_FIELD_IS_BYREF，变量类型是__block修饰变量

探究下_Block_object_assign方法，在libclosure-79源码中全局搜索_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:
        // _Block_retain_object_default = fn (arc)
        _Block_retain_object(object);
        *dest = object;
        break;

      case BLOCK_FIELD_IS_BLOCK:
        *dest = _Block_copy(object);
        break;
    
      case BLOCK_FIELD_IS_BYREF | BLOCK_FIELD_IS_WEAK:
      case BLOCK_FIELD_IS_BYREF:
        *dest = _Block_byref_copy(object);
        break;
        
      case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_OBJECT:
      case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_BLOCK: 
        *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:
        *dest = object;
        break;

      default:
        break;
    }
}

• 如果变量类型是普通对象，交给系统处理，此时进行指针拷贝*dest = object，引用计数 +1
• 如果变量类型是block类型，进行_Block_copy操作
• 如果变量类型是__block修饰变量，进行_Block_byref_copy操作

_Block_byref_copy源码探究

_Block_byref_copy主要是对变量拷贝，_block修饰的变量底层编译成Block_byref类型

// Values for Block_byref->flags to describe __block variables
enum {
    // Byref refcount must use the same bits as Block_layout's refcount.
    // BLOCK_DEALLOCATING =      (0x0001),  // runtime
    // BLOCK_REFCOUNT_MASK =     (0xfffe),  // runtime

    BLOCK_BYREF_LAYOUT_MASK =       (0xf << 28), // compiler
    BLOCK_BYREF_LAYOUT_EXTENDED =   (  1 << 28), // compiler
    BLOCK_BYREF_LAYOUT_NON_OBJECT = (  2 << 28), // compiler
    BLOCK_BYREF_LAYOUT_STRONG =     (  3 << 28), // compiler
    BLOCK_BYREF_LAYOUT_WEAK =       (  4 << 28), // compiler
    BLOCK_BYREF_LAYOUT_UNRETAINED = (  5 << 28), // compiler
    BLOCK_BYREF_IS_GC =             (  1 << 27), // runtime
    BLOCK_BYREF_HAS_COPY_DISPOSE =  (  1 << 25), // compiler
    BLOCK_BYREF_NEEDS_FREE =        (  1 << 24), // runtime
};

// __block  -> {}
// 结构体
struct Block_byref {
    void * __ptrauth_objc_isa_pointer isa; // 8
    struct Block_byref *forwarding;  // 8
    volatile int32_t flags; // contains ref count//4
    uint32_t size; // 4
};

struct Block_byref_2 {
    BlockByrefKeepFunction byref_keep;  
    BlockByrefDestroyFunction byref_destroy;   
};

struct Block_byref_3 {
    const char *layout;
};

• __block修饰的变量底层被编译成了Block_byref结构体类型
• Block_byref的类型和Block_layout的descriptor比较类似，都是通过flags来判断Block_byref_2和Block_byref_3是否存在。既Block_byref_2和Block_byref_3是可选的。大家可以参考对Block_layout分析来类比理解Block_byref

_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) {
        // 在堆区开辟内存将外界变量拷贝一份到堆区
        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和 外界变量src的forwarding指向同一片内存
        // 也就意味着它们持有着同一个对象
        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_copy比较类似
        if (src->flags & BLOCK_BYREF_HAS_COPY_DISPOSE) {
         
            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;
            }
            调用 Block_byref_2 中的byref_keep方法
            (*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;
}

• 通过malloc方法开辟内存将外界变量拷贝一份，存放到堆区新开辟的内存中
• copy->forwarding = copy 和 src->forwarding = copy表明它们的forwarding指向同一片内存，那么它们就持有同一个对象
• (*src2->byref_keep)(copy, src)调用Block_byref_2中的byref_keep方法

总结：_Block_byref_copy对__block修饰的变量进行拷贝即对Block_byref进行拷贝

byref_keep 源码探究

byref_keep方法在结构体Block_byref_2在底层编译时已经被初始化赋值了。查看main.cpp文件

图中main.cpp文件显示Block_byref_2结构体中byref_keep存储__Block_byref_id_object_copy_131函数指针，而byref_destroy存储__Block_byref_id_object_dispose_131函数指针

__Block_byref_id_object_copy_131再次调用_Block_object_assign方法，此次_Block_object_assign方法中的参数是Block_byref结构体中的obj对象。所以此次会走BLOCK_FIELD_IS_BLOCK流程

总结：

• 通过_Block_copy方法，将栈区blcok拷贝一份放在堆区
• __block修饰的对象，通过_Block_byref_copy方法，将Block_byref结构体类型进行拷贝
• 通过_Block_object_assign方法，对Block_byref中的对象处理。实际上这一层没有进行拷贝，但是走的还是拷贝的流程

注意：只有blcok修饰的对象，才有三层拷贝。是否具有拷贝功能和捕获的变量类型有关

_Block_object_dispose探究

_Block_object_dispose方法和_Block_object_assign方法是对应的，还是一样的探究方式先汇编查看

汇编显示在block释放时会调用_Block_object_dispose方法。在libclosure-79源码中全局搜索_Block_object_dispose

void _Block_object_dispose(const void *object, const int flags) {
    switch (os_assumes(flags & BLOCK_ALL_COPY_DISPOSE_FLAGS)) {
      case BLOCK_FIELD_IS_BYREF | BLOCK_FIELD_IS_WEAK:
      case BLOCK_FIELD_IS_BYREF:
        // get rid of the __block data structure held in a Block
        _Block_byref_release(object);
        break;
      case BLOCK_FIELD_IS_BLOCK:
        _Block_release(object);
        break;
      case BLOCK_FIELD_IS_OBJECT:
        _Block_release_object(object);
        break;
      case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_OBJECT:
      case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_BLOCK:
      case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_OBJECT | BLOCK_FIELD_IS_WEAK:
      case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_BLOCK  | BLOCK_FIELD_IS_WEAK:
        break;
      default:
        break;
    }
}

这个_Block_object_dispose方法就是调用了block结构体中Block_descriptor_2中的disponse，根据捕获的变量类型_Block_object_dispose进行不同的释放操作。如果是__block修饰的变量会调用_Block_byref_release方法

static void _Block_byref_release(const void *arg) {
    struct Block_byref *byref = (struct Block_byref *)arg;
    
    byref = byref->forwarding;
    
    if (byref->flags & BLOCK_BYREF_NEEDS_FREE) {
        int32_t refcount = byref->flags & BLOCK_REFCOUNT_MASK;
        os_assert(refcount);
        if (latching_decr_int_should_deallocate(&byref->flags)) {
            if (byref->flags & BLOCK_BYREF_HAS_COPY_DISPOSE) {
                struct Block_byref_2 *byref2 = (struct Block_byref_2 *)(byref+1);
                //byref_destroy 释放销毁变量 和 byref_keep对应
                (*byref2->byref_destroy)(byref);
            }
            //释放
            free(byref);
        }
    }
}

_Block_byref_release方法就是对象，变量的释放和销毁

总结

block底层源码虽然不是很多，但是过程很绕，有时候有点摸不着头脑。自己在探究的过程中也是探究了很多遍才慢慢理清楚整个逻辑。耐心和坚持很重要