OC底层原理--创建对象(alloc&init&new)都干了啥

alloc源码分析

本次探索主要基于objc4-781源码进行分析

首先,通过断点调试源码的方式绘制自定义对象执行alloc操作的整体流程如下图所示:

alloc流程图.png

接下来,我们看下每一步具体做了什么

第一步: 进入callAlloc方法,直接执行return ((id(*)(id, SEL))objc_msgSend)(cls, @selector(alloc));

// Call [cls alloc] or [cls allocWithZone:nil], with appropriate 
// shortcutting optimizations.
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));
}

其中关于 slowpath 和 fastpath 这里需要简要说明下，这两个都是 objc 源码中定义的宏，其定义如下

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

其中的__builtin_expect指令是由gcc引入的，
1、目的：编译器可以对代码进行优化，以减少指令跳转带来的性能下降。即性能优化
2、作用：允许程序员将最有可能执行的分支告诉编译器。
3、指令的写法为：__builtin_expect(EXP, N)。表示 EXP==N 的概率很大。
4、fastpath 定义中 __builtin_expect((x),1) 表示 x 的值为真的可能性更大；即执行 if 里面语句的机会更大
5、slowpath 定义中的 __builtin_expect((x),0) 表示 x 的值为假的可能性更大。即执行 else 里面语句的机会更大

第二步: 调用 alloc 方法,方法实现如下

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

第三步: 调用 _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 方法,具体实现第一步已给出,不过这里 callAlloc 内部走的是 fastpath 中的 return _objc_rootAllocWithZone(cls, nil);

第五步: 调用 _objc_rootAllocWithZone 方法,方法具体实现如下:

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

第六步: 调用 _class_createInstanceFromZone 方法,具体实现如下:

/***********************************************************************
* class_createInstance
* fixme
*  Locking: none
*
* Note: this function has been carefully written so that the fastpath
* takes no branch.
**********************************************************************/
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);
      } 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 的最核心的三个步骤:计算内存大小,申请内存以及将内存地址与对象进行关联

计算内存大小: size = cls->instanceSize(extraBytes);

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

申请内存: calloc ,返回值 obj 为具体内存地址
```
obj = (id)calloc(1, size);
```

将内存地址与对象进行关联

obj->initInstanceIsa(cls, hasCxxDtor);

  这一步主要是创建 isa 指针,并将 isa 指针指向申请的内存地址,然后与cls(LYPerson)类进行关联

至此,alloc的整个流程我们已经基本了解了,接下来我们看下 init 做了哪些操作

`init` 源码分析

依然是通过断点跳转至源码具体实现,我们发现 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都是直接返回了对象本身,那么苹果这么做用意何在呢?

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

至此,对于 init 的原理我们也有了了解,那么最后让我们来看一下new具体做了哪些操作

`new` 源码分析

依然是通过断点跳转至源码具体实现,我们发现 new 的操作异常简单,具体如下:

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

过源码可以得知，new 函数中直接调用了 callAlloc 函数（即 alloc 中分析的函数），且调用了 init 函数，所以可以得出 new 其实就等价于 [alloc init] 的结论

但是一般开发中并不建议使用 new ，主要是因为有时会重写 init 方法做一些自定义的操作，而用 new 初始化时调用的是 NSObject 的 init 方法.这种时候就可能会出现无法走到自定义 init 的部分

总结

通过源码调试的方式我们已经了解了对象创建过程中 alloc init new 分别做了哪些东西.了解了这些原理之后可以帮助我们后续更好的理解对象.最后稍微总结下关键点:

slowpath 和 fastpath 写法主要是为了实现编译器优化
对象创建过程的关键三步分别是:计算内存大小,申请内存以及将内存地址与对象进行关联
计算内存大小的时候涉及到内存对齐,以16位进行对齐
init 主要是提供构造函数的入口,不做其他操作
new 中的 init 方法是默认调用的,所以实现了 initWith** 方法的类调用 new 方法时无法调用自定义的内容

OC底层原理--创建对象(alloc&init&new)都干了啥

alloc源码分析

init 源码分析

new 源码分析

总结

`init` 源码分析

`new` 源码分析