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一样扩展。