alloc&init 的源码流程图如下

iOS 底层之 alloc&init&new 的源码流程分析

首要创立Person 类， 在main函数创立Person 实例 Person *p = [Person alloc]; 1.进入到alloc 办法的源码完成

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

2.跳转到_objc_rootAlloc 源码完成

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

3.跳转至 callAlloc 的源码完成

static ALWAYS_INLINE id
callAlloc(Class cls, bool checkNil, bool allocWithZone=false)
{
#if __OBJC2__ //有可用的编译器优化
  if (slowpath(checkNil && !cls)) return nil;
    //判别是否自定义完成了 +allocWithZone 办法
  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));

该办法中有两个定义的宏

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

其中__builtin_expect指令由gcc 引进，意图：1. 编译器能够对代码进行优化，以削减指令跳转带来的功能下降，2.作用： 允许程序员将最有或许执行的分支告知编译器；3.写法为： __builtin_expect(EXP, N) , 表明 EXP == N的概率很大；

fastPath 定义的__builtin_expect(bool(x), 1) 表明x 的值为真的或许性更大；

slowpath 定义的__builtin_expect(bool(x), 0) 表明x 的值为假的或许性更大；

日常开发中能够经过设置来优化编译器，到达功能优化的意图，设置路径： Build Settiing -> Optimization Level -> Debug -> 将None 改为fastest/smallest 4.跳转至 _objc_rootAllocWithZone 的源码完成

id
_objc_rootAllocWithZone(Class cls, objc_zone_t zone __unused)
{
  // allocWithZone under __OBJC2__ ignores the zone parameter
  return _class_createInstanceFromZone(cls, 0, nil,
OBJECT_CONSTRUCT_CALL_BADALLOC);
}

5.跳转至 _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;
  size = cls->instanceSize(extraBytes);
  if (outAllocatedSize) *outAllocatedSize = size;
  id obj;
#if SUPPORT_ZONES
  // 支撑zone
  // 早期的内存是经过zone 请求的 ilo89i='
  if (zone) {
    obj = (id)malloc_zone_calloc((malloc_zone_t *)zone, 1, size);
  } else {
#endif
    obj = (id)calloc(1, size);
#if SUPPORT_ZONES
  }
#endif
  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);
}

该办法中有三个核心办法:

  1. cls->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;
  }

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

断点调试此处的参数x 为8 即： align16(8)

iOS 底层之 alloc&init&new 的源码流程分析

2.calloc 请求内存，返回地址指针 向内存中请求巨细为 instanceSize核算的内存， 并将内存地址的指针返回，赋值给obj,obj = (id)calloc(1, size);

3.obj->initInstanceIsa(cls, hasCxxDtor); : 初始化isa 指针 并将类与isa 关联

Init 源码探索

经过查看 Init 源码

- (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 便是将传入的对象 直接返回

new 的源码探索

日常开发中，对象的创立 有 alloc Init 和new ， 现在看下new的源码完成

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

经过源码能够看出 new 相当于alloc init 过程，但是二者有何区别 以下是其他博主总结的， 引证一下

iOS 底层之 alloc&init&new 的源码流程分析