iOS之深入解析Block的底层原理

一、block 本质

① block 本质探究

• 定义一个 block.c 文件，键入以下代码：

	#include "stdio.h"
	
	int main() {
    
    
	    void(^block)(void) = ^{
    
    
	        printf("Hello");
	    };
	    return 0;
	}

• 通过xcrun -sdk iphonesimulator clang -arch x86_64 -rewrite-objc block.c，将block.c 编译成 block.cpp，其中block在底层被编译成了以下的形式：

	int main(){
    
    
	    void(*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
	
	     ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
	    return 0;
	}
	
	static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
    
    
		printf("Hello");
	}
	
	// 构造函数
	void(*block)(void) = __main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA));
	// block调用执行
	block->FuncPtr(block);

• block 等于__main_block_impl_0，是一个函数；不难看出，__main_block_impl_0，是一个结构体，同时可以说明 block 是一个__main_block_impl_0 类型的对象，如下所示：

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

• 其中的 __block_impl 结构体如下：

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

• block 本质上也是一个 OC 对象，内部有一个 isa 指针。block 是封装了函数调用以及函数调用环境的 OC 对象。
• block 通过 clang 编译后的源码间的关系如下所示，以 __block 修饰的变量为例：

② block为什么需要调用？

• 在底层 block 的类型 __main_block_impl_0 结构体，通过其同名构造函数创建，第一个传入的block 的内部实现代码块，即 __main_block_func_0，用 fp 表示，然后赋值给 imp 的 FuncPtr 属性，在 main 中进行调用，这也是 block 为什么需要调用的原因。
• 如果不调用，block 内部实现的代码块将无法执行，即：
  • 函数声明：即 block 内部实现声明成了一个函数 __main_block_func_0；
  • 执行具体的函数实现：通过调用 block 的 FuncPtr 指针，调用 block 执行。

③ block是如何获取外界变量的？

• 定义一个变量，并在block中调用：

	int a = 6;
    void(^block)(void) = ^{
    
    
        printf("Hello: %d", a);
    };
    block();

• 底层编译实现如下：

	struct __main_block_impl_0 {
    
    
	  struct __block_impl impl;
	  struct __main_block_desc_0* Desc;
	  // 编译时就自动生成了相应的变量
	  int a;
	  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _a, int flags=0) : a(_a) {
    
    
	    // block的isa，默认是stackBlock
	    impl.isa = &_NSConcreteStackBlock;
	    impl.Flags = flags;
	    impl.FuncPtr = fp;
	    Desc = desc;
	  }
	};
	static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
    
    
	  int a = __cself->a; // bound by copy 值拷贝，即 a = 6，此时的a与传入的__cself的a并不是同一个
		printf("Hello: %d", a);
	}
	    
	int main(){
    
    
	
	    int a = 6;
	    void(*block)(void) = __main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA, a));
	
	    block)->FuncPtr(block);
	    return 0;
	}

• __main_block_func_0中的a是值拷贝，如果此时在block内部实现中作 a++操作，会造成编译器的代码歧义，即此时的a是只读的。即：block捕获外界变量时，在内部会自动生成同一个属性来保存。

④ __block的原理

• 对a加一个__block 修饰，然后在block中对a进行++操作：

	int main() {
    
    
	    __block int a = 6;
	    void(^block)(void) = ^{
    
    
	        a++;
	        printf("Hello: %d", a);
	    };
	    block();
	    return 0;
	}

• 同样编译成C++如下所示：

struct __Block_byref_a_0 {
    
    // __block修饰的外界变量的结构体
  void *__isa;
__Block_byref_a_0 *__forwarding;
 int __flags;
 int __size;
 int a;
};

struct __main_block_impl_0 {
    
    //block的结构体类型
  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) {
    
    //构造方法
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
    
    //block内部实现
  __Block_byref_a_0 *a = __cself->a; // bound by ref 指针拷贝，此时的对象a 与 __cself对象的a 指向同一片地址空间
        //等同于 外界的 a++
        (a->__forwarding->a)++;
        printf("Hello: %d", (a->__forwarding->a));
    }
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {
    
    _Block_object_assign((void*)&dst->a, (void*)src->a, 8/*BLOCK_FIELD_IS_BYREF*/);}

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

