iOS alloc&init 底层实现

源码定位

在业务层开发时，很少会研究Objc源码及底层实现。
下面罗列查找源码的3个方法：

1.  通过符号断点跟流程。
2.  ctrl + step into；结合符号断点查到源码库。
3.  运行时汇编跟流程。汇编开启方法：Xcode->Debug->Debug workflow->Always Show Disassembly）

举🌰：

在测试项目新建一个继承NSObject的类，并alloc出一个实例对象：

FLObject *object = [FLObject alloc];

打好断点后运行，并开启汇编调试

symbol

如图symbol，我们可以看到下一条指令的汇编注释symbol stub for: objc_alloc得知立即调用存根符号为objc_alloc的函数，所以我们不妨增加一个objc_alloc的符号断点，接着运行可以看到

libObjc

所以可以看到在调用 FLObject *object = [FLObject alloc]; 时，底层调用为libobjc.A.dylib动态链接库中的objc_alloc方法。

通过苹果开源库下载相关开源库。

注：callq：属于x86的指令，即调用函数时的压栈出栈。图libObjc中callq指令会使程序跳到0x10934b30的地址中执行。除此之外，该指令还会将当前函数的下一条指令入栈

2.alloc&init 探索

alloc 流程分析

alloc 的实现流程如下：

alloc 流程.png

1. 自定义类调用的 alloc ，点击进入定义：

/// alloc分析 step1
+ (id)alloc {
    return _objc_rootAlloc(self);
}

2. 跳转至rootAlloc内部实现

/// alloc分析 step2
id
_objc_rootAlloc(Class cls)
{
    return callAlloc(cls, false/*checkNil*/, true/*allocWithZone*/);
}

3. 跳转至callAlloc内部实现

static ALWAYS_INLINE id
callAlloc(Class cls, bool checkNil, bool allocWithZone=false) /// alloc分析 step3
{
#if __OBJC2__
    
    if (slowpath(checkNil && !cls)) return nil;
    /// 判断当前类是否重写allocWithZone方法
    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));
}

callalloc内部实现中，有 slowpath和fastpath用于判断的宏。

/// x很大可能为真，即真值判断
#define fastpath(x) (__builtin_expect(bool(x), 1))
/// x很大可能为假，即假值判断
#define slowpath(x) (__builtin_expect(bool(x), 0))

其中__builtin_expect是由gcc引入的
目的：编译器可以对代码进行优化，以减少指令跳转带来的性能下降，即性能优化
作用：允许程序员将最有可能执行的分支告诉编译器。
写法： __builtin_expect(EXP, N)。表示 EXP==N的概率很大。

hasCustomAWZ

fastpath中cls->ISA()->hasCustomAWZ()表示 当前类是否重写类的allWithZone，此时判断成立，继续调用_objc_rootAllocWithZone。

4. 跳转_objc_rootAllocWithZone实现

id
_objc_rootAllocWithZone(Class cls, malloc_zone_t *zone __unused) /// alloc分析 step4
{
    // allocWithZone under __OBJC2__ ignores the zone parameter
    return _class_createInstanceFromZone(cls, 0, nil,
                                         OBJECT_CONSTRUCT_CALL_BADALLOC);
}

5. 跳转_class_createInstanceFromZone,此方法是alloc源码的核心操作。其中主要实现分为3部分：

   - cls->instanceSize：计算需要开辟的内存大小；
   - calloc(1, 计算的内存大小)：申请内存，并返回地址指针；
   - obj->InitInstanceIsa：关联 cls 与 地址指针

static ALWAYS_INLINE id /// alloc分析 step5
_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 {
        /// alloc 开辟内存的地方
        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);
}

核心操作细分

1. cls->instanceSize：计算所需开辟的内存大小

源码实现

/// alloc分析 instanceSize step1
    size_t instanceSize(size_t extraBytes) const {
        /// 经断点调试，fastpath真值判断成立，编译器快速计算内存大小
        if (fastpath(cache.hasFastInstanceSize(extraBytes))) {
            return cache.fastInstanceSize(extraBytes);
        }
        /// 计算类中所有属性的大小 + 额外的字节数0
        size_t size = alignedInstanceSize() + extraBytes;
        // CF requires all objects be at least 16 bytes.
        if (size < 16) size = 16;
        return size;
    }

/// alloc分析 instanceSize step2
    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
            /// 16字节对齐算法
            return align16(size + extra - FAST_CACHE_ALLOC_DELTA16);
        }
    }

align16(size_t x) 即16字节对齐算法。系统开辟内存时，默认以16字节对齐，对象实际所需内存按8字节对齐，16字节对齐也为后期扩容做准备。

下面是align16()内部实现：

/*
   0000 0000 0000 1111  15 
   0000 0000 0001 0111 23           1.入参size + 15
   1111 1111 1111 0000 15的取反      2.对15取反
   0000 0000 0001 0000 16倍数       3.step1与step2 取&，即低位抹零，留下16的倍数
 **/
static inline size_t align16(size_t x) {
    return (x + size_t(15)) & ~size_t(15);
}

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

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

验证：在未执行calloc时，po obj为nil，执行后calloc后再po，返回了一个地址指针。

3. obj->InitInstanceIsa：关联 当前类 与 地址指针

经过第二步，内存已申请，并且也拿到了当前类；下面就是将 类 与 地址指针 即进行关联，内部实现流程如下:

initIsa.png

即：初始化isa指针，将isa指针指向申请的内存地址，在将指针与cls类进行 关联。

总结

alloc的核心工作就是开辟内存，并使用16字节对齐算法。而开辟的系统开辟的内存大小都是16的倍数。
主要步骤：计算大小 -> 开辟内存 -> 关联

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

new 源码探索

关于new方法，我们在开发中多使用alloc + init的方法创建并初始化对象。其两者本身并无区别，从源码可以得知：new方法通过调用callAlloc & init方法，等价于[[cls alloc] init]。

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

但是在开发中，new的应用场景并不多。 因为我们可以通过重写init来自定义初始化操作，同时会在这个方法中调用[super init]，而用new初始化可能会无法走到自定义的init的实现。

举例：
在自定义类中添加两个初始化方法，重写 父类init 及 自定义初始化构造方法，下面我们分别执行new 及 自定义初始化方法

• 执行new

  
  new 方法

• 执行 自定义初始化

  
  构造初始化

总结

• 子类没有重写父类的init，new调用父类的init；
• 子类重写父类init，new会调用子类重写init；
• 使用alloc + init，可以在init添加子类所需参数，拓展性更高。