底层源码-alloc & init & new的探索

在探索alloc源码之前，先了解对象的内容，指针地址和内存地址之间的关系

在图中可以看出3个对象指向的是同一个内存空间，内容和指针地址是相同的，但是对象的内存地址是不同的的。

%p ",p1 指的是指针地址
%p ",&p1 指的是内存地址

现在就让我们探索alloc做了什么，init做了什么。

alloc 流程图

首先我们来探索alloc的执行流程
【第一步】根据main函数的LGPerson类，进入alloc类方法的源码实现。

【第二步】跳转_objc_rootAlloc的源码实现

【第三步】跳转callAlloc的源码

【第四步】跳转_objc_rootAllocWithZone源码

【第五步】跳转_class_createInstanceFromZone源码

static ALWAYS_INLINE id
_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;
    //第1步
    size = cls->instanceSize(extraBytes);
    if (outAllocatedSize) *outAllocatedSize = size;

    id obj;
    if (zone) {
        obj = (id)malloc_zone_calloc((malloc_zone_t *)zone, 1, size);
    } else {
        // alloc 开辟内存的地方
         //第2步
        obj = (id)calloc(1, size);
    }
    if (slowpath(!obj)) {
        if (construct_flags & OBJECT_CONSTRUCT_CALL_BADALLOC) {
            return _objc_callBadAllocHandler(cls);
        }
        return nil;
    }

    if (!zone && fast) {
        //第3步
        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);
}

alloc 核心方法

cls->instanceSize：计算出需要的内存空间大小
calloc：向系统申请开辟内存，返回地址指针
obj->initInstanceIsa：关联到相应的类

cls->instanceSize

跳转至instanceSize的源码实现

 size_t instanceSize(size_t extraBytes) const {
        if (fastpath(cache.hasFastInstanceSize(extraBytes))) {
            return cache.fastInstanceSize(extraBytes);
        }

        size_t size = alignedInstanceSize() + extraBytes;
        // CF requires all objects be at least 16 bytes.
        if (size < 16) size = 16;
        return size;
    }

通过断点调试，会执行到cache.fastInstanceSize方法，快速计算内存大小

跳转至fastInstanceSize源码实现，断点调试，跳转align16

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

calloc 申请内存

通过instanceSize计算的内存大小，向内存中申请大小为 size的内存，并赋值给obj，因此 obj是指向内存地址的指针.

obj = (id)calloc(1, size);

断点调试，在未执行calloc时，po obj为nil，执行后，再po obj法线，返回了一个16进制的地址.

obj->initInstanceIsa：类与isa关联

经过calloc可知，内存已经申请好了，类也已经传入进来了，接下来就需要将类与地址指针即isa指针进行关联.

内存字节对齐原则

1.数据成员对其规则：结构体(struct)或联合体(union)的数据成员，第一个数据成员放在offset为0的地方，以后每个数据成员存储的起始位置要从该成员大小或者成员的子成员大小（只要该成员有子成员，比如数组、结构体等）的整数倍开始。
eg: int为4字节，则要从4的整数倍地址开始存储
2.结构体作为成员：如果一个结构体内部包含其他结构体成员，则结构体成员要从其内部最大元素大小的整数倍地址开始存储。

eg: struct a里包含struct b，b中包含其他char、int、double等元素，那么b应该从8（double的元素大小）的整数倍开始存储

收尾工作：结构体的总大小，也就是sizeof的结果，必须是其内部最大成员的整数倍，不足的需要补齐。

需要字节对齐的原因，有以下几点：

通常内存是由一个个字节组成的，cpu在存取数据时，并不是以字节为单位存储，而是以块为单位存取，块的大小为内存存取力度。频繁存取字节未对齐的数据，会极大降低cpu的性能，所以可以通过减少存取次数来降低cpu的开销
16字节对齐，是由于在一个对象中，第一个属性isa占8字节，当然一个对象肯定还有其他属性，当无属性时，会预留8字节，即16字节对齐，如果不预留，相当于这个对象的isa和其他对象的isa紧挨着，容易造成访问混乱
16字节对齐后，可以加快CPU读取速度，同时使访问更安全，不会产生访问混乱的情况

字节对齐-总结

在字节对齐算法中，对齐的主要是对象，而对象的本质则是一个 struct objc_object的结构体，
结构体在内存中是连续存放的，所以可以利用这点对结构体进行强转。
苹果早期是8字节对齐，现在是16字节对齐

init 源码探索

探索完alloc ，接下来就是init源码探索，init源码的实现有两种方式

类方法
这里的init是一个构造方法，是通过工厂设计（工厂方法模式）,主要是用于给用户提供构造方法入口。这里能使用id强转的原因，主要还是因为内存字节对齐后，可以使用类型强转为你所需的类型。

// Replaced by CF (throws an NSException)
+ (id)init {
    return (id)self;
}

实例方法

// Replaced by CF (throws an NSException)
- (id)init {
    return _objc_rootInit(self);
}

跳转至_objc_rootInit的源码实现

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

根据上述代码，它最终返回的是self本身

new源码探索

一般在开发中，初始化除了init，还可以使用new，两者本质上并没有什么区别，以下是objc中new的源码实现，通过源码可以得知，new函数中直接调用了callAlloc函数（即alloc中分析的函数），且调用了init函数，所以可以得出new 其实就等价于 [alloc init]的结论

+ (id)new {
    return [callAlloc(self, false/*checkNil*/) init];
}

一般开发中并不建议使用new，主要是因为有时会重写init方法做一些自定义的操作，用new初始化可能会无法走到自定义的部分。

有兴趣可以下载源码进行调试