引言

当我们创建一个对象的时候比如: [[Person alloc] init] alloc 到底做了什么 init到底做了什么 ? 这就是这篇文档要给大家分享的一些个人见解,希望大家多提意见,共同学习.

探索路程

如下图直接上代码

001.png

上述代码说明p1,p2,p3指向了相同的内存地址,init并没有创建空间真正申请空间的是alloc申请了空间.

%p -> &p1：是对象的指针地址，
%p -> p1：是对象指针指向的的内存地址

由p1,p2,p3的指针地址推断，栈内存是连续的（0x30 + 0x08 = 0x38, 0x28 + 0x08 = 0x30 [这里是16进制运算]），并且所占内存都是8字节（指针占内存8字节）

002.png

源码探索

要想知道alloc到底做了什么事我们需要知道他的源码里面到底怎么实现的,由于苹果API是点不进去的我们只能根据符号断点或者其他方法去探索我们可以从网上下载他的源码去分析.

苹果开源库：
1：https://opensource.apple.com/source 所以开源库都在里面，包括各个老版本
2：https://opensource.apple.com 可以根据系统版本选择更新的下载
3 : 编译源码，可参考https://github.com/LGCooci/objc4_debug

999

知道哪里下载库了，那我们怎么知道alloc属于哪个库呢？
这里为大家提供3个方法，供参考
方法一：下符号断点的形式直接跟流程
下符号断点的方法如图

003.png

方法二：Ctrl + step into

004

按住Ctrl，多点几次下一步，来到了 objc_alloc

005

把objc_alloc作为符号断点，加上的一瞬间就又找到了libobjc.A.dylib

006

方法三：汇编查看跟流程（最常用的）
Debug -> Debug Workflow -> Always Show Disassembly 进入汇编

007

得到 objc_alloc

008

用方法二下符号断点又可以拿到libobjc.A.dylib

找到源码库libobjc.A.dylib 即 objc4

下载源码+编译源码请移步到 iOS_objc4-781.2 最新源码编译调试

打开源码工程，开始alloc源码探索

通过 command + 鼠标左键一步一步进入源码看流程

如下图 NSObject 和它的子类是有点区别的 NSObject 没走alloc只走了一次callAlloc是因为系统帮我们做了(alloc底层会被hook去调用objc_alloc,所以先走objc_alloc再走alloc) MyNSObject走了两次callAlloc 第二次才是真正的去开辟空间.

666

444

所以可以看到在调用NSObject *objc = [NSObject alloc];时，其实调用的是objc中的objc_alloc方法。

二、OC 的 alloc 深入探究

经过上面一步，我们就能浅尝辄止吗？当然不能；所以我搞来一份objc4源码继续我们的探究。
看到源码 NSObject.mm 文件，里面的alloc方法

image

他会调用_objc_rootAlloc

image

问题：
我上面看到 [NSObject alloc]看到的不是会到objc_alloc来吗？怎么源码分析的到了_objc_rootAlloc？
答：我们知道OC代码有运行时的特点，即方法的调用不是在编译时确定的，而是运行时，不懂的补一下编译原理。我们在objc运行时源码中查找objc_alloc，发现如下的代码

static void 
fixupMessageRef(message_ref_t *msg)
{    
    msg->sel = sel_registerName((const char *)msg->sel);

    if (msg->imp == &objc_msgSend_fixup) { 
        if (msg->sel == @selector(alloc)) {
            msg->imp = (IMP)&objc_alloc;
        } else if (msg->sel == @selector(allocWithZone:)) {
            msg->imp = (IMP)&objc_allocWithZone;
        } else if (msg->sel == @selector(retain)) {
            msg->imp = (IMP)&objc_retain;
        } else if (msg->sel == @selector(release)) {
            msg->imp = (IMP)&objc_release;
        } else if (msg->sel == @selector(autorelease)) {
            msg->imp = (IMP)&objc_autorelease;
        } else {
            msg->imp = &objc_msgSend_fixedup;
        }
    } 
    else if (msg->imp == &objc_msgSendSuper2_fixup) { 
        msg->imp = &objc_msgSendSuper2_fixedup;
    } 
    else if (msg->imp == &objc_msgSend_stret_fixup) { 
        msg->imp = &objc_msgSend_stret_fixedup;
    } 
    else if (msg->imp == &objc_msgSendSuper2_stret_fixup) { 
        msg->imp = &objc_msgSendSuper2_stret_fixedup;
    } 
#if defined(__i386__)  ||  defined(__x86_64__)
    else if (msg->imp == &objc_msgSend_fpret_fixup) { 
        msg->imp = &objc_msgSend_fpret_fixedup;
    } 
#endif
#if defined(__x86_64__)
    else if (msg->imp == &objc_msgSend_fp2ret_fixup) { 
        msg->imp = &objc_msgSend_fp2ret_fixedup;
    } 
#endif
}

