前言
作为iOS开发老司机，我们都知道创建OC对象的2种方式:[[Class alloc] init] 或[Class new]。那么创建对象的过程是怎样的，这2中方式有何区别？alloc、init、new都做了什么，new和alloc，init 之间有何关系呢？本文带您分析和探索alloc & init & new。
准备工作
首先我们需要编译好objc4-781。
- Cooci老师github下载地址
- 可参考iOS-底层原理 02:objc4-781编译环境。
问题探索
- 代码
LGPerson *p1 = [LGPerson alloc];
LGPerson *p2 = [p1 init];
LGPerson *p3 = [p1 init];
LGPerson *p4 = [LGPerson new];
NSLog(@"p1== %@ %p %p",p1, p1, &p1);
NSLog(@"p2== %@ %p %p",p2, p2, &p2);
NSLog(@"p3== %@ %p %p",p3, p3, &p3);
NSLog(@"p4== %@ %p %p",p4, p4, &p4);
- 打印结果
p1== <LGPerson: 0x102404080> 0x102404080 0x7ffeefbff4e0
p2== <LGPerson: 0x102404080> 0x102404080 0x7ffeefbff4c8
p3== <LGPerson: 0x102404080> 0x102404080 0x7ffeefbff4d0
p4== <LGPerson: 0x1024040a0> 0x1024040a0 0x7ffeefbff4d8
其中：%@打印对象；%p打印地址；&p 指针地址。
如上代码示例，我们就要思考
- p1、p2、p3打印的对象地址为什么一样，为何打印的对象指针的地址不一致?
- p4的对象地址和指针地址为什么和p1、p2、p3都不一样?
这就是本文需要探索的内容，alloc做了什么？init做了什么？new与alloc、init之间的关系.
alloc源码探索
alloc源码探索流程图如下:
alloc源码流程图
- 首先根据main函数中的
LGPerson *p1 = [LGPerson alloc]类的alloc方法点击进入alloc方法的源码实现（即源码分析开始）.
+ (id)alloc {
return _objc_rootAlloc(self);
}
- 再点击进入
_objc_rootAlloc
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__
// 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方法中，我通过断点调试，判断执行到_objc_rootAllocWithZone.
slowpath & fastpath
关于slowpath和fastpath其宏定义如下所示。其作用是编译优化
//x很可能为真， fastpath 可以简称为 真值判断
#define fastpath(x) (__builtin_expect(bool(x), 1))
//x很可能为假，slowpath 可以简称为 假值判断
#define slowpath(x) (__builtin_expect(bool(x), 0))
- 其中的
__builtin_expect指令是由gcc引入的，- 目的：编译器可以对代码进行优化，以减少指令跳转带来的性能下降。即性能优化
- 作用：允许程序员将
最有可能执行的分支告诉编译器。 -
__builtin_expect(EXP, N)表示EXP==N的概率很大。 -
fastpath定义中的__builtin_expect((x),1)表示x的值为真的可能性更大；即执行if里面语句的机会更大 -
slowpath定义中的__builtin_expect((x),0)表示x的值为假的可能性更大。即执行else里面语句的机会更大 - 编译器优化
Xcode设置方法，如下图所示:
- 再点击进入
_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
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)// alloc 源码 第五步
{
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;
//计算需要开辟的内存大小，传入的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 {
//申请内存
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类 与 obj指针（即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);
}
这部分就是alloc源码的核心操作，由上述代码可知该方法的实现主要分为三部分
-
cls->instanceSize：计算需要开辟的内存空间大小; -
calloc：申请内存，返回地址指针; -
obj->initInstanceIsa：将 类 与 isa 关联
cls->instanceSize：计算需要的内存大小
size_t instanceSize(size_t extraBytes) const {
//快速计算内存大小
if (fastpath(cache.hasFastInstanceSize(extraBytes))) {
return cache.fastInstanceSize(extraBytes);
}
//计算类中所有属性需要的内存大小 extraBytes额外字节数一般是0
size_t size = alignedInstanceSize() + extraBytes;
// CF requires all objects be at least 16 bytes.
//最小返回16字节
if (size < 16) size = 16;
return size;
}
- 断点调试进入
cache.fastInstanceSize(extraBytes)
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);
}
align16的实现，就是使用位运算算法完成16字节对齐。
算法
(x + size_t(15)) & ~size_t(15)
以x=8为例，计算过程如下:
8 + size(15) = 23二进制->0000 0000 0001 0111size_t(15)二进制->0000 0000 0000 1111- 取反
~size_t(15)二进制->1111 1111 1111 0000- 求交 & :
0000 0000 0001 0111&1111 1111 1111 0000=0000 0000 0001 0000- 结果表示为十进制:
16
关于内存结构对齐更多内容可看我的这篇iOS-底层原理 04:内存对齐
calloc：开辟内存，返回地址指针
obj = (id)calloc(1, size);
通过instanceSize计算的内存大小，向内存中申请大小为size的内存，并赋值给obj，因此obj是指向内存地址的指针。
如图所示:
在未执行
calloc时，po obj为nil，执行后，再po obj发现，返回了一个16进制的地址，但是又和平常见到的地址指针(<LGPerson: 0x101b08b50>)不一样，为什么呢？
- 主要是
obj没有和cls进行关联（下面要探索的） - 同时也验证了
calloc只是开辟了内存
obj->initInstanceIsa 初始化指针 ，类和isa关联
初始化指针(isa)，并将isa指针指向申请的内存地址，在将指针(isa)与cls类进行关联
obj->initInstanceIsa(cls, hasCxxDtor);
inline void
objc_object::initInstanceIsa(Class cls, bool hasCxxDtor)
{
ASSERT(!cls->instancesRequireRawIsa());
ASSERT(hasCxxDtor == cls->hasCxxDtor());
initIsa(cls, true, hasCxxDtor);
}
同样也可以通过断点调试来印证上面的说法，在执行完initInstanceIsa后，在通过po obj可以得出一个对象指针
总结
- 通过对
alloc源码的分析，可知alloc的主要目的就是开辟内存 - 开辟内存的核心步骤有3步：
计算 -- 开辟 -- 关联
init 源码探究
通过源码探索，inti的源码实现有以下两种:
类方法 init
+ (id)init {
return (id)self;
}
实例方法init
通过以下代码进行探索实例方法 init
LGPerson *objc = [[LGPerson alloc] init];
点击init进入init的源码实现
- (id)init {
return _objc_rootInit(self);
}
跳转至_objc_rootInit的源码实现
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;
}
总结:
- 返回的是对象本身.
- 不同的是
类方法返回的是id类型的self，可以提供给开发者更多的自由去自定义 ，通过id实现强转，返回我们需要的类型
new源码探索
文章开头已提及一般初始化除了init，还可以使用new，两者本质上并没有什么区别，以下是objc中new的源码实现，通过源码可以得知，new函数中直接调用了callAlloc函数（即alloc中分析的函数），且调用了init函数，所以可以得出new 其实就等价于[alloc init]的结论
+ (id)new {
return [callAlloc(self, false/*checkNil*/) init];
}
但是一般开发中并不建议使用new，主要是因为有时会重写init方法做一些自定义的操作，例如initWithFrame，会在这个方法中调用[super init]，用new初始化可能会无法走到自定义的initWithFrame部分。如下探索所示:
- (instancetype)init {
self = [super init];
if (self != nil) {
NSLog(@"重写");
}
return self;
}
- (instancetype)initWithFrame {
self = [super init];
if (self != nil) {
NSLog(@"自定义init");
}
return self;
}
- 使用 alloc + init 初始化时，打印的情况如下
LGPerson * p1 = [LGPerson alloc] init];
image.png
- 使用new 初始化时，打印的情况如下
LGPerson * p4 = [LGPerson new]
image.png
总结
- 如果子类没有重写父类的init，new会调用父类的init方法
- 如果子类重写了父类的init，new会调用子类重写的init方法
- 如果使用 alloc + 自定义的init，可以帮助我们自定义初始化操作，例如传入一些子类所需参数等，最终也会走到父类的init，相比new而言，扩展性更好，更灵活。
源码探索后我们再思考文章的问题探索可知:
-
p1、p2、p3对象和地址打印都一致， 为何&p打印不一致
alloc是真正开辟内存和绑定对象的，p1、p2、p3共用同一个alloc，所以他们都是指向同一目的地址。但是他们本身也是对象，在init时传入他们自身id，&p打印的是他们自身的指针地址。
-
p4的地址为什么和p1、p2、p3都不一样。
因为p1、p2、p3是同一个alloc打印的，而p4的new相当于从新alloc，所以都不一样。
