iOS-底层原理02：alloc&init&new分别做了什么

在我们的日常开发的过程中经常会使用到alloc，init，new，这些方法，但是这些方法又是如何实现的呢？在他们当中又做了哪些事情呢？下面我们先来看一个例子：

GJPerson *objc1 = [GJPerson alloc];
GJPerson *objc2 = [objc1 init];
GJPerson *objc3 = [objc1 init];
NSLog(@"%@ - %p - %p", objc1, objc1, &objc1);
NSLog(@"%@ - %p - %p", objc2, objc2, &objc2);
NSLog(@"%@ - %p - %p", objc3, objc3, &objc3);

以上3条输出语句分别输出了3个对象的内容、内存地址、指针地址，他们的值又会是什么呢？是否相同呢？

验证结果如下图：

从验证结果可知，3个对象指向的是同一内存空间，所以其内容和内存地址都是相同的，但是指针地址是不同的
从而我们可以初步的推断出，alloc开辟了内存空间，init将指针指向alloc开辟的内存空间中！

下面我们就来深入的了解一下alloc，init，new ~

alloc源码探究

准备工作：
下载objc4源码
编译源码，可自行进行百度、google、github，网上有详细的编译教程以及可编译程序，就不多加赘述了

alloc + init 整体源码的执行流程如下图：

通过断点调试源码可知，alloc实现主要分为以下几个步骤：

第一步：alloc 方法

1
2
3

+ (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)// alloc 源码 第三步
{
#if __OBJC2__ //有可用的编译器优化
    /*
	fastpath slowpath参考链接：https://www.jianshu.com/p/536824702ab6
	checkNil 为false，!cls 也为false ，所以slowpath 为 false，假值判断不会走到if里面，即不会返回nil
     */
    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方法，这部分是alloc源码的核心操作，由下面的流程图及源码可知，该方法的实现主要分为三部分

cls->instanceSize：计算需要开辟的内存空间大小
calloc：申请内存，返回地址指针

obj->initInstanceIsa：将类与 isa 关联

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)// alloc 源码 第五步
{
    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;

    //计算需要开辟的内存大小，传入的extraBytes 为 0
    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) {
        //将 cls类 与 obj指针（即isa） 关联
        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);
}

cls->instanceSize：计算所需内存大小

instanceSize的源码实现

size_t instanceSize(size_t extraBytes) const {
    //编译器快速计算内存大小
    if (fastpath(cache.hasFastInstanceSize(extraBytes))) {
        return cache.fastInstanceSize(extraBytes);
    }
    
    // 计算类中所有属性的大小 + 额外的字节数0
    size_t size = alignedInstanceSize() + extraBytes;
    // CF requires all objects be at least 16 bytes.
    //如果size 小于 16，最小取16
    if (size < 16) size = 16;
    return size;
}

fastInstanceSize的源码实现

size_t fastInstanceSize(size_t extra) const
{
    ASSERT(hasFastInstanceSize(extra));

    //Gcc的内建函数 __builtin_constant_p 用于判断一个值是否为编译时常数，如果参数EXP 的值是常数，函数返回 1，否则返回 0
    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
        //删除由setFastInstanceSize添加的FAST_CACHE_ALLOC_DELTA16 8个字节
        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);
}

内存字节对齐原则

在解释为什么需要16字节对齐之前，首先需要了解内存字节对齐的原则，主要有以下三点

数据成员对齐规则：struct 或者 union 的数据成员，第一个数据成员放在offset为0的地方，以后每个数据成员存储的起始位置要从该成员大小或者成员的子成员大小（只要该成员有子成员，比如数据、结构体等）的整数倍开始（例如int在32位机中是4字节，则要从4的整数倍地址开始存储）
数据成员为结构体：如果一个结构里有某些结构体成员，则结构体成员要从其内部最大元素大小的整数倍地址开始存储（例如：struct a里面存有struct b，b里面有char、int、double等元素，则b应该从8的整数倍开始存储）
结构体的整体对齐规则：结构体的总大小，即sizeof的结果，必须是其内部做大成员的整数倍，不足的要补齐

为什么需要16字节对齐

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

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

calloc：申请内存，返回地址指针

此时并没有与obj对象进行关联，只是返回了地址指针

obj->initInstanceIsa：类与isa关联

将上述得到的地址指针与obj进行关联

到此alloc执行就已经结束了 ~

init 源码探索

类方法实现init

1
2
3

+ (id)init {
    return (id)self;
}

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

new 源码探索

1
2
3

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

从以上代码可以看出，new方法实际上等价与[[xxx alloc] init]，鉴于开发过程中通常会重写init方法做一些自定义的操作，所以不建议使用new方法

注：
1.如果子类没有重写父类的init，new会调用父类的init方法
2.如果子类重写了父类的init，new会调用子类重写的init方法
3.如果使用 alloc + 自定义的init，可以帮助我们自定义初始化操作，例如传入一些子类所需参数等，最终也会走到父类的init，相比new而言，扩展性更好，更灵活。