iOS之深入解析alloc、init与new的底层原理

底层探索

一、对于iOS的底层原理探索，查找到函数所在的源码库，一般有以下方法实现

① 符号断点

• 在哪里新建符号断点：选择Symbolic Breakpoint：

• 怎么添加符号断点：在Symbol中加入alloc、objc_alloc等：

• 继续追踪方法底层原理，可以继续使用以上符号断点方法添加对应的方法名即可；
• 直到最后追踪到系统底层库为止，例如： alloc 的源码最后追踪到位于 libobjc.A.dylib 库。

② LLDB调试

• 在需要探索的内部方法或者实现的地方，打上断点；
• 运行代码，执行到断点地方，然后按住 control 键，即出现以下调试断点：

• 点击上图中的第四个step into之后，即可看见相应实现方法，如：alloc 如下：

• 再添加一个 objc_alloc 符号断点，便可显示 objc_alloc 所在的源码库 libobjc.A.dylib 。

③ 汇编分析

• xcode 工具栏选择 Xcode -> Debug WorkFlow -> Always Show Disassembly，该选项表示始终显示反汇编 ，即汇编分析

• 按照“符号断点”的运行代码，执行到断点地方，然后按住 control键，即出现以下调试断点方法，即可进入callq ，对应 objc_alloc：

• 最后，也可以看到 alloc 对应的源码库为 libobjc.A.dylib 库。

二、作为 iOS 开发者，最需要关注的应该就是从应用启动到应用被 kill 掉这一整个生命周期的内容。不妨从最熟悉的 main 函数开始，一般来说，在 main.m 文件中打一个断点，左侧的调用堆栈视图应该如下图所示:

三、调用堆栈有两个注意点:

• 需要关闭 Xcode 左侧 Debug 区域最下面的 show only stack frames with debug symbols and between libraries

扫描二维码关注公众号，回复： 11618896 查看本文章

• 增加一个 _objc_init 的符号断点

四、通过上面的调用堆栈信息不难得出一个简单粗略的加载流程

五、Apple 开源库源码

• Apple 所有开源源码汇总地址，根据相应的版本查找对应的源码，以mac 10.15为例: macOS --> 10.15 --> 选择10.15 --> 搜索 objc；
• Apple 比较直接的源码下载地址，直接搜索想要下载的源码名称即可，例如objc：直接搜索 objc --> objc4/ --> 选择相应的objc的版本。

内存对齐

一、内存对齐概念

① 什么是内存对齐？

• 内存对齐是一种在计算机内存中排列数据（表现为变量的地址）、访问数据（表现为CPU读取数据）的一种方式。
• 内存对齐包含了两种相互独立又相互关联的部分：基本数据对齐和结构体数据对齐 。

② 为什么要进行内存对齐？

• 平台原因(移植原因)：不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。
• 性能原因：数据结构(尤其是栈)应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。

③ 内存对齐原则

在 iOS 中，对象的属性需要进行内存对齐，而对象本身也需要进行内存对齐。内存对齐有三原则：

• 数据成员对齐原则: 结构( struct )(或联合( union ))的数据成员，第一个数据成员放在 offset 为 0 的地方，以后每个数据成员存储的起始位置要从该成员大小或者成员的子成员大小。
• 结构体作为成员: 如果一个结构里有某些结构体成员，则结构体成员要从其内部最大元素大小的整数倍地址开始存储。(如：struct a⾥存有struct b，b⾥有char、int 、double等元素，那b应该从8的整数倍开始存储)
• 收尾工作: 结构体的总大小，也就是 sizeof 的结果，必须是其内部最大成员的整数倍，不足的要补⻬。

简而言之：

• 前面的地址必须是后面的地址正数倍，不是就补齐；
• 结构体里面的嵌套结构体大小要以该嵌套结构体最大元素大小的整数倍；
• 整个 Struct 的地址必须是最大字节的整数倍。

注意：

• 在字节对齐算法中，对齐的主要是对象，而对象的本质则是一个 struct objc_object 的结构体；
• 结构体在内存中是连续存放的，所以可以利用这点对结构体进行强转；
• 苹果早期是8字节对齐，现在是16字节对齐。

二、对象申请内存和系统开辟内存

在Xocde中打印以下两个函数：

	Boy *boy = [Boy alloc];
	NSLog(@"%lu - %lu - %lu", sizeof(boy), class_getInstanceSize([Boy class]), malloc_size((__bridge const void *)(boy)));
	

