一、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内部实现。如下:
扫描二维码关注公众号,回复:
12903337 查看本文章
- 上文中提到的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 才有三次。