前言
在iOS开发中，我们经常通过[[NSObject alloc] init]来创建一个对象，在这个过程中系统究竟做了那些事，我们往往是不清楚的，本文将通过底层源码来分析对象的实例化过程。
一、allco、init创建对象
在探究底层原理之前，我们先创建一个Person类，然后实例化对象，并打印出结果。
Person *p1 = [Person alloc];
Person *p2 = [p1 init];
Person *p3 = [p1 init];
NSLog(@"%@ - %p - %p", p1, p1, &p1);
NSLog(@"%@ - %p - %p", p2, p2, &p2);
NSLog(@"%@ - %p - %p", p3, p3, &p3);
//打印结果
<Person: 0x600000310410> - 0x600000310410 - 0x7ffee20a10d8
<Person: 0x600000310410> - 0x600000310410 - 0x7ffee20a10d0
<Person: 0x600000310410> - 0x600000310410 - 0x7ffee20a10c8
从打印结果我们可以知道，p1、p2、p3指向的是同一个内存地址，说明在这个过程中只创建了一个Person对象，并且在alloc方法时就已经实例化了，init并没有创建一个新的对象。那alloc、init方法分别做了什么？接下来，我们通过对源码进行流程跟踪来找出答案。
二、alloc的实现流程
一般情况下，对alloc进行断点分析是查看不了源码的，若要分析其实现流程，可以通过下面三个方式：
- 下载objc源码，在源码工程里直接打断点跟踪方法调用流程。
- 在alloc创建对象的地方打断点，运行代码，再通过摁住control + step into，逐步分析。
- 打开Debug - Debug Workflow - Alwalsys show Disassembly，在alloc创建对象的地方打断点，运行代码，即可查看到汇编代码流程。
后两种方法均是通过查看汇编代码来进行分析的，感兴趣的同学可以自行探索。这里，我们通过在objc源码中打断点来进行流程跟踪，objc源码可在苹果开源网站下载，下载后参考这篇文章进行相关配置，即可运行。
通过断点跟踪后，得知alloc的实现流程如下所示：
1 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方法。
2 callAlloc
// 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));
}
__OBJC2__：用于区分调用新老ABI，大多数情况下默认为1。
hasCustomAWZ()：判断当前类是否重写了allocWithZone方法。
fastpath(x)和slowpath(x)是用于编译器优化的两个宏定义
//fastpath(x)表示x很可能为true，大概率会执行
#define fastpath(x) (__builtin_expect(bool(x), 1))
//slowpath(x)表示x很可能为false，大概率不执行。
#define slowpath(x) (__builtin_expect(bool(x), 0))
通过这两个指令，编译器在编译过程中，会将可能性更大的代码紧跟着前面的代码，从而减少代码读取时指令跳转带来的性能上的下降。
callAlloc方法里主要判断当前类是否有重写allocWithZone方法，如果有，就调用allocWithZone，若没有，就调用objc_rootAllocWithZone。因此，如果存在单例类，就需要重写allocWithZone，确保实例化的一定是单例对象。
3 objc_rootAllocWithZone
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方法。
4 objc_rootAllocWithZone（核心方法）
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();
//1.计算需要申请的内存空间大小
size_t size;
size = cls->instanceSize(extraBytes);
if (outAllocatedSize) *outAllocatedSize = size;
//2.为对象分配内存空间，并返回内存地址
id obj;
if (zone) {
obj = (id)malloc_zone_calloc((malloc_zone_t *)zone, 1, size);
} else {
//zone一般为nil，所以会在这里开辟内存
obj = (id)calloc(1, size);
}
if (slowpath(!obj)) {
if (construct_flags & OBJECT_CONSTRUCT_CALL_BADALLOC) {
return _objc_callBadAllocHandler(cls);
}
return nil;
}
//3将类和开辟的内存空间关联起来。
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);
}
hasCxxCtor()：当前class或者superclass是否有.cxx_construct 构造方法的实现。
hasCxxDtor()：该对象是否有 C++ 或者 Objc 的析构器，如果有析构函数，则需要做析构逻辑,，如果没有，则可以更快的释放对象。
canAllocNonpointer()：表示是否对 isa 指针开启指针优化。0：纯isa指针；1：不⽌是类对象地址，isa 中还包含了类信息、对象的引⽤计数等。
zone：在iOS8之后，iOS就不再通过zone来申请内存空间了，所以zone传参为nil。
一般在这里就完成了对象的实例化，主要经过了三个步骤：
-
cls->instanceSize：计算需要申请的内存空间大小，最少16字节。 -
calloc：为对象分配内存空间，并返回内存地址。 -
initInstanceIsa：通过isa将当前类和开辟的内存空间关联起来。
三、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作相关初始化操作。
四、其他实例化方式
new
+ (id)new {
return [callAlloc(self, false/*checkNil*/) init];
}
[NSObject new]方法等同于[[NSObject alloc] init]，先调用callAlloc方法，再调用init方法。这两者的区别在于，采用[alloc init]方式可以灵活拓展，比如实现initWithXXX这种自定义的init方法，而采用new方式只能重写父类的init方法。下面用这两种方式实例化两个Person对象来形象说明。
- 先在Person.h文件里申明属性和自定义的init方法，再在Person.m文件里作相应实现。
//在Person.h文件里申明一个name属性和一个自定义的init方法
@interface Person : NSObject
//属性name
@property (nonatomic, strong) NSString *name;
//自定义的init方法
-(instancetype)initWithDefaultName;
@end
//在Person.m文件里作如下实现
@implementation Person
-(instancetype)init{
self = [super init];
if(self){
_name = @"重写";
}
return self;
}
-(instancetype)initWithDefaultName{
self = [super init];
if(self){
_name = @"自定义";
}
return self;
}
- 然后用这两种方式创建对象，打印name的值。
//创建对象
Person *p1 = [[Person alloc] initWithDefaultName];
Person *p2 = [Person new];
NSLog(@" p1.name = %@, p2.name = %@", p1.name, p2.name);
//输出结果
p1.name = 自定义, p2.name = 重写
从打印结果可看出，相比起New，自定义initWithXXX更加灵活拓展，在同一个类中，可以通过自定义不同的initWithXXX方法来做相应初始化操作。
五、总结
本文主要介绍了objc源码中alloc的实现流程，其中最核心的三个步骤：如何计算需要申请的内存空间大小？系统实际开辟多大的内存？isa是怎么将类和开辟的空间关联起来的？就不在本文中讲解了，不然内容太多不容易抓住重点，大家有兴趣的话，可以关注后续文章，我会抽时间一一进行梳理的。
推荐阅读
1. iOS原理 alloc核心步骤1：instanceSize详解
2. iOS原理 alloc核心步骤2：calloc详解
3. iOS原理 alloc核心步骤3：initInstanceIsa详解
