[iOS] alloc&init源码学习记录

在开发过程中，有时会有一个疑问：alloc&init究竟做了什么？

alloc 是分配内存，init 具体干了点啥还真不是很清楚，下面通过看 objc 源码的方式，去看下 alloc&init 的底层实现。

来看下面这一段代码：

NSObject *object = [NSObject alloc];

上面这段代码其实就是开辟了一块内存空间，将这块内存空间的地址返回给了 object，我们可以在objc源码中具体看下alloc 的实现，objc 源码请自行查找。

alloc流程图如下：

未命名文件.png

在 NSObject.mm文件中，我们看到了 alloc 的实现：

1. `+ (id)alloc`

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

2. `id_objc_rootAlloc(Class cls)`

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

3.`static ALWAYS_INLINE id callAlloc(Class cls, bool checkNil, bool allocWithZone=false)`

static ALWAYS_INLINE id
callAlloc(Class cls, bool checkNil, bool allocWithZone=false)
{
// 有可用的编译器优化
#if __OBJC2__ 

// checkNil 为 false, !cls 也为 false，所以 slowpath  为 false
    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));
}

这里继续跟断点，发现走到了_objc_rootAllocWithZone方法里面。

slowpath & fastpath

这两个都是 objc 源码中定义的宏：

// 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的概率很大。

fastpath 定义中 __builtin_expect((x),1) 表示 x 的值为真的可能性很大，即执行 if 里面语句的机会更大

slowpath 定义中 __builtin_expect((x),0) 表示 x 的值为假的可能性很大，即执行 else 里面语句的机会更大

4. `id _objc_rootAllocWithZone(Class cls, malloc_zone_t *zone __unused)`

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

这里发现 zone参数没用了，内部接着调用_class_createInstanceFromZone方法了。

5.`static ALWAYS_INLINE id _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;
    // 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) {
            return _objc_callBadAllocHandler(cls);
        }
        return nil;
    }
   // 3. 将 cls 类与 obj 指针关联
    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);
    }

// 4. 返回开辟的内存的地址，也就是指向该内存的指针
    if (fastpath(!hasCxxCtor)) {
        return obj;
    }

    construct_flags |= OBJECT_CONSTRUCT_FREE_ONFAILURE;
    return object_cxxConstructFromClass(obj, cls, construct_flags);
}

上面方法中具体干了 4 件事：

计算开辟空间大小
开辟内存空间
将 cls 类与 obj 指针关联
返回内存地址的指针

该方法具体流程如下：

image.png

5.1 计算开辟空间大小

执行流程如下图所示：

image.png

5.1.1 `instanceSize`

跳转至instanceSize的源码实现：

 size_t instanceSize(size_t extraBytes) const {
        // 编译器快速计算内存大小
        if (fastpath(cache.hasFastInstanceSize(extraBytes))) {
            return cache.fastInstanceSize(extraBytes);
        }
        // 计算类中所有属性的大小 + 额外字节数 0
        size_t size = alignedInstanceSize() + extraBytes;
        // 最小为 16
        if (size < 16) size = 16;
        return size;
    }

我们可以看到：if (size < 16) size = 16;，说明开辟的内存空间最小是 16，下面，我们继续看alignedInstanceSize ()

uint32_t alignedInstanceSize() const {
        return word_align(unalignedInstanceSize());
}

alignedInstanceSize这个方法是返回字节对齐后的内存地址大小，具体包含下面两个方法：

unalignedInstanceSize()是这个对象的一些成员变量占用的大小，也是未进行字节对齐之前的内存大小，存放在data()->ro()->instanceSize，在 dyld 加载 mach-o文件时，会加载整个类的结构，也就是在那时进行赋值的，这里直接取就行了：

uint32_t unalignedInstanceSize() const {
        ASSERT(isRealized());
        return data()->ro()->instanceSize;
    }

我们新创建一个类：Person，它没有任何成员变量，但是它的 unalignedInstanceSize = 8个字节，因为继承于 NSObject，有一个isa指针，64 位下一个指针占用8 个字节。

word_align()方法，进行字节对齐:

#   define WORD_MASK 7UL
static inline uint32_t word_align(uint32_t x) {
// 先对WORD_MASK进行非 ~ 运算
// 再和(x + WORD_MASK)进行 与 & 运算
    return (x + WORD_MASK) & ~WORD_MASK;
}

这个方法主要就是进行字节对齐，向上取 8 的倍数。

通过断点调试，instanceSize方法，会执行到cache.fastInstanceSize方法，快速计算内存大小，我们去看下这个方法：

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

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

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

5.1.2 内存对齐

内存对齐原则：
数据成员对齐规则：struct 或者 union 的数据成员，第一个数据成员放在 offset 为 0 的地方，之后每个数据成员存储的起始位置要从该成员大小或者成员的子成员大小（只要该成员有子成员，比如数据、结构体等）的整数倍开始（例如int在32位机中是4字节，则要从4的整数倍地址开始存储）
数据成员为结构体：如果一个结构里有某些结构体成员，则结构体成员要从其内部最大元素大小的整数倍地址开始存储（例如：struct a里面存有struct b，b里面有char、int、double等元素，则b应该从8的整数倍开始存储）
结构体的整体对齐规则：结构体的总大小，即sizeof的结果，必须是其内部做大成员的整数倍，不足的要补齐

为什么要 16 字节对齐？
内存由一个个字节组成，cpu 在存取数据时，并不是以字节为单位进行存储，而是以块为单位存取，块的大小为内存存取粒度，通过减少存取次数来降低 cpu 开销
16字节对齐，由于一个对象中，isa 指针占 8 个字节，当没有其它属性的时候，会预留 8 个字节，即 16 字节对齐，如果不预留，相当于这个对象的isa和其他对象的isa紧挨着，容易造成访问混乱
16字节对齐后，可以加快CPU读取速度，同时使访问更安全，不会产生访问混乱的情况

以 align(8) 为例，解释下 16 字节对齐算法的过程：

image.png

首先将原始的内存 8 与size_t(15) 相加，得到 8 + 15 = 23
将 size_t(15)即 15进行~（取反）操作，~（取反）的规则是：1变为0，0变为1
• 最后将 23 与 15的取反结果进行&（与）操作，最后的结果为 16，即内存的大小是以16的倍数增加的

5.1.3 `calloc` : 申请内存，返回内存地址指针

通过instanceSize计算的内存大小，向内存中申请大小为 size的内存，并赋值给obj，因此 obj是指向一块内存的指针

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

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

这里 po obj 还是一个内存地址，是因为还没有与传入的cls进行关联
同时印证了alloc的根本作用就是开辟内存

5.2 `obj->initInstanceIsa`：类与 isa 关联

image.png

主要过程就是初始化一个isa指针，并将isa指针指向申请的内存地址，再将指针与cls类进行关联。

在obj->initIsa(cls);代码前后，我们可以分别po obj看下不同：

// 之前
(lldb) po obj
0x0000000101d21c20

// 之后
(lldb) po obj

可以明显的看到：obj 的isa指向的是 LGPerson。

6. 总结

通过对alloc源码的分析，可以得知alloc的主要目的就是开辟内存，而且开辟的内存需要使用16字节对齐算法，现在开辟的内存的大小基本上都是16的整数倍
开辟内存的核心步骤有3步：计算内存大小 -- 申请内存空间 -- 关联cls和obj的isa指针

7. `init分析`

源码如下：

// Replaced by CF (throws an NSException)
+ (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 其实就是返回了self，可能是为了方便程序猿重写 init 方法吧。

8. `new 分析`

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

看起来和上面一样，不是吗？

顺便记录下 lldb 指令：

register read xxx
寄存器读取
x p
以 16 进制打印 p 的内存占用
x/4xg p
每4 位读取 p 的内存占用

[iOS] alloc&init源码学习记录

1. + (id)alloc

2. id_objc_rootAlloc(Class cls)

3.static ALWAYS_INLINE id callAlloc(Class cls, bool checkNil, bool allocWithZone=false)

slowpath & fastpath

4. id _objc_rootAllocWithZone(Class cls, malloc_zone_t *zone __unused)

5.static ALWAYS_INLINE id _class_createInstanceFromZone

5.1 计算开辟空间大小

5.1.1 instanceSize

5.1.2 内存对齐

5.1.3 calloc : 申请内存，返回内存地址指针

5.2 obj->initInstanceIsa：类与 isa 关联

6. 总结

7. init分析

8. new 分析

你可能感兴趣的:([iOS] alloc&init源码学习记录)

1. `+ (id)alloc`

2. `id_objc_rootAlloc(Class cls)`

3.`static ALWAYS_INLINE id callAlloc(Class cls, bool checkNil, bool allocWithZone=false)`

4. `id _objc_rootAllocWithZone(Class cls, malloc_zone_t *zone __unused)`

5.`static ALWAYS_INLINE id _class_createInstanceFromZone`

5.1.1 `instanceSize`

5.1.3 `calloc` : 申请内存，返回内存地址指针

5.2 `obj->initInstanceIsa`：类与 isa 关联

7. `init分析`

8. `new 分析`