int main(){
    
    
    //__Block_byref_a_0 是结构体，a 等于 结构体的赋值，即将外界变量a 封装成对象
    //&a 是外界变量a的地址
    __attribute__((__blocks__(byref))) __Block_byref_a_0 a = {
    
    (void*)0,(__Block_byref_a_0 *)&a, 0, sizeof(__Block_byref_a_0), 11};
    //__main_block_impl_0中的第三个参数&a，是封装的对象a的地址
    void(*block)(void) = __main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_a_0 *)&a, 570425344));

     ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
    return 0;
}

• 分析可得：
  • __main_block_impl_0中，将对象a的地址&a给构造函数；
  • 在__main_block_func_0内部对a的处理是指针拷贝，此时创建的对象a与传入对象的a指向同一内存空间。
• 总结：
  • 外界变量会生成__Block_byref_a_0结构体；
  • 结构体用来保存原始变量的指针和值；
  • 将变量生成的结构体对象的指针地址传递给block，然后在block内部就可以对外界变量进行操作。
• 深拷贝和浅拷贝的说明对比：
  • 值拷贝 - 深拷贝，只是拷贝数值，且拷贝的值不可更改，指向不同的内存空间，上文中的普通变量a就是值拷贝；
  • 指针拷贝 - 浅拷贝，生成的对象指向同一片内存空间，案例中经过__block修饰的变量a就是指针拷贝；

二、block 底层源码分析

① block 源码位置

• 在 block 处打上断点，分析运行时的block，如下所示：

• 执行结果如下：

• 加 objc_retainBlock 符号断点，继续向下执行，会执行到_Block_copy，如下：

• 继续加 _Block_copy 符号断点，向下执行，会发现在libsystem_blocks.dylib源码中：

• 可以到苹果开源网站下载最新的libclosure-74源码，分析 _Block_copy 的源码实现，可以发现 block 在底层的真正类型是 Block_layout。

② block 类型分析

• 查看 Block_layout 类型的定义，不难发现它是一个结构体：

	struct Block_layout {
    
    
	    // 指向表明block类型的类
	    void *isa;// 8字节
	    // 用来作标识符的,类似于isa中的位域,按bit位表示一些block的附加信息
	    volatile int32_t flags; // contains ref count 4字节
	    // 保留信息,可以理解预留位置,用于存储block内部变量信息
	    int32_t reserved;//4字节
	    // 函数指针,指向具体的block实现的调用地址
	    BlockInvokeFunction invoke;
	    // block的附加信息
	    struct Block_descriptor_1 *descriptor;
	    // imported variables
	};

• 分析说明：
  • isa：指向表明block类型的类；
  • flags：标识符，按bit位表示一些block的附加信息，类似于isa中的位域，其中flags 类型如下（BLOCK_HAS_COPY_DISPOSE 决定是否有 Block_descriptor_2。BLOCK_HAS_SIGNATURE 决定是否有 Block_descriptor_3）。
    • 第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_IS_GC，是否拥有 block 析构函数；
    • 第27位，标志是否有垃圾回收；// OS X
    • 第28位 - BLOCK_IS_GLOBAL，标志是否是全局block；
    • 第30位 - BLOCK_HAS_SIGNATURE，与 BLOCK_USE_STRET 相对，判断当前 block 是否拥有一个签名。用于 runtime 时动态调用。
  • reserved：保留信息，可以理解预留位置，猜测是用于存储block内部变量信息；
  • invoke：是一个函数指针，指向block的执行代码；
  • descriptor：block的附加信息，比如保留变量数、block的大小、进行copy或dispose的辅助函数指针。有三种类型：
    • Block_descriptor_1（必选）；
    • Block_descriptor_2（可选）；
    • Block_descriptor_3（可选）；
