iOS中OC对象alloc分析

首先我们先看下alloc创建对象的一个整体流程图：

alloc流程 (1).png

1. 如何分析 alloc 方法的执行流程

1.1 通过符号断点分析

首先我们在alloc方法调用的地方打上断点，待程序运行到改行时，按住 ctrl键，同时数遍点击 xcode底部的 Debug窗口的 step into即可进入。具体方法如下图所示：

QQ20210605-231939@2x.png
注意：一定要在程序运行到alloc方法的时候，在enable符号断点，否者程序运行时创建的类，会反复hit这个符号断点

1.2 直接阅读汇编代码

通过设置Always Show Disassembly阅读程序的汇编代码，分析alloc的执行流程。具体方法： 点击xcode顶部的Debug菜单，选择Debug Workflow,勾选Always Show Disassembly。打上断点，重新运行程序，将直接进入汇编代码窗口。此方法可结合符号断点，快速定位到相关的方法。

323191622906873_.pic_hd.jpg

1.3 通过编译源码

此方法，相较于阅读汇编代码，对于我个人而言比较简单，也比较直观，但源码的编译过程比较繁琐，问题比较多，需要很多耐心去解决相关的问题。想走捷径的同学可以去这里下载相关的代码：Github。如果想尝试下自己编辑源代码，可以去这里下载objc4源码，opensource

可能会遇到的问题：

1.3.1 设置了断点却无法触发

选择 Target -> Build Phases -> Compile Sources将 main.m文件移动到最前面。

QQ20210605-234044@2x.png

1.3.1 断点生效了,但是无法进入alloc方法的实现

选择 Target -> Build Setting -> Enable Hardened Runtime将其设置为Yes

QQ20210605-234343@2x.png

2. alloc方法分析

首先会调用：

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

再次进入会调用：

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

再次进入会调用：

static ALWAYS_INLINE id callAlloc(Class cls, bool checkNil, bool allocWithZone=false)
{
#if __OBJC2__
    if (slowpath(checkNil && !cls)) return nil;
    // 这里的if判断的是当前类或者父类有没有实现alloc/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));
}

点击_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就进入了真在的核心方法。

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 {
        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);// isa指针跟cls关联起来
    } 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);
}

三个核心的方法：

instanceSize: 先计算出需要的内存空间大小

   inline 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;
    }
    // 快速计算
    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;
            // 字节对齐
            return align16(size + extra - FAST_CACHE_ALLOC_DELTA16);
        }
    }

    // 计算类中变量所需的大小
    uint32_t alignedInstanceSize() const {
        return word_align(unalignedInstanceSize());
    }
       
       // 最后调用 align16 方法，进行字节对齐，返回值必然是16的倍数
       // 这个方法写的很巧妙、优雅，值得学习，深究
    static inline size_t align16(size_t x) {
        return (x + size_t(15)) & ~size_t(15);
    }
    

calloc: 向系统申请开辟内存,返回地址指针

由instanceSize计算出所需的内存空间大小后，交由系统去开辟相应的内存空间大小。首先我们通过断点可以看出，obj在创建的时候就分配一块脏地址。

QQ20210606-011151@2x.png

经过调用calloc方法以后，开辟相应的内存空间，但这时候还并未与相应的类关联起来

QQ20210606-011503@2x.png

initInstanceIsa: 关联到相应的类

image.png

通过断点的可以看到，initInstanceIsa调用以后，已经将isa指针与相应的类关联起来。最终返回obj,至此alloc的流程基本调用完毕。

3. 总结

通过以上的分析，我们可以得出调用alloc方法以后，会开辟出相应大小的内存空间。而调用init方法，会将相应的地址指向该内存空间。代码验证：

     Person *p1 = [Person alloc];
     Person *p2 = [p1 init];
     Person *p3 = [p1 init];
     NSLog(@"%@-%p", p1, &p1); // <Person: 0x10103f560>-0x7ffeefbff440
     NSLog(@"%@-%p", p2, &p2); // <Person: 0x10103f560>-0x7ffeefbff428
     NSLog(@"%@-%p", p3, &p3); // <Person: 0x10103f560>-0x7ffeefbff430

     Person *p4 = [Person alloc];
     NSLog(@"%@-%p", p4, &p4); // <Person: 0x1014457b0>-0x7ffeefbff438