alloc流程分析

OC作为一门面向对象的语言，那么对于对象的创建方法的探索流程就必不可少。下面我们就探索一下关于对象在创建时开辟内存的alloc方法的流程。

一、源码

探索之前我们需要一份最新的objc4-781官方源码进行调试，可参考cooci最新的objc4-779.1源码编译调试方法进行调试
objc官方源码
老司机最新macOS 10.15下objc4-779.1源码编译调试

二、源码调试方式

有了源码之后我们该如何调试alloc方法呢？

1. 符号断点

在下alloc符号断点的时候需要注意，不用运行之前就打开符号断点，因为所有的对象都有alloc方法，为了确保是自己创建的对象的alloc方法，我们需要先在自己对象的alloc方法前加一个断点，然后执行到断点处，我们再打开alloc符号断点，就进入了我们自己对象的alloc方法内部了。

符号断点.png

断点符号名称.png

2. Step into

和方法1一样，先在自己对象的alloc方法前加个断点，执行到断点处，按住control键，Step into进入方法

Step into.png

objc_alloc.png

所在库的位置.png

3. 汇编方式

和方法1一样，先在自己对象的alloc方法前加个断点，执行到断点处，Debug -> Debug Workflow -> Always Show Disassembly打开汇编模式，Step into断点进入汇编页面

汇编方式.png

和方法2相同，找到objc_alloc方法，step into进入方法内部查看所在库的位置

汇编页面.png

三、alloc源码调试

有了源码和知道了调试方式之后，便来到了第三步——alloc源码调试

1. alloc方法

+ (id)alloc {
    return _objc_rootAlloc(self);
}

2. _objc_rootAlloc方法

_objc_rootAlloc(Class cls)
{
    return callAlloc(cls, false/*checkNil*/, true/*allocWithZone*/);
}

fastpath表示条件更可能成立
slowpath表示条件更不可能成立

其实将fastpath和slowpath去掉是完全不影响任何功能的。之所以将fastpath和slowpath放到if语句中，是为了告诉编译器，if中的条件是大概率fastpath还是小概率slowpath事件，从而让编译器对代码进行优化。知道了这些，我们就可以来继续看源码了：

3. callAlloc方法

static ALWAYS_INLINE id
callAlloc(Class cls, bool checkNil, bool allocWithZone=false)
{
#if __OBJC2__
    if (slowpath(checkNil && !cls)) return nil;
    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));
}

4. _objc_rootAllocWithZone方法

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

5. _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;

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

6. cls->instanceSize & calloc & obj->initInstanceIsa

① cls->instanceSize：先计算出需要的内存空间大小

首先判断是否有缓存，有的话采用内存对齐方法计算所需内存大小

如果没有缓存，则计算内存大小，如果size 小于 16，最小取16

size_t instanceSize(size_t extraBytes) const {
    if (fastpath(cache.hasFastInstanceSize(extraBytes))) { // // 判断是否有缓存
        return cache.fastInstanceSize(extraBytes); // 内存对齐
    }
     // 计算类中所有属性的大小 + 额外的字节数0
    size_t size = alignedInstanceSize() + extraBytes; 
    // 如果size 小于 16，最小取16
    if (size < 16) size = 16;
    return size;
}

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方法：内存对齐方法

static inline size_t align16(size_t x) {
    return (x + size_t(15)) & ~size_t(15);
}

内存对齐算法：

假设传入的参数： x = 8
x + size_t(15) = 8 + 15 = 23
x + size_t(15) 二进制：
0000 0000 0001 0111 = 23
size_t(15) 二进制：
0000 0000 0000 1111 = 15
~size_t(15) :
1111 1111 1111 0000
x + size_t(15) & ~size_t(15)：0000 0000 0001 0000 = 16

所以返回值 (x + size_t(15)) & ~size_t(15) = 16（原始值：8）也就是 16 的倍数对齐，即 16 字节对齐

② calloc：向系统申请开辟内存,返回地址指针
通过instanceSize计算的内存大小，向内存中申请大小为 size的内存，并赋值给obj，因此obj是指向内存地址的指针

// alloc 开辟内存的地方
obj = (id)calloc(1, size);

这里我们可以通过断点来印证上述的说法，在未执行calloc时，po obj为nil，执行后，再po obj发现，返回了一个16进制的地址

未执行calloc和执行calloc后

在平常的开发中，一般一个对象的打印的格式都是类似于这样的（是一个指针）。为什么这里不是呢？

主要是因为objc地址还没有与传入的cls进行关联
同时印证了alloc的根本作用就是开辟内存

③ obj->initInstanceIsa：关联到相应的类

执行initInstanceIsa后

7. 总结

根据源码调试方法，我们会得到alloc方法的执行流程如下：

alloc流程.png