• Flag标识如下：

	// Values for Block_layout->flags to describe block objects
	enum {
    
    
	    //释放标记，一般常用于BLOCK_BYREF_NEEDS_FREE做位与运算，一同传入flags，告知该block可释放
	    BLOCK_DEALLOCATING =      (0x0001),  // runtime
	    //存储引用引用计数的 值，是一个可选用参数
	    BLOCK_REFCOUNT_MASK =     (0xfffe),  // runtime
	    //低16位是否有效的标志，程序根据它来决定是否增加或者减少引用计数位的值
	    BLOCK_NEEDS_FREE =        (1 << 24), // runtime
	    //是否拥有拷贝辅助函数，（a copy helper function）决定block_description_2
	    BLOCK_HAS_COPY_DISPOSE =  (1 << 25), // compiler
	    //是否拥有block C++析构函数
	    BLOCK_HAS_CTOR =          (1 << 26), // compiler: helpers have C++ code
	    //标志是否有垃圾回收，OSX
	    BLOCK_IS_GC =             (1 << 27), // runtime
	    //标志是否是全局block
	    BLOCK_IS_GLOBAL =         (1 << 28), // compiler
	    //与BLOCK_HAS_SIGNATURE相对，判断是否当前block拥有一个签名，用于runtime时动态调用
	    BLOCK_USE_STRET =         (1 << 29), // compiler: undefined if !BLOCK_HAS_SIGNATURE
	    //是否有签名
	    BLOCK_HAS_SIGNATURE  =    (1 << 30), // compiler
	    //使用有拓展，决定block_description_3
	    BLOCK_HAS_EXTENDED_LAYOUT=(1 << 31)  // compiler
	};

• descriptor的类型如下：

	#define BLOCK_DESCRIPTOR_1 1
	struct Block_descriptor_1 {
    
    
	    uintptr_t reserved;// 保留信息
	    uintptr_t size;    // block大小
	};
	
	#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 布局
	};

• 关于descriptor的可以从其构造函数中体现，其中Block_descriptor_2和Block_descriptor_3都是通过Block_descriptor_1的地址，经过内存平移得到的：

	static struct Block_descriptor_1 * _Block_descriptor_1(struct Block_layout *aBlock)
	{
    
    
	    return aBlock->descriptor;//默认打印
	}
	#endif
	
	static struct Block_descriptor_2 * _Block_descriptor_2(struct Block_layout *aBlock)
	{
    
    
	    if (! (aBlock->flags & BLOCK_HAS_COPY_DISPOSE)) return NULL;
	    uint8_t *desc = (uint8_t *)aBlock->descriptor;//descriptor_1的地址
	    desc += sizeof(struct Block_descriptor_1);//通过内存平移获取
	    return (struct Block_descriptor_2 *)desc;
	}
	
	static struct Block_descriptor_3 * _Block_descriptor_3(struct Block_layout *aBlock)
	{
    
    
	    if (! (aBlock->flags & BLOCK_HAS_SIGNATURE)) return NULL;
	    uint8_t *desc = (uint8_t *)aBlock->descriptor;
	    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;
	}

③ 内存变化

• 打断点运行，执行到 objc_retainBlock，block 断点处读取寄存器 x0，此时的block 是全局 block ，即__NSGlobalBlock__类型：

• 增加外部变量a，并在block内打印：

	int a = 10;
    void (^block)(void) = ^{
    
    
        NSLog(@"Hello: %d", a);
    };
    block();

• 然后读取block断点处的x0 ，可以发现block变成了栈block：NSStackBlock，如下：

• 执行到符号断点objc_retainBlock时，可以看出，依然还是栈block：

• 增加_Block_copy符号断点并断住，直接在最后的ret加断点，读取x0，发现经过_Block_copy之后，变成了堆block，即__NSMallocBlock__，主要是由于block地址发生了变化，如下：

④ 调用

• 在以下位置进行断点调试，如下：

• 可以看到register read x10 ，此时是指向一片内存空间，用于存储_block_invoke；
• 按住control + step into，进入 _block_invoke，可以得出是通过内存平移得到的block内部实现。如下：

• 上文中提到的Block_layout的结构体源码，从源码中可以看出，有个属性invoke，即block的执行者，是从isa的首地址平移 16 字节取到invoke，然后进行调用执行。

三、签名

• 继续操作，读取x0寄存器，看内存布局，通过内存平移 3*8 就可获得Block_layout的属性descriptor，主要是为了查看是否有Block_descriptor_2 和Block_descriptor_3，其中3中有block的签名：