发现消息发送时，当msg->imp == &objc_msgSend_fixup 进行了方法实现(IMP)的替换。

什么时候msg->imp == &objc_msgSend_fixup成立还没有确定的探究，后续了解会进一步更新。从源码的运行看[NSObject alloc]会走到objc_alloc；但是其子类的[LGPerson alloc]会调用_objc_rootAlloc

不管是_objc_rootAlloc或者objc_alloc从图4看都会进入callAlloc这个函数,不过最后两个参数不同；我们姑且往下走,进入callAlloc去看看究竟。代码如下

image

这里看到有两个宏定义函数:slowpath, fastpath. 这两个函数是用于编译器优化；slowpath低概率会走;fastpath大概率会走,如果项目中有需求，自己也可以用上，让自己的代码质量提高。
hasCustomAWZ是否有自定义的AWZ；经过运行实际得出，当类的第一次运行时slowpath，fastpath判断都为false,后面在运行时fastpath为true;不过我们看到下面的函数又是消息的发送，调用的是alloc和allocWithZone，其实接着往下走，可以发现，他又回到了callAlloc,并且此时的fastpath为true;

那么函数此时应来到_objc_rootAllocWithZone

unsigned 
class_createInstances(Class cls, size_t extraBytes, 
                      id *results, unsigned num_requested)
{
    return _class_createInstancesFromZone(cls, extraBytes, nil, 
                                          results, num_requested);
}

那么我们去看看_class_createInstancesFromZone

unsigned
_class_createInstancesFromZone(Class cls, size_t extraBytes, void *zone, 
                               id *results, unsigned num_requested)
{
    unsigned num_allocated;
    if (!cls) return 0;

    size_t size = cls->instanceSize(extraBytes);

    num_allocated = 
        malloc_zone_batch_malloc((malloc_zone_t *)(zone ? zone : malloc_default_zone()), 
                                 size, (void**)results, num_requested);
    for (unsigned i = 0; i < num_allocated; i++) {
        bzero(results[i], size);
    }

    // Construct each object, and delete any that fail construction.

    unsigned shift = 0;
    bool ctor = cls->hasCxxCtor();
    for (unsigned i = 0; i < num_allocated; i++) {
        id obj = results[i];
        obj->initIsa(cls);    // fixme allow nonpointer
        if (ctor) {
            obj = object_cxxConstructFromClass(obj, cls,
                                               OBJECT_CONSTRUCT_FREE_ONFAILURE);
        }
        if (obj) {
            results[i-shift] = obj;
        } else {
            shift++;
        }
    }

    return num_allocated - shift;    
}

这里的逻辑大体分为

1、求出实例所需内存大小

size_t size = cls->instanceSize(extraBytes);

2、分配空间

num_allocated = 
        malloc_zone_batch_malloc((malloc_zone_t *)(zone ? zone : malloc_default_zone()), 
                                 size, (void**)results, num_requested);

3、绑定isa到类

obj->initIsa(cls);    // fixme allow nonpointer

接下来返回对应类的首地址

