iOS-底层原理|iOS-底层原理 02（alloc & init & new 源码分析） iOS-底层原理02：alloc&init&new源码

在分析alloc源码之前，先来看看一下3个变量指针和内存地址区别：

文章图片
如图所示分别输出3个对象的内容、指针地址、对象地址，下图是打印结果

文章图片
如图所示结论：通过上图可以看出，可以发现三个对象的指针地址是不一致的；
因此我们可以知道，alloc 会去申请 Person 对象的一块内存空间，然后会用一个指针来指向这块申请的内存空间，即 p1，而 init 不会对申请的内存空间做任何的操作，而是指向申请的同一片内存空间。

文章图片

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

这就是本文需要探索的内容，alloc做了什么？init做了什么？
准备工作

下载 objc4-781 源码
编译源码，可参考objc4-781 源码编译 & 调试

alloc 源码探索,通过汇编探索流程 alloc + init 整体源码的探索流程如下

iOS-底层原理|iOS-底层原理 02（alloc & init & new 源码分析）

文章图片
alloc流程

1、找到 alloc 方法，发现 alloc 方法中调用了 _objc_rootAlloc 方法

//alloc源码分析-第一步 + (id)alloc { return _objc_rootAlloc(self); }

2、_objc_rootAlloc 中调用了 callAlloc 方法

//alloc源码分析-第二步 id _objc_rootAlloc(Class cls) { return callAlloc(cls, false/*checkNil*/, true/*allocWithZone*/); }

3、callAlloc 中会调用 _objc_rootAllocWithZone 和 objc_msgSend

static ALWAYS_INLINE id callAlloc(Class cls, bool checkNil, bool allocWithZone=false)// alloc 源码第三步 { #if __OBJC2__ //有可用的编译器优化 /* 参考链接：https://www.jianshu.com/p/536824702ab6 */// checkNil 为false，!cls 也为false ，所以slowpath 为 false，假值判断不会走到if里面，即不会返回nil 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)); }

如上所示，在calloc方法中，当我们无法确定实现走到哪步时，可以通过断点调试，判断执行走哪部分逻辑。这里是执行到_objc_rootAllocWithZone
slowpath & fastpath 其中关于slowpath和fastpath这里需要简要说明下，这两个都是objc源码中定义的宏，其定义如下

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

上面是 callAllco 方法的源码实现，其中 if 语句中用到了 slowpath 和 fastpath，这是苹果编译器优化的结果。一般我们打包 release 版本的时候，会自动勾选上编译器优化选项。

4、在 _objc_rootAllocWithZone 中会调用 _class_createInstanceFromZone 方法

id _objc_rootAllocWithZone(Class cls, malloc_zone_t *zone __unused)// alloc 源码第四步 { // allocWithZone under __OBJC2__ ignores the zone parameter //zone 参数不再使用类创建实例内存空间 return _class_createInstanceFromZone(cls, 0, nil, OBJECT_CONSTRUCT_CALL_BADALLOC); }

5、在 _class_createInstanceFromZone 中才是实现了主要的功能, 这部分是alloc源码的核心操作，由下面的流程图及源码可知，该方法的实现主要分为三部分
- cls->instanceSize：计算需要开辟的内存空间大小
- calloc：申请内存，返回地址指针
- obj->initInstanceIsa：将类与 isa 关联

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)// alloc 源码第五步 { 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; //计算需要开辟的内存大小，传入的extraBytes 为 0 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) { //将 cls类与 obj指针（即isa）关联 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); }

alloc 核心操作 1.instanceSize 方法：计算所需内存大小

1、跳转至instanceSize的源码实现

size_t instanceSize(size_t extraBytes) const { //编译器快速计算内存大小 if (fastpath(cache.hasFastInstanceSize(extraBytes))) { return cache.fastInstanceSize(extraBytes); }// 计算类中所有属性的大小 + 额外的字节数0 size_t size = alignedInstanceSize() + extraBytes; // CF requires all objects be at least 16 bytes. //如果size 小于 16，最小取16 if (size < 16) size = 16; return size; }

通过断点调试，会执行到cache.fastInstanceSize方法，快速计算内存大小

2、跳转至fastInstanceSize的源码实现，通过断点调试，会执行到align16

size_t fastInstanceSize(size_t extra) const { ASSERT(hasFastInstanceSize(extra)); //Gcc的内建函数 __builtin_constant_p 用于判断一个值是否为编译时常数，如果参数EXP 的值是常数，函数返回 1，否则返回 0 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 //删除由setFastInstanceSize添加的FAST_CACHE_ALLOC_DELTA16 8个字节 return align16(size + extra - FAST_CACHE_ALLOC_DELTA16); } }

3、跳转至align16的源码实现，这个方法是16字节对齐算法

//16字节对齐算法 static inline size_t align16(size_t x) { return (x + size_t(15)) & ~size_t(15); }

为什么需要16字节对齐需要字节对齐的原因，有以下几点：

通常内存是由一个个字节组成的，cpu在存取数据时，并不是以字节为单位存储，而是以块为单位存取，块的大小为内存存取力度。频繁存取字节未对齐的数据，会极大降低cpu的性能，所以可以通过减少存取次数来降低cpu的开销
16字节对齐，是由于在一个对象中，第一个属性isa占8字节，当然一个对象肯定还有其他属性，当无属性时，会预留8字节，即16字节对齐，如果不预留，相当于这个对象的isa和其他对象的isa紧挨着，容易造成访问混乱
16字节对齐后，可以加快CPU读取速度，同时使访问更安全，不会产生访问混乱的情况

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

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

3.obj->initInstanceIsa：类与isa关联经过calloc可知，内存已经申请好了，类也已经传入进来了，接下来就需要将类与地址指针即isa指针进行关联，其关联的流程图如下所示

文章图片
如图所示主要过程就是初始化一个isa指针，并将isa指针指向申请的内存地址，在将指针与cls类进行关联
同样也可以通过断点调试来印证上面的说法，在执行完initInstanceIsa后，在通过po obj可以得出一个对象指针

文章图片
init 方法 alloc源码探索完了，接下来探索init源码，通过源码可知，inti的源码实现有以下两种类方法 init 和实例方法 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强转的原因，主要还是因为内存字节对齐后，可以使用类型强转为你所需的类型
new 方法一般在开发中，初始化除了init，还可以使用new，两者本质上并没有什么区别，以下是objc中new的源码实现，通过源码可以得知，new函数中直接调用了callAlloc函数（即alloc中分析的函数），且调用了init函数，所以可以得出new 其实就等价于 [alloc init]的结论