• 分析说明：

	// 读取寄存器
	(lldb) register read x0
	      x0 = 0x000000010039c028  block探索`__block_literal_global
	// 打印 block
	(lldb) po 0x000000010039c028
	<__NSGlobalBlock__: 0x10039c028>
	 signature: "v8@?0"
	 invoke   : 0x100399e48 (/private/var/containers/Bundle/Application/7E4B5E63-B77A-46E1-B3A6-BF2A33BFBCF4/block探索.app/block探索`__29-[ViewController viewDidLoad]_block_invoke)
	// 打印 block 内存分配
	(lldb) x/8gx 0x000000010039c028
	0x10039c028: 0x00000001ebb509b0 0x0000000050000000
	0x10039c038: 0x0000000100399e48 0x000000010039c008
	0x10039c048: 0x00000001ec1a6280 0x00000000000007c8
	0x10039c058: 0x000000010039b396 0x0000000000000005
	// 查看descriptor的内存情况
	(lldb) x/8gx 0x000000010039c008
	0x10039c008: 0x0000000000000000 0x0000000000000020
	0x10039c018: 0x000000010039b390 0x0000000000000000
	0x10039c028: 0x00000001ebb509b0 0x0000000050000000
	0x10039c038: 0x0000000100399e48 0x000000010039c008
	// 第三个0x000000010039b390表示签名
	(lldb) po (char *)0x000000010039b390
	"v8@?0"

• 判断是否有Block_descriptor_2，即flags的BLOCK_HAS_COPY_DISPOSE（拷贝辅助函数）是否有值：
• p/x 1<<25 ，即1左移25位，其十六进制为0x2000000；
• p 0x02000000 & 0x00000000c1000002 ，即BLOCK_HAS_COPY_DISPOSE & flags ，等于0，表示没有Block_descriptor_2；

• 判断是否有Block_descriptor_3：
  • p/x 1<<30，即1左移30位；
  • p 0x40000000 & 0x00000000c1000002 ，即BLOCK_HAS_SIGNATURE & flags ，如果有值则说明有Block_descriptor_3；
  • p (char *)0x000000010039b390：获取Block_descriptor_3中的属性signature签名；

	(lldb) p/x 1<<30
	(int) $5 = 0x40000000
	
	(lldb) p 0x40000000 & 0x00000000c1000002
	(unsigned int) $6 = 1073741824
	
	(lldb) p (char *)0x000000010039b390
	(char *) $8 = 0x000000010039b390 "v8@?0"

• po [NSMethodSignature signatureWithObjCTypes:“v8@?0”] ，即打印签名；

	(lldb) p (char *)0x000000010039b390
	(char *) $8 = 0x000000010039b390 "v8@?0"
	
	(lldb) po [NSMethodSignature signatureWithObjCTypes:"v8@?0"]
	<NSMethodSignature: 0xb56f60fe49be8c07>
	    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: -------- -------- -------- --------
	    	// encoding = (@),类型是 @?
	        type encoding (@) '@?'
	        // @是isObject ，？是isBlock，代表 isBlockObject
	        flags {
    
    isObject, isBlock}
	        modifiers {
    
    }
	        frame {
    
    offset = 0, offset adjust = 0, size = 8, size adjust = 0}
	        // 所在偏移位置是8字节
	        memory {
    
    offset = 0, size = 8}

• block的签名信息类似于方法的签名信息，主要是体现block的返回值，参数以及类型等信息。

四、block 三次 copy

① _Block_copy 源码分析

• 进入 _Block_copy 源码，将 block 从栈区拷贝至堆区，如果需要则直接释放；如果是 globalBlock，不需要 copy，则直接返回。
• 反之则有两种：栈区 block 或者堆区 block，由于堆区 block 需要申请空间，前面并没有申请空间的逻辑，所以只能是栈区 block：
  • 通过 malloc 申请内存空间用于接收 block；
  • 通过 memmove 将 block 拷贝至新申请的内存中；
  • 设置 block 对象的类型为堆区 block，即 result->isa = _NSConcreteMallocBlock；

	// Copy, or bump refcount, of a block.  If really copying, call the copy helper if present.
	// block的拷贝操作: 栈Block -> 堆Block
	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_layout类型对象，防止对外界造成影响
	    if (aBlock->flags & BLOCK_NEEDS_FREE) {
    
    // 是否需要释放
	        // latches on high
	        latching_incr_int(&aBlock->flags);
	        return aBlock;
	    }
	    else if (aBlock->flags & BLOCK_IS_GLOBAL) {
    
    // 如果是全局block，直接返回
	        return aBlock;
	    }
	    else {
    
    // 为栈block 或者 堆block，由于堆区需要申请内存，所以只可能是栈区
	        // Its a stack block.  Make a copy. 它是一个堆栈块block拷贝。
	        struct Block_layout *result =
	            (struct Block_layout *)malloc(aBlock->descriptor->size);//申请空间并接收
	        if (!result) return NULL;
	        //通过memmove内存拷贝，将 aBlock 拷贝至result
	        memmove(result, aBlock, aBlock->descriptor->size); // bitcopy first
	#if __has_feature(ptrauth_calls)
	        // Resign the invoke pointer as it uses address authentication.
	        result->invoke = aBlock->invoke;//可以直接调起invoke
	#endif
	        // 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;//设置block对象类型为堆区block
	        return result;
	    }
	}