内存分配分析

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;
    1:根据字节对齐机制计算出相关的分配所需内存空间的大小
    size = cls->instanceSize(extraBytes);
    if (outAllocatedSize) *outAllocatedSize = size;

    id obj;
    if (zone) {
        obj = (id)malloc_zone_calloc((malloc_zone_t *)zone, 1, size);
    } else {
       2 ： 根据第一步计算所需空间，向系统开辟内存
        obj = (id)calloc(1, size);
    }
    if (slowpath(!obj)) {
        if (construct_flags & OBJECT_CONSTRUCT_CALL_BADALLOC) {

         3：根据分配的内存情况管理对象
            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：计算相关内存大小

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

根据断点我们能进入到 return cache.fastInstanceSize(extraBytes);这里，再次进入代码到

  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字节对齐的方式，如果分配小于16字节，就直接等于16字节。所以此时的size 是16，
align16(size + extra - FAST_CACHE_ALLOC_DELTA16);

size : 16字节对齐，此时是16，
extra :是系统计算的额外信息，根据断点此时是0，
FAST_CACHE_ALLOC_DELTA16：是宏定义：此时是8

image

所以结合最终返回的align16的值是 align16(8)

我们在此进入align16的定义函数

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

此处代码的意思就是，上一步计算结果的值加上15，和15的值取反过后再进行 按位与操作，
什么意思呢：例如上一步我们计算的结果是8，再加上15 结果等于23，23在内存中的标识是这样的

0000 0000 0001 0111

15的内存表示

0000 0000 0000 1111

15取反操作的值是

1111 1111 1111 0000

所以按位与的操作就是 23 & ~15

0000 0000 0001 0111
1111 1111 1111 0000
0000 0000 0001 0000（结果）十进制的16

如果是内存分配大于16 的，比如 20 加上15表示成 35，内存表示（0000 0000 0010 0011）
按位与操作是 35 & ~15

0000 0000 0010 0011
1111 1111 1111 0000
0000 0000 0010 0000(结果) 十进制的32，

所以这就是16字节对齐的核心机制，相信我已经介绍的够清晰了，这就是iOS内存分配的最新机制。

步骤2 ：分配内存

根据计算的内存size_t size 进行内存的分配，

image

步骤3 关联对象类型

通过InitInstanceIsa 方法进行关联类对象实例，

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

    initIsa(cls, true, hasCxxDtor);
}

objc_object::initIsa(Class cls, bool nonpointer, bool hasCxxDtor) 
{ 
    ASSERT(!isTaggedPointer()); 

    if (!nonpointer) {
        isa = isa_t((uintptr_t)cls);
    } else {
        ASSERT(!DisableNonpointerIsa);
        ASSERT(!cls->instancesRequireRawIsa());

        isa_t newisa(0);

#if SUPPORT_INDEXED_ISA
        ASSERT(cls->classArrayIndex() > 0);
        newisa.bits = ISA_INDEX_MAGIC_VALUE;

        // isa.magic is part of ISA_MAGIC_VALUE
        // isa.nonpointer is part of ISA_MAGIC_VALUE
        newisa.has_cxx_dtor = hasCxxDtor;
        newisa.indexcls = (uintptr_t)cls->classArrayIndex();
#else
        newisa.bits = ISA_MAGIC_VALUE;
        // isa.magic is part of ISA_MAGIC_VALUE
        // isa.nonpointer is part of ISA_MAGIC_VALUE
        newisa.has_cxx_dtor = hasCxxDtor;
        newisa.shiftcls = (uintptr_t)cls >> 3;
#endif

        isa = newisa;
    }
}

总结

这就是 alloc 的完整流程；
通过ISA的关联，我们就完成了一个对象的内存分配情况，也就是一个对象的alloc 的完整流程，因为任何一个类对象都可以通过ISA指针找到相应的父类，以及元类，这样对象的各种初始化实例方法都能通过ISA指针指向找到相应的IMP。从而调用方法进行消息转发。

666

这就是alloc的大致流程

init 源码探索

alloc源码探索完了，接下来探索init源码，通过源码可知，inti的源码实现有以下两种

类方法 init

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

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

实例方法 init

通过以下代码进行探索实例方法 init

LGPerson *objc = [[LGPerson alloc] init];

通过main中的init跳转至init的源码实现

- (id)init {
    return _objc_rootInit(self);
}

跳转至_objc_rootInit的源码实现

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

有上述代码可以，返回的是传入的self本身。

new 源码探索

一般在开发中，初始化除了init，还可以使用new，两者本质上并没有什么区别，以下是objc中new的源码实现，通过源码可以得知，new函数中直接调用了callAlloc函数（即alloc中分析的函数），且调用了init函数，所以可以得出new 其实就等价于 [alloc init]的结论

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

但是一般开发中并不建议使用new，主要是因为有时会重写init方法做一些自定义的操作，例如 initWithXXX，会在这个方法中调用[super init]，用new初始化可能会无法走到自定义的initWithXXX部分。

例如，在CJLPerson中有两个初始化方法，一个是重写的父类的init，一个是自定义的initWithXXX方法，如下图所示

image

使用 alloc + init 初始化时，打印的情况如下

image
使用new 初始化时，打印的情况如下

image

总结

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

谢谢你的阅读!

链接：https://www.jianshu.com/p/b72018e88a97
推荐参考:https://www.jianshu.com/p/dbba973c7446

iOS-alloc底层做了什么流程分析

iOS-alloc底层做了什么流程分析

引言

探索路程

源码探索

打开源码工程，开始alloc源码探索

二、OC 的 alloc 深入探究

内存分配分析

步骤1：计算相关内存大小

步骤2 ：分配内存

步骤3 关联对象类型

总结

init 源码探索

new 源码探索