OC对象原理（上）
一 . alloc 初识
1. 我们写一个例子，来看下alloc的操作.
截屏2022-01-05 下午10.28.17.png
我们可以看出
截屏2022-01-05 下午10.34.17.png
小结
1 alloc 可以开辟内存，生成对象。
2 栈区开辟的内存是从高地址往低地址。f8 -> f0 -> e8
3 init 不会改变对象的内存地址，team1, team2,team3都指向了同一个内存地址
4 因为指向同一个内存地址。所以给team1的name属性赋值时，其实操作的也是team3指针指向的内存地址。 所以team3的name也为小码
2. 疑惑跟进
alloc怎么做到开辟空间的? init 又有何作用
二 . 3种探索底层的方式
1. 添加符号断点
截屏2022-01-05 下午11.00.49.png
添加objc_alloc符号断点，运行可以看到
截屏2022-01-05 下午11.01.06.png
根据这个方法，通过符号断点，去断_objc_rootAllocWithZone方法，看接着又调用了哪些方法，以此类推，我们就可以调试到我们需要调试的地方.
2. 通过汇编进行断点调试跟踪
设置步骤：Xcode -> Debug -> Debug Workflow -> Always Show Disassembly
配合符号断点运行，会出现
截屏2022-01-05 下午11.09.40.png
3. 通过已知函数名称，并手动插入符号断点，确定位置
这里可以添加符号断点alloc。
4 问题跟进
这几个虽然有效，但是效率太低了，每次都得不断的进行断点跟踪，不仅繁琐，还还很麻烦。寻找丝滑的路径
三 . 通过源码编译，进行alloc的源码探究
我们可以通过苹果开源库, 找到objc4。下载源码学习.
根据源码工程。我们看下alloc的流程.
+ (id)alloc {
return _objc_rootAlloc(self);
}
进入 _objc_rootAlloc
id _objc_rootAlloc(Class cls)
{
return callAlloc(cls, false/*checkNil*/, true/*allocWithZone*/);
}
进入 callAlloc
static ALWAYS_INLINE id
callAlloc(Class cls, bool checkNil, bool allocWithZone=false)
{
#if __OBJC2__ //判断是不是 objc2.0版本
//slowpath(x):x很可能为假，为真的概率很小
//fastpath(x):x很可能为真
//其实将fastpath和slowpath去掉是完全不影响任何功能,写上是告诉编译器对代码进行优化
if (slowpath(checkNil && !cls)) return nil;
//判断该类是否实现自自定义的 +allocWithZone，没有则进入if条件句
if (fastpath(!cls->ISA()->hasCustomAWZ())) {
return _objc_rootAllocWithZone(cls, nil);
}
#endif
// No shortcuts available.
if (allocWithZone) {
return ((id(*)(id, SEL, struct _NSZone *))objc_msgSend)(cls, @selector(allocWithZone:), nil);
}
return ((id(*)(id, SEL))objc_msgSend)(cls, @selector(alloc));
}
进入 _objc_rootAllocWithZone
id
_objc_rootAllocWithZone(Class cls, malloc_zone_t *zone __unused)
{
// allocWithZone under __OBJC2__ ignores the zone parameter
return _class_createInstanceFromZone(cls, 0, nil,
OBJECT_CONSTRUCT_CALL_BADALLOC);
}
进入核心代码区_class_createInstanceFromZone
这里主要做三步
1cls->instanceSize 计算ro中成员变量所需的内存大小
2 (id)calloc(1, size)开辟内存空间
3 obj->initInstanceIsa初始化isa指针与cls 关联
_class_createInstanceFromZone(Class cls, size_t extraBytes, void *zone,
int construct_flags = OBJECT_CONSTRUCT_NONE,
bool cxxConstruct = true,
size_t *outAllocatedSize = nil)
{
ASSERT(cls->isRealized());
// Read class's info bits all at once for performance
bool hasCxxCtor = cxxConstruct && cls->hasCxxCtor();
bool hasCxxDtor = cls->hasCxxDtor();
bool fast = cls->canAllocNonpointer();
size_t size;
size = cls->instanceSize(extraBytes);
if (outAllocatedSize) *outAllocatedSize = size;
id obj;
if (zone) {
obj = (id)malloc_zone_calloc((malloc_zone_t *)zone, 1, size);
} else {
obj = (id)calloc(1, size);
}
if (slowpath(!obj)) {
if (construct_flags & OBJECT_CONSTRUCT_CALL_BADALLOC) {
return _objc_callBadAllocHandler(cls);
}
return nil;
}
if (!zone && fast) {
obj->initInstanceIsa(cls, hasCxxDtor);
} else {
// Use raw pointer isa on the assumption that they might be
// doing something weird with the zone or RR.
obj->initIsa(cls);
}
if (fastpath(!hasCxxCtor)) {
return obj;
}
construct_flags |= OBJECT_CONSTRUCT_FREE_ONFAILURE;
return object_cxxConstructFromClass(obj, cls, construct_flags);
}
2
但在实际运行源码时，发现alloc会先调用objc_alloc方法
objc_alloc(Class cls)
{
return callAlloc(cls, true/*checkNil*/, false/*allocWithZone*/);
}
这是因为苹果在底层做了插桩处理，
第一次：执行alloc时，会通过方法映射，调用objc_alloc，此时做了 插桩 操作（做标记 receiver），接下来就是第一次调用 callAlloc ->objc_msgSend(alloc)
第二次：再次执行alloc，再次执行objc_alloc，发现有标记存在，所以不再执行 objc_alloc方法，而是调用本身的 alloc，进而执行 _objc_rootAlloc-> callAlloc ->objc_msgSend(allocWithZone)
这里主要是因为，alloc是对内存的操作，苹果对于这样的操作要做一定的管控
3 最终流程图
文字描述
1 调用alloc方法后， 调用objc_alloc，调用callAlloc
2 判断 slowpath(checkNil && !cls)
3 判断fastpath(!cls->ISA()->hasCustomAWZ()) 是否有自定义的allocWithZone方法
4 如果有自定义的allocWithZone方法， 调用_objc_rootAllocWithZone
5 如果没有自定义的allocWithZone方法，我们可以看到 objc_alloc调用的callAlloc方法，allocWithZone 参数为false
6 所以 调用了((id(*)(id, SEL))objc_msgSend)(cls, @selector(alloc));,再走了一次alloc
7 再次执行objc_alloc，发现有标记存在，所以不再执行 objc_alloc方法，而是调用本身的 alloc.
8 alloc 调用 _objc_rootAlloc方法
9 _objc_rootAlloc调用了 callAlloc， 注意这个方法里面的allocWithZone 参数为true。
10 继续重复上面2， 3， 4
11 如果没有自定义的allocWithZone方法，allocWithZone 参数为true，调用了((id(*)(id, SEL, struct _NSZone *))objc_msgSend)(cls, @selector(allocWithZone:), nil);
12 allocWithZone 会调用 _objc_rootAllocWithZone(self, (malloc_zone_t *)zone);
13 _objc_rootAllocWithZone 调用了_class_createInstanceFromZone
14 通过 cls->instanceSize(extraBytes); 获取需要申请的内存大小
15 通过calloc，申请内存空间
16 initInstanceIsa：初始化指针 ，和类关联起来
流程图
alloc 流程图.png
4. 疑惑跟进
我们研究下核心三个方法
四 . 通过源码编译，进行alloc的核心三个方法
1 instanceSize：计算内存大小
inline size_t instanceSize(size_t extraBytes) const {
//快速计算内存大小
if (fastpath(cache.hasFastInstanceSize(extraBytes))) {
return cache.fastInstanceSize(extraBytes);
}
//计算类中所有变量需要的内存大小 extraBytes额外字节数一般是0
size_t size = alignedInstanceSize() + extraBytes;
// CF requires all objects be at least 16 bytes.
//最小返回16字节
if (size < 16) size = 16;
return size;
}
断点进入cache.fastInstanceSize
size_t fastInstanceSize(size_t extra) const
{
ASSERT(hasFastInstanceSize(extra));
if (__builtin_constant_p(extra) && extra == 0) {
return _flags & FAST_CACHE_ALLOC_MASK16;
} else {
size_t size = _flags & FAST_CACHE_ALLOC_MASK;
// remove the FAST_CACHE_ALLOC_DELTA16 that was added
// by setFastInstanceSize
return align16(size + extra - FAST_CACHE_ALLOC_DELTA16);
}
}
断点进入align16 (16字节对齐)
static inline size_t align16(size_t x) {
return (x + size_t(15)) & ~size_t(15);
}
我们探究下 align16 方法的具体实现
假如 x = 4
上面就reurn (4 + 15) & ~15
19 = 0001 0011
15 = 0000 1111
~15 = 1111 0000
19 & ~15 = 00010000 = 16
所以是16字节对齐
2. 为什么需要16字节对齐
cpu 读取数据是以固定字节块来读取的，这是一个用空间换取时间的做法，如果频繁的读取字节未对齐的数据，降低了cpu的性能和读取速度。
更安全 由于在一个对象中isa指针是占8个字节，如果不进行节对齐 ，对象之间就会紧挨着，容易造成访问混乱。16字节对齐，会预留部分空间，访问更安全
3 calloc，开辟内存
obj = (id)calloc(1, size);
这时候的obj还只是个地址，系统给开辟一个占位内存地址。还未和isa进行绑定
4 initInstanceIsa：初始化指针 ，和类关联起来
inline void
objc_object::initInstanceIsa(Class cls, bool hasCxxDtor)
{
ASSERT(!cls->instancesRequireRawIsa());
ASSERT(hasCxxDtor == cls->hasCxxDtor());
initIsa(cls, true, hasCxxDtor);
}
在上一步，obj已经向操作系统申请好内存空间，但是首地址也就是 Class结构体的第一个变量 isa还没有被初始化，首地址指向的还是一片脏内存，在isa初始化完成后 obj 首地址 isa被初始化成功关联到对象.
五 . init 和 new
1. init
- (id)init {
return _objc_rootInit(self);
}
id
_objc_rootInit(id obj)
{
// In practice, it will be hard to rely on this function.
// Many classes do not properly chain -init calls.
return obj;
}
工厂设计模式, 子类根据自身需求去初始化类。
1 new
+ (id)new {
return [callAlloc(self, false/*checkNil*/) init];
}
可以看出new 方法相当于 callAlloc + init。 不能像init一样扩展。