• 可以发现对象自己申请的内存大小与系统实际给开辟的大小时不一样的，这里对象申请的内存大小是 40 个字节，而系统开辟的是 48 个字节。
• 40 个字节不难理解，是因为当前对象有 4 个属性，有三个属性为 8 个字节，有一个属性为 4个字节，再加上 isa 的 8 个字节，就是 32 + 4 = 36 个字节，然后根据内存对齐原则，36 不能被 8 整除，36 往后移动刚好到了 40 就是 8 的倍数，所以内存大小为 40。
• class_getInstanceSize 和 malloc_size 对同一个对象返回的结果不一样的，原因是 malloc_size 是直接返回的 calloc 之后的指针的大小。

size_t instanceSize(size_t extraBytes) {
    size_t size = alignedInstanceSize() + extraBytes;
    // CF requires all objects be at least 16 bytes.
    if (size < 16) size = 16;
    return size;
}

• 通过instanceSize计算的内存大小，向内存中申请 大小 为 size的内存，并赋值给obj，因此 obj是指向内存地址的指针；在未执行 calloc 时，po obj 为 nil，执行后，再 po obj ，返回一个16进制的地址。

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

• 而 class_getInstanceSize 内部实现是：也就是说 class_getInstanceSize 会输出 8 个字节，malloc_size 会输出 16 个字节，当然前提是该对象没有任何属性。

size_t class_getInstanceSize(Class cls) {
    if (!cls) return 0;
    return cls->alignedInstanceSize();
}

三、不同数据类型占据的内存大小（字节）

C	OC	32位	64位
bool	BOOL(64位)	1	1
signed char	(_signed char)int8_t、BOOL(32位)	1	1
unsigned char	Boolean	1	1
short	int16_t	2	2
unsigned short	unichar	2	2
int、int32_t	NSInteger(32位)、boolean_t(32位)	4	4
unsigned int	NSUInteger(32位)、boolean_t(64位)	4	4
long	NSInteger(64位)	4	8
unsigned long	NSUInteger(64位)	4	8
long long	int64_t	8	8
float	CGFloat(32位)	4	4
double	CGFloat(64位)	8	8

alloc、init与new的底层原理

一、实例初始化

运用Objective-C语言进行开发的时候，我们都知道可以通过 [XXX alloc]、[[XXX alloc] init]、[XXX new]的形式进行对象实例的创建，那么不禁会疑惑alloc、init、new它们各自都做了什么呢？同样的都是进行实例创建，它们之间有什么内在的关联呢？它们之间又有着什么样的区别呢？

• 我们不妨先出使用alloc、init、new分别初始化对象，具体实现和并打印对象结果、指针地址、内存地址如下：

	Boy *boy1 = [Boy alloc];
    Boy *boy2 = [boy1 init];
    Boy *boy3 = [[Boy alloc] init];
    Boy *boy4 = [Boy new];
    NSLog(@"%@ %p %p",boy1, boy1, &boy1);
    NSLog(@"%@ %p %p",boy2, boy2, &boy2);
    NSLog(@"%@ %p %p",boy3, boy3, &boy3);
    NSLog(@"%@ %p %p",boy4, boy4, &boy4);

打印结果
2020-09-02 00:32:43.295969+0800 iOS之alloc与init[1284:37780] <Boy: 0x6000008c03d0> 0x6000008c03d0 0x7ffee75284d8
2020-09-02 00:32:43.296121+0800 iOS之alloc与init[1284:37780] <Boy: 0x6000008c03d0> 0x6000008c03d0 0x7ffee75284d0
2020-09-02 00:32:43.296282+0800 iOS之alloc与init[1284:37780] <Boy: 0x6000008c03a0> 0x6000008c03a0 0x7ffee75284c8
2020-09-02 00:32:43.296370+0800 iOS之alloc与init[1284:37780] <Boy: 0x6000008c03c0> 0x6000008c03c0 0x7ffee75284c0

• 通过以上可以看出：boy1与boy2是同一个对象，而与boy3、boy4则是不同的对象。虽然boy1与boy2是同一个对象，并且指针地址相同，指向的是同一个内存空间，但是它们的内存地址却又不一样，那么alloc、init、new到底做了什么呢？其实，当alloc执行返回的时候，x0寄存器就会存储一个指针，指向申请的内存空间，并且可以看到内存地址相差8个字节。

二、如何查找alloc实现？

• 在alloc初始化的地方，打上断点，如下：

• 运行代码，执行到断点地方，然后按住 control键，即出现以下调试断点：
  
