image

我们在日常开发中经常会用到类似于下面的一段代码来创建对象：

Person *p = [[Person alloc] init];

大家可以很明显的注意到，创建一个对象，需要经历alloc和init两个方法的调用才能实现。那么今天我们就来探索其中的alloc究竟做了什么。

其实作为iOS开发者，大家很清楚，alloc是用来给对象开辟内存的。那么究竟是怎么开辟内存的呢？这是我们今天探索的重点。
首先我们要下载objc4的源码，尽量下载最新的版本的。
其次，下载下来的源码是不能编译的，这里给大家推荐一篇文章，iOS_objc4-756.2 最新源码编译调试。大家可以参考这篇文章编译自己的源码。

alloc源码探索

1、创建Person对象，如下：

image

• 「第一步」进入alloc函数的源码：

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

• 「第二步」在alloc源码中，我们会发下，函数进入了_objc_rootAlloc，我们跟进去查看：

// Base class implementation of +alloc. cls is not nil.
// Calls [cls allocWithZone:nil].
id
_objc_rootAlloc(Class cls)
{
    return callAlloc(cls, false/*checkNil*/, true/*allocWithZone*/);
}

• 「第三步」同样的操作，我们进入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));
}

这个时候，就有点懵了，源码中出现了不同的分支。这个时候就需要我们进行断点调试了。

在断点调试之前，我们首先来搞清楚callAlloc方法里面几个关键判断的意思。
1、 hasCustomAWZ。
首先我们跟进hasCustomAWZ，发现其源码实现是这样的：

bool hasCustomAWZ() const {
        return !cache.getBit(FAST_CACHE_HAS_DEFAULT_AWZ);
    }

接着我们继续跟进FAST_CACHE_HAS_DEFAULT_AWZ，此时我们发现了我们先要的（注意源码注释）：

// class or superclass has default alloc/allocWithZone: implementation
// Note this is is stored in the metaclass.
#define FAST_CACHE_HAS_DEFAULT_AWZ    (1<<14)

也就是说cls->ISA()->hasCustomAWZ()是用来获取类或父类中，是否有alloc/allocWithZone:的实现。（很显然，此时我们的Person并没有）

2、 我们知道了fastpath函数的参数是什么意思，下面我们就要看fastpath是什么意思了。

我们跟进入发现：

#define fastpath(x) (__builtin_expect(bool(x), 1))
#define slowpath(x) (__builtin_expect(bool(x), 0))

fastpath&slowpath是两个objc源码中定义的宏。
调用的都是__builtin_expect。

__builtin_expect(bool exp, probability)的主要作用是进行条件分支预测。
函数主要有两个参数：
第一个参数：是一个布尔表达式
第二个参数：表明第一个参数为真值的概率，这个参数只能是1或0；当取值为1时，表示布尔表达式大部分情况下的值为真值；当取值为0时，表示布尔表达式大部分情况下的值是假值。
函数的返回值，就是第一个参数的表达式的值。

那也就是说fastpath(!cls->ISA()->hasCustomAWZ())的结果，其实就是!cls->ISA()->hasCustomAWZ()的结果。那么「第四步」就是进入if里面的_objc_rootAllocWithZone。（这一点根据断点调试也可以判断出来）

3、这里还有一个判断__OBJC2__
在源码中，点不进去，无法知道这个宏定义是干什么用的。但是我们可以根据下面的一段注释来判断大致意思：

image

• 「第四步」_objc_rootAllocWithZone

NEVER_INLINE
id
_objc_rootAllocWithZone(Class cls, malloc_zone_t *zone __unused)
{
    // allocWithZone under __OBJC2__ ignores the zone parameter
    // __OBJC2__ 下的 allocWithZone 忽略 zone 参数
    return _class_createInstanceFromZone(cls, 0, nil,
                                         OBJECT_CONSTRUCT_CALL_BADALLOC);
}

• 「第五步」_class_createInstanceFromZone

_class_createInstanceFromZone是alloc整个流程的核心。

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)
{
    // 'Realized' --> '实现'
    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;

    // 计算需要开辟的内存大小，根据上一个函数`_objc_rootAllocWithZone`可以知道，此时‘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 {
        // 同样的根据`_objc_rootAllocWithZone`可以知道，`__OBJC2__`情况下，会进入这里。
        // calloc --> 申请内存，大小为`size`.
        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(类) 与 objc指针(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);
}

在整个_class_createInstanceFromZone中，最主要的是以下三个步骤：

