OC底层原理探索文档汇总
上文说到，block本质是一个可以捕获变量的匿名函数，并且具有对象的特征，也可以看做是一个仅有一个函数的对象。接下来就通过Clang和查看源码分析block的底层实现来证明
主要内容：
1、block的本质
2、__block的原理
3、block的底层类型
4、block从栈拷贝到堆的过程分析
1、block的本质
1.1 block在底层的结构
定义block.c文件
#include "stdio.h"
int main(){
void(^block)(void) = ^{
printf("wy");
};
return 0;
}
通过Clang编译
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("wy");
}
//******简化******
void(*block)(void) = __main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA));//构造函数
block->FuncPtr(block);//block调用执行
说明：
- 可以看出__main_block_impl_0用来构造block
- __main_block_impl_0函数传入两个参数，__main_block_func_0和&__main_block_desc_0_DATA。
- 通过指向block的FuncPtr方法进行调用
查看结构体
//**block定义结构体**
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实现结构体**
struct __block_impl {
void *isa;
int Flags;
int Reserved;
void *FuncPtr;
};
说明：
- 可以看到__main_block_impl_0结构体是用以定义block的一个结构体。包含block结构体、block描述信息，以及一个同名构造函数
- impl是block本身
- Desc会提供一些定义block时的描述信息
- 在构造函数中会将外界的值赋值到block结构体中。以此来构造block
- 重点看的就是给impl的isa赋值block类型，还有将外界的函数赋值给block。
- 在block结构体__block_impl中包含isa和FuncPtr，还有Flags和Reserved（这两个不用关注）
- 结构体中包含有isa，有三种类型，NSGlobalBlock、NSMallocBlock、NSStackBlock，这也可以说明block可以看做一个对象，因为它有isa，并且指向不同的结构体类型。
- FuncPtr就是block中的函数，它用来执行具体的功能
1.2 block如何捕获外界变量
定义一个变量，并在block中调用
int main(){
int a = 11;
void(^block)(void) = ^{
printf("WY - %d", a);
};
block();
return 0;
}
底层编译：
//**block实现结构体**
struct __block_impl {
void *isa;
int Flags;
int Reserved;
void *FuncPtr;
};
//block定义结构体
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
int a;//编译时就自动生成了相应的变量
// a(_a) 的做法是将传入的_a赋值给当前结构体中的a
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _a, int flags=0) : a(_a) {
impl.isa = &_NSConcreteStackBlock;//block的isa默认是stackBlock
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
//block函数
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
//在函数中会自动创建一个局部变量，并将外界的变量值赋值给局部变量a中
//属于值拷贝，也就是直接将11赋值给a.因此__cself->a和a没有关系
int a = __cself->a; // bound by copy 值拷贝，即 a = 11
printf("WY - %d", a);
}
int main(){
int a = 11;
//当block使用外界变量时，会自动将变量传入到block中
void(*block)(void) = __main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA, a));
block)->FuncPtr(block);
return 0;
}
说明：
- 当block使用外界的变量时，会将变量通过block的构造函数中传入到block定义结构体中
- 在block的构造函数中会将变量赋值给block定义结构体__main_block_impl_0的变量。（此时_main_block_impl_0结构体会自动创建一个相同名称的变量,差别在于没有前边没有）
- 之后在block函数中也会自动创建一个局部变量，同时将__main_block_impl_0结构体中的变量赋值给局部变量。以此让函数可以使用该变量。
总结：block在使用外界变量时，会在block定义结构体中定义一个变量来保存外界变量的值。这样就表现为捕获。
1.3 __block修饰变量的原理
对a加一个__block，然后在block中使用a
#include "stdio.h"
int main(){
__block int a = 11;
void(^block)(void) = ^{
a++;
printf("WY %d",a);
};
// block();
return 0;
}
Clang编译：
//block实现结构体
struct __block_impl {
void *isa;//可以看到包含有isa
int Flags;
int Reserved;
void *FuncPtr;//函数指针
};
//__block修饰的变量结构体
struct __Block_byref_a_0 {
void *__isa;
__Block_byref_a_0 *__forwarding;//这里是a的地址
int __flags;
int __size;
int a;//最后可以找到结构中的变量a
};
//定义block的底层结构体
struct __main_block_impl_0 {
struct __block_impl impl;//block结构体
struct __main_block_desc_0* Desc;//描述符
__Block_byref_a_0 *a; // 变量，在编译时就会将外界的数据获取到
//构造函数，传入的fp就是block内部的函数
__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;//这里是栈block
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
//block内部的函数实现，会传入block本身
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
//将block的变量赋值给当前函数的局部变量。
//但因为此处的a是指针，不是基本类型，所以指针赋值的修改是可以影响的。
//在函数中是定义了一个变量a，如果是基本数据类型，进行赋值，那么就是局部变量，无法影响到外界的a
__Block_byref_a_0 *a = __cself->a; // bound by ref
//之后将结构体a的__forwarding结构体拿到，在拿到结构体中的变量a,之后进行操作
//也就是说这里操作的不是局部变量本身，而是局部变量结构体的指针。
(a->__forwarding->a)++;
printf("LG_Cooci - %d",(a->__forwarding->a));
}
int main(){
//__block修饰的变量
__attribute__((__blocks__(byref))) __Block_byref_a_0 a = {(void*)0,(__Block_byref_a_0 *)&a, 0, sizeof(__Block_byref_a_0), 11};
//block定义
void(*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_a_0 *)&a, 570425344));
//这里是调用，可以看到会将结构体__Block_byref_a_0作为变量传入到block中
void(*block)(void) = __main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_a_0 *)&a, 570425344));
return 0;
}
说明：
- 可以看到外界的变量使用__block修饰后，其实在底层会将该变量设置为结构体__Block_byref_a_0
- __Block_byref_a_0结构体主要包含两个值，一个是变量地址，一个是变量本身
- block在使用变量时，也会传入__Block_byref_a_0结构体来使用，可以看到传入的其实就是a的地址&a。
- __main_block_impl_0中也会主动创建一个变量block来存储外界变量的地址，通过a(_a->__forwarding)来进行赋值
- 最后在block内部函数__main_block_func_0中也自动创建一个__Block_byref_a_0局部变量用来存储外界变量的地址。
- 在函数中使用变量时，其实使用的是通过变量地址所指向的变量。
总结：
- 外界变量会生成__Block_byref_a_0结构体
- 结构体用来保存原始变量的指针和值
- 将变量生成的结构体对象的指针地址 传递给block，然后在block内部就可以对外界变量进行操作了
- 简单来说就是将值拷贝转变为指针拷贝，所以就可以修改外界变量了。
2、block的底层类型
查看libclosure-74源码,通过查看_Block_copy的源码实现，发现block在底层的真正类型是Block_layout
block真正类型
查看Block_layout类型的定义，是一个结构体
// Block 结构体
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的附加信息，使用位域的方式存储，其中flags的种类有以下几种，主要重点关注BLOCK_HAS_COPY_DISPOSE 和 BLOCK_HAS_SIGNATURE。 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 时动态调用。
// 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
};
- reserved：保留信息，可以理解预留位置，猜测是用于存储block内部变量信息
- invoke：是一个函数指针，指向block的执行代码
- descriptor：block的附加信息，比如保留变量数、block的大小、进行copy或dispose的辅助函数指针。有三类
- Block_descriptor_1是必选的
- Block_descriptor_2 和 Block_descriptor_3都是可选的
#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
// Block 的描述 : copy 和 dispose 函数
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;
}
// Block 的描述 : 签名相关
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;
}
4、block的拷贝过程
包括block本身从栈如何拷贝到堆中，捕获的外界局部变量如何拷贝到堆中两类。
4.1 _Block_copy源码分析
这里只有一次拷贝，即将栈block拷贝为堆block，如果不使用外界的局部变量，就只有这一层拷贝。
源码
// 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_copy源码，将block 从栈区拷贝至堆区
- 如果需要释放，则直接释放
- 如果是globalBlock，说明不需要copy，直接返回
- 反之，肯定是栈block，因为初始创建的不可能是堆block，堆block必须是通过栈block拷贝的
- 此处将栈block拷贝为堆block
- 通过malloc申请内存空间用于接收block
- 通过memmove将block拷贝至新申请的内存中
- 设置block对象的类型为堆区block，即result->isa = _NSConcreteMallocBlock
4.2 _Block_object_assign 分析
如果block使用外部的局部变量，则会开始接下来的两层拷贝
首先需要知道外部变量的种类有哪些，下面这些其中用的最多的是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.
};
4.2.1 _Block_object_assign源码
// __block 变量
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];
********/
// objc 指针地址 weakSelf (self)
// arc
_Block_retain_object(object);
// 持有
//持有了当前指针，就在这里，强引用
*dest = object;
break;
case BLOCK_FIELD_IS_BLOCK:
/*******
void (^object)(void) = ...;
[^{ object; } copy];
********/
// block 被一个 block 捕获
*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;
}
}
说明：
- 如果是普通对象，则交给系统arc处理，并通过*dest = object拷贝对象指针，即引用计数+1，所以如果直接使用外界的对象，则该对象会引用计数+1不能释放，这也是循环引用出现的条件
- 如果是block类型的变量，则通过_Block_copy操作，将block从栈区拷贝到堆区
- 如果是__weak或__block修饰的变量，调用_Block_byref_copy函数，开始捕获变量
4.2.2 进入_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
//1、先创建了一个需要捕获的变量的结构体
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;
//2、在这里将这个结构体的指针都指向这两个变量中，这样他们两个的修改都会改变这个内存数据
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结构体类型对象
- 再创建一个需要捕获的变量的结构体，并且将原来的数据拷贝到这个结构体中
- 最后让src和copy两者的forwarding都指向copy，也就是他们指向同一个区域，这样就可以做到他们两个的修改都会改变这个内存数据
总结：
- 最初创建的需要捕获的变量的结构体是在栈中
- 之后这个结构体从栈中copy到堆中
- 最后将栈的指针指向堆中的结构体，堆中的结构体的指针指向自己。