• 按住control，然后点击第四个图标调试，就可以进入到 objc_alloc 中；
• symbolic Beakpoint 添加符号断点 objc_alloc 可以发现在 libobjc.A.dylib ；

• 也可以先把断点打在alloc的地方，运行，断点断住之后再下一个alloc的符号断点，会发现有很多的类实现了alloc方法，先不用管直接过掉断点，就会进入汇编的代码之中；

• 可以通过 Xcode -> Debug 进入汇编分析：

	X0 X1..其中x0-x7八个寄存器是用来保存参数的
	objc_msgSend会有两个默认参数，这也就意味着x0保存的是self,也就是isa指针，x1保存的是_cmd
	register read x0 (register指令能够获取和修改各个寄存器的信息。)
	po 0x4567899. “po”命令是“print object”（打印对象）的简写

三、底层实现源码分析

既然是深入底层，那么肯定需要知道底层代码是做了什么事情，苹果是开源了这部分的代码，可以在Source Browser下载。下载下来的源码直接编译是通不过的，需要自己修改下配置，具体请参考objc_debug。

① alloc

• 进入到alloc的源码里面，我们发现alloc调用了_objc_rootAlloc方法，而_objc_rootAlloc调用了callAlloc方法。

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

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

static ALWAYS_INLINE id
callAlloc(Class cls, bool checkNil, bool allocWithZone=false) {
#if __OBJC2__ 
    
    // 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));
}

• 在callAlloc方法里面可以看到if的判断条件，那么fastpath(!cls->ISA()->hasCustomAWZ())都做了什么呢？fastpath又是什么呢？fastpath的定义如下：

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

• 要搞清楚fastpath是什么，就要知道__builtin_expect是什么。其实，这个指令是gcc引入的，作用是允许程序员将最有可能执行的分支告诉编译器。这个指令的写法为：__builtin_expect(EXP, N)。
  • 目的：编译器可以对代码进行优化，以减少指令跳转带来的性能下降，即性能优化；
  • 作用：允许程序员将最有可能执行的分支告诉编译器；
  • 指令的写法为：__builtin_expect(EXP, N)。表示 EXP==N的概率很大；
  • fastpath定义中__builtin_expect((x),1)表示 x 的值为真的可能性更大；即执行 if 里面语句的机会更大；
  • slowpath定义中的__builtin_expect((x),0)表示 x 的值为假的可能性更大，即执行 else 里面语句的机会更大；
• !cls->ISA()->hasCustomAWZ()做了什么呢？很明显是调用了hasCustomAWZ这样一个方法：

    bool hasDefaultAWZ( ) {
        return data()->flags & RW_HAS_DEFAULT_AWZ;
    }
	#define RW_HAS_DEFAULT_AWZ    (1<<16)

• RW_HAS_DEFAULT_AWZ 这个是用来标示当前的class或者是superclass是否有默认的alloc/allocWithZone:。值得注意的是，这个值会存储在 metaclass 中。
• hasDefaultAWZ( )方法是用来判断当前class是否有重写allocWithZone。如果cls->ISA()->hasCustomAWZ()返回YES，意味着当前的class有重写allocWithZone方法，那么就直接对class进行allocWithZone，申请内存空间。

if (allocWithZone) return [cls allocWithZone:nil];

 + (id)allocWithZone:(struct _NSZone *)zone {
    return _objc_rootAllocWithZone(self, (malloc_zone_t *)zone);
}

• allocWithZone内部调用了_objc_rootAllocWithZone方法，接下来分析下_objc_rootAllocWithZone方法

id
_objc_rootAllocWithZone(Class cls, malloc_zone_t *zone)
{
    id obj;

#if __OBJC2__
    // allocWithZone under __OBJC2__ ignores the zone parameter
    (void)zone;
    obj = class_createInstance(cls, 0);//创建对象
#else
    if (!zone) {
        obj = class_createInstance(cls, 0);
    }
    else {
        obj = class_createInstanceFromZone(cls, 0, zone);
    }
#endif

    if (slowpath(!obj)) obj = callBadAllocHandler(cls);
    return obj;
}

• 不难发现直接调用了class_createInstance方法来创建对象，而_class_createInstanceFromZone 是 alloc 源码的核心操作，实现主要分为三部分：
  • cls->instanceSize：计算需要开辟的内存空间大小
  • calloc：申请内存，返回地址指针；
  • obj->initInstanceIsa：将 类 与 isa 关联。

id class_createInstance(Class cls, size_t extraBytes) {
    return _class_createInstanceFromZone(cls, extraBytes, nil);
}