• size = cls->instanceSize(extraBytes);计算需要开辟的内存大小。
• obj = (id)calloc(1, size);申请内存
• obj->initInstanceIsa(cls, hasCxxDtor);关联类和isa指针。

• 「第六步」object_cxxConstructFromClass
  该函数的源码也非常容易理解，因为官方的注释给的很清楚。这里就截取关键部分，不再展示完整的源码。
  
  image
  
  可以看到object_cxxConstructFromClass的返回值，如果是self就表示构建成功；
  如果是nil就表示构建失败。

alloc流程图

通过上面的探索，我们总结出alloc函数的调用流程图如下：

image

Tips

上面我们探索了alloc的流程，里面有几个知识点，这里我们扩充一下：

1: 字节对齐 && 内存对齐

这就是在_class_createInstanceFromZone中的size = cls->instanceSize(extraBytes);。
这里我们们进入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;
}
```

在没有缓存的情况下，我们会调用alignedInstanceSize()，那么我们就跟进去：

```
// Class's ivar size rounded up to a pointer-size boundary.
// 类的 ivar 大小向上舍入到指针大小边界
uint32_t alignedInstanceSize() const {
    return word_align(unalignedInstanceSize());
}
```

这里我们看一下unalignedInstanceSize()的返回值是多少，跟进去我们发现，该返回值的大小由实例变量的大小决定，依赖于成员变量(ivars)：

```
// May be unaligned depending on class's ivars.
uint32_t unalignedInstanceSize() const {
    ASSERT(isRealized());
    return data()->ro()->instanceSize;
}
```

此时，我们的Person没有自定义的成员变量，但是，返回值是8；这是因为NSObject本身有一个isa。如下：

image

image

同时objc_class继承自最原始的objc_object:

image

• 字节的对齐是 --- 8字节对齐
  这一点我们进入word_align函数就能够知道：
  
  image
  
  注意WORD_MASK为7，根据算法，word_align返回值，永远是8的倍数。

算法讲解：
首先我们知道此时：x = 8 && WORD_MASK = 7；
那么函数中的计算公式就是：(8 + 7) & ~7 也就是 15 & ~7。
15的二进制是 ---> 0000 1111。
7的二进制是 ---> 0000 0111，那么~7为 ---> 1111 1000。
那么15 & ~7 就是 0000 1111 & 1111 1000，结果为0000 1000 == 8

• 内存对齐是 --- 16字节对齐
  在instanceSize中，如果有缓存，会调用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);
}

这个也不难理解，算法跟上面字节对齐的算法是一样的。但是这里保证的返回值是16的倍数。

2: __builtin_expect(bool exp, probability)

这个函数我们在上面已经简单介绍过了，这里我们再来详细的介绍一下（参考文章：LLVM编译器中的内置(built-in)函数）：
这个函数的主要作用是进行条件分支预测。函数主要有两个参数：第一个参数是布尔表达式、第二个参数表明第一个参数的值为真值的概率，这个参数只能取1或0。

当取值为1时，表示布尔表达式大部分情况下的值是真值，而取值为0时，表示布尔表达式大部分情况下的值是假值。

函数的返回值就是第一个参数的表达式的值。

在一条指令执行时，由于流水线的作用，CPU可以完成下一条指令的取值，这样可以提高CPU的利用率。在执行一条条分支指令时，CPU也会预取下一条执行，但是如果条件分支跳转到其他指令，那么CPU预取的下一条指令就没用了，这样就降低了流水线的效率。__builtin_expect函数可以优化程序编译后的指令序列，使指令尽可能的顺序执行，从而提高CPU预取指令的正确率。
例如：

if (__builtin_expect (x, 0))
    foo();

表示：x的值大部分情况下可能为假，因此foo()函数得到执行的机会比较少。这样编译器在编译这段代码的时候，就不会将foo()函数的汇编指令紧挨着if条件跳转指令。
再比如：

if (__builtin_expect (x, 1))
    foo();

表示：x的值大部分情况下可能为真，因此foo()函数得到执行的机会比较大。这样编译器在编译这段代码的时候，就会将foo()函数的汇编指令紧挨着if条件跳转指令。

为了简化函数使用，iOS系统使用两个宏fastpath和slowpath来实现这种分支优化判断处理：

#define fastpath(x) (__builtin_expect(bool(x), 1))
#define slowpath(x) (__builtin_expect(bool(x), 0))