iOS 底层原理之 alloc & init & new 探究

前言

在探究 alloc 底层原理之前，我们先做个简单的测验，下面分别输出对象的内容，对象的地址，以及对象指针的地址代码和打印如下：

 LWPerson * objc = [LWPerson alloc];
 LWPerson * objc1 = [objc init];
 LWPerson * objc2 = [objc init];

 NSLog(@"%@--%p--%p",objc,objc,&objc);
 NSLog(@"%@--%p--%p",objc1,objc1,&objc1); 
 NSLog(@"%@--%p--%p",objc2,objc2,&objc2);

 --0x10065aee0--0x7ffeefbff4f0
 --0x10065aee0--0x7ffeefbff4e8
 --0x10065aee0--0x7ffeefbff4e0

结论：从上面打印的结果分析，打印的内容，对象的地址是一样的，但是对象指针的地址是不一样的，为什么呢 ？

原因如下图：

下面就是我们要探究的内容 ，在初始化对象时，alloc做了什么？init又做了什么？new和alloc，init 之间有何关系呢？

准备工作

• 下载源码 objc4-779.1
• 编译源码（后续补上）

alloc源码探索

根据源码工程，点击进入alloc， 流程图如下

代码流程如下首先点击进入 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__
    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

从源代码可以看出 _class_createInstanceFromZone方法中有核心三部分需要实现

• cls->instanceSize ： 计算内存大小
• (id)calloc(1, size) ： 开辟内存，返回地址指针
• obj->initInstanceIsa ：初始化指针，和类关联起来

cls->instanceSize：计算内存大小

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

内存(结构体)字节对齐原则

为什么需要16字节对齐

• cpu 读取数据是以固定字节块来读取的，这是一个用空间换取时间的做法，如果频繁的读取字节未对齐的数据，降低了CPU的性能和读取速度。
• 更安全 由于在一个对象中isa指针是占8个字节，如果不进行节对齐 ，对象之间就会紧挨着，容易造成访问混乱。16字节对齐，会预留部分空间，访问更安全

我们探究下align16方法的具体实现 已 align16(8)为例

x = 8, (x + size_t(15)) & ~size_t(15), ~(取反)
15 0000 0000 0000 1111
x + size_t(15) = 23 0000 0000 0001 0111
~15 1111 1111 1111 0000
最后一步： 23 & ~15 0000 0000 0001 0111 & 1111 1111 1111 0000
结果：0000 0000 0001 0000 16

总结：其实这种算法和 >> 4 << 4 是一样的，得出的结果就是16 的倍数，不足16的全部抹去。

calloc 开辟内存，返回地址指针

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

首先由instanceSize 计算出需要的内存大小，然后向系统申请size大小的内存，返回给objc，因此objc是指向内存地址的指针，下面我们通过断点打印的方法来验证下

发现在没有calloc之前只打印了cls类名，calloc后打印的是一个16进制的指针地址，说明已经开辟了内存，但是和平常见到的地址指针()不一样，为什么呢？

• 主要是 objc 没有和 cls 进行关联（下面要探索的）
• 同时也验证了 calloc 只是开辟了内存

obj->initInstanceIsa 初始化指针 ，和类关联起来

obj->initInstanceIsa(cls, hasCxxDtor);

inline void 
objc_object::initInstanceIsa(Class cls, bool hasCxxDtor)
{
    ASSERT(!cls->instancesRequireRawIsa());
    ASSERT(hasCxxDtor == cls->hasCxxDtor());

    initIsa(cls, true, hasCxxDtor);
}

具体的 isa 结构和源码探究，会在后面单独讲

在isa指针初始化以后，打印objc，指针已经与类已经关联

总结：alloc 的核心作用就是开辟内存，通过isa指针和类关联

init 源码探究

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

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

• init的类方法和实例方法返回的对象本身
• 不同的是类方法返回的是id 类型的self，可以提供给开发者更多的自由去自定义 ，通过id实现强转，返回我们需要的类型

new探究

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

源码显示 走了callAlloc的方法流程，然后走了init方法 ，所以 new看做是alloc + init

• alloc + init 可以重写init方法，提供开发者更多的自由
• new 是对(alloc+init)进行了封装，无法在初始化的时候添加其它的需求