tatic __attribute__((always_inline)) 
id
_class_createInstanceFromZone(Class cls, size_t extraBytes, void *zone, 
                              bool cxxConstruct = true, 
                              size_t *outAllocatedSize = nil)
{
    if (!cls) return nil;

    assert(cls->isRealized());
    // Read class's info bits all at once for performance
    //读取class的信息
    bool hasCxxCtor = cls->hasCxxCtor();
    bool hasCxxDtor = cls->hasCxxDtor();
    bool fast = cls->canAllocNonpointer();

    size_t size = cls->instanceSize(extraBytes);
    if (outAllocatedSize) *outAllocatedSize = size;

    id obj;
    if (!zone  &&  fast) {
        obj = (id)calloc(1, size);
        if (!obj) return nil;
        obj->initInstanceIsa(cls, hasCxxDtor);
    } 
    else {
        if (zone) {
            obj = (id)malloc_zone_calloc ((malloc_zone_t *)zone, 1, size);
        } else {
            obj = (id)calloc(1, size);
        }
        if (!obj) return nil;

        // Use raw pointer isa on the assumption that they might be 
        // doing something weird with the zone or RR.
        obj->initIsa(cls);
    }

    if (cxxConstruct && hasCxxCtor) {
        obj = _objc_constructOrFree(obj, cls);
    }

    return obj;
}

• 创建对象就要为对象开辟内存空间，这里会不会就是为对象开辟了空间呢？我们发现方法里面调用了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;
}

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

// May be unaligned depending on class's ivars.
// 读取当前的类的属性数据大小
uint32_t unalignedInstanceSize() {
  assert(isRealized());
  return data()->ro->instanceSize;
}
// 进行内存对齐
// WORD_MASK == 7
static inline uint32_t word_align(uint32_t x) {
   return (x + WORD_MASK) & ~WORD_MASK;
}

• 不难看出，instanceSize方法计算出了对象所需内存的大小，而且必须是大于或等于16字节，然后调用calloc函数为对象分配内存空间。通过 obj = (id)calloc(1, size) 创建 obj 对象传递了一个 size ，就是 obj 的内存大小对，对于alloc申请内存，任何集成 NSObject 对象创建之后默认的内存大小为16个字节；
• 那 initInstanceIsa 方法又是干什么的呢？其实这个方法就是初始化isa指针。
• 上面我们分析了 hasDefaultAWZ( ) 方法返回Yes的情况，那如果hasDefaultAWZ( )方法返回NO呢？以下是 hasDefaultAWZ( ) 返回NO的情况，有去判断当前的class是否支持快速alloc。如果可以，直接调用calloc函数，并且申请一块 bits.fastInstanceSize() 大小的内存空间，然后初始化isa指针，否则直接调用class_createInstance方法。

    if (fastpath(cls->canAllocFast())) {
            // No ctors, raw isa, etc. Go straight to the metal.
            bool dtor = cls->hasCxxDtor();
            id obj = (id)calloc(1, cls->bits.fastInstanceSize());
            if (slowpath(!obj)) return callBadAllocHandler(cls);
            obj->initInstanceIsa(cls, dtor);
            return obj;
        }
        else {
            // Has ctor or raw isa or something. Use the slower path.
            id obj = class_createInstance(cls, 0);
            if (slowpath(!obj)) return callBadAllocHandler(cls);
            return obj;
        }

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

• 然后 align16 是16字节对齐算法：

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

• 总结：alloc为我们创建了一个对象并且申请了一块不少于16字节的内存空间，并初始化isa指针。

② init

既然 alloc 创建了对象，那还要 init 干嘛呢？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并没有做什么，只是把当前的对象返回了。既然什么都没做那我们还需要调用 init 吗？答案是肯定的，其实 init 就是一个工厂模式，方便开发者自行重写定义，即交给子类可以自定义去重写。

③ new

• new底层源码

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

• new调用的是callAlloc方法和init，那么可以理解为new实际上就是alloc+init的综合体。

总结

• alloc创建了对象并且申请了一块不少于16字节的内存空间，并初始化了isa指针；
• 相比于 alloc 来说， init 内部实现十分简单，先来到的是 _objc_rootInit ，然后就直接返回 obj 了。其实这里是一种抽象工厂设计模式的体现，对于 NSObject 自带的 init 方法来说，其实啥也没干，但是如果你继承于 NSObject 的话，然后就可以去重写 initWithXXX 之类的初始化方法来做一些初始化操作；
• new其实是alloc+init的一个综合。