② _Block_object_assign 分析

• 想要分析block的三层copy，首先需要知道外部变量的种类有哪些，其中用的最多的是BLOCK_FIELD_IS_OBJECT和BLOCK_FIELD_IS_BYREF。

	// Block 捕获的外界变量的种类
	// Runtime support functions used by compiler when generating copy/dispose helpers
	
	// Values for _Block_object_assign() and _Block_object_dispose() parameters
	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类型作为变量
	    BLOCK_FIELD_IS_BLOCK    =  7,  // a block variable
	    // 经过__block修饰的变量
	    BLOCK_FIELD_IS_BYREF    =  8,  // the on stack structure holding the __block variable
	    // weak 弱引用变量
	    BLOCK_FIELD_IS_WEAK     = 16,  // declared __weak, only used in byref copy helpers
	    // 返回的调用对象 - 处理block_byref内部对象内存会加的一个额外标记，配合flags一起使用
	    BLOCK_BYREF_CALLER      = 128, // called from __block (byref) copy/dispose support routines.
	};

• 进入_Block_object_assign源码：
  • 如果是普通对象，则交给系统arc处理，并拷贝对象指针，即引用计数+1，所以外界变量不能释放；
  • 如果是block类型的变量，则通过_Block_copy操作，将block从栈区拷贝到堆区；
  • 如果是__block修饰的变量，调用_Block_byref_copy函数进行内存拷贝以及常规处理。

	static struct Block_byref *_Block_byref_copy(const void *arg) {
    
    
	    
	    //强转为Block_byref结构体类型，保存一份
	    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;
	        //block内部持有的Block_byref 和 外界的Block_byref 所持有的对象是同一个，这也是为什么__block修饰的变量具有修改能力
	        //copy 和 scr 的地址指针达到了完美的同一份拷贝，目前只有持有能力
	        copy->forwarding = copy; // patch heap copy to point to itself
	        src->forwarding = copy;  // patch stack to point to heap copy
	        copy->size = src->size;
	        //如果有copy能力
	        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
	            //Block_byref_2是结构体，__block修饰的可能是对象，对象通过byref_keep保存，在合适的时机进行调用
	            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_id_object_copy
	            (*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;
	}

• 进入_Block_byref_copy源码：
  • 将传入的对象，强转为Block_byref结构体类型对象，保存一份；
  • 没有将外界变量拷贝到堆，需要申请内存，其进行拷贝；
  • 如果已经拷贝过了，则进行处理并返回；
  • 其中 copy 和 src 的 forwarding 指针都指向同一片内存，这也是为什么__block修饰的对象具有修改能力的原因。

static struct Block_byref *_Block_byref_copy(const void *arg) {
    
    
    
    //强转为Block_byref结构体类型，保存一份
    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;
        //block内部持有的Block_byref 和 外界的Block_byref 所持有的对象是同一个，这也是为什么__block修饰的变量具有修改能力
        //copy 和 scr 的地址指针达到了完美的同一份拷贝，目前只有持有能力
        copy->forwarding = copy; // patch heap copy to point to itself
        src->forwarding = copy;  // patch stack to point to heap copy
        copy->size = src->size;
        //如果有copy能力
        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
            //Block_byref_2是结构体，__block修饰的可能是对象，对象通过byref_keep保存，在合适的时机进行调用
            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_id_object_copy
            (*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;
}

③ _Block_object_dispose 分析

• 同一般的retain和release一样，_Block_object_object其本质主要是retain，所以对应的还有一个release，即_Block_object_dispose方法，其源码实现如下，也是通过区分block种类，进行不同释放操作：

// When Blocks or Block_byrefs hold objects their destroy helper routines call this entry point
// to help dispose of the contents 当Blocks或Block_byrefs持有对象时，其销毁助手例程将调用此入口点以帮助处置内容
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://__block修饰的变量，即bref类型的
        // get rid of the __block data structure held in a Block
        _Block_byref_release(object);
        break;
      case BLOCK_FIELD_IS_BLOCK://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_byref_release源码，主要就是对象、变量的释放销毁：

static void _Block_byref_release(const void *arg) {
    
    
    //对象强转为Block_byref类型结构体
    struct Block_byref *byref = (struct Block_byref *)arg;

    // dereference the forwarding pointer since the compiler isn't doing this anymore (ever?)
    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);
                (*byref2->byref_destroy)(byref);//销毁拷贝对象
            }
            free(byref);//释放
        }
    }
}

④ 调试验证

• 定义一个__block修饰的NSString对象：

 	__block NSString *name = [NSString stringWithFormat:@"YANG"];
	void (^block)(void) = ^{
    
     
		// block_copy
	    name = @"YANG";
	    NSLog(@"%@", name);
	    // block 内存
	};
	block();

• xcrun编译结果如下：
  • 编译后的name比普通变量多了__Block_byref_id_object_copy_131 和 __Block_byref_id_object_dispose_131；
  • __Block_byref_name_0结构体中多了__Block_byref_id_object_copy和__Block_byref_id_object_dispose；

__Block_byref_name_0 name =
	        {
    
    (void*)0,
	            (__Block_byref_name_0 *)&name,
	            33554432,
	            sizeof(__Block_byref_name_0),
	            __Block_byref_id_object_copy_131,
	            __Block_byref_id_object_dispose_131,
	            ((NSString * _Nonnull (*)(id, SEL, NSString * _Nonnull, ...))(void *)objc_msgSend)((id)objc_getClass("NSString"), sel_registerName("stringWithFormat:"), (NSString *)&__NSConstantStringImpl__var_folders_hr_l_56yp8j4y11491njzqx6f880000gn_T_main_9f330d_mi_0)};
	            
	//********__Block_byref_name_0结构体********
	struct __Block_byref_name_0 {
    
    
	  void *__isa;
	__Block_byref_name_0 *__forwarding;
	 int __flags;
	 int __size;
	 void (*__Block_byref_id_object_copy)(void*, void*);
	 void (*__Block_byref_id_object_dispose)(void*);  // 5*8 = 40
	 NSString *name;
	};
	 
	 //********__Block_byref_id_object_copy_131********
	 //block自身拷贝（_Block_copy） -- __block bref结构体拷贝(_Block_object_assign) -- _Block_object_assign中对外部变量（存储在bref）拷贝一份到内存
	static void __Block_byref_id_object_copy_131(void *dst, void *src) {
    
    
	    //dst 外部捕获的变量，即结构体 - 5*8 = 40，然后就找到了name(name在bref初始化时就赋值了)
	    _Block_object_assign((char*)dst + 40, *(void * *) ((char*)src + 40), 131);
	}
	
	 //********__Block_byref_id_object_dispose_131********
	static void __Block_byref_id_object_dispose_131(void *src) {
    
    
	 _Block_object_dispose(*(void * *) ((char*)src + 40), 131);
	}

• 通过可编译源码断点调试，关键方法的执行顺序为：_Block_copy -> _Block_byref_copy -> _Block_object_assign，正好对应上述三层copy。

④ 总结

• block 捕获外界变量 name 流程：
  • 通过_Block_copy方法，将block拷贝一份至堆区；
  • 通过_Block_object_assign方法正常拷贝，因为__block修饰的外界变量在底层是 Block_byref结构体；
  • 然后捕获外部变量还存有一个对象，从bref中取出相应对象name，拷贝至block空间，才能使用（相同空间才能使用，不同则不能使用）。
  • 最后通过内存平移就得到了name，此时的name和外界的name是同一片内存空间（从_Block_object_assign方法中的*dest = object可以看出）。
• block 三次 copy 总结：
  • 通过 _Block_copy 实现对象的自身拷贝，从栈区拷贝至堆区；
  • 通过 _Block_byref_copy 方法，将对象拷贝为 Block_byref 结构体类型；
  • 调用 _Block_object_assign 方法，对 __block 修饰的当前变量的拷贝。
  • 注意：只有 __block 修饰的对象，block 的 copy 才有三次。

⑤ block 三层 copy 流程如下：