iOS 探索alloc和init以及new
我们平常开发中，我们在创建对象时，一般都是用这样：
LPPerson *obj1 = [[LPPerson alloc]init];
LPPerson *obj2 = [LPPerson new];
那大家有想过，为什么必须要这样创建才行？alloc和init以及new到底干了什么？今天我们就来探索下
一、准备工作
1、源码准备
- 为了保证我们顺利学习，请先准备一份最新的Objc源码
- 配置下，保证其可以正常编译。具体流程可以百度，很多。
2 、编译源码方式
-
添加符号断点（
symbol BreakPoint）
点击添加断点并选择如下：
image.png
然后添加对应的断点内容：
image.png
-
按压Control并点击Setp in
step in.gif
-
使用汇编源码
在Xcode上方的Debug菜单栏中点击如下选项：
image.png
然后就会出现如下汇编界面：
image.png
二、探索alloc
我新建了一个LPPerson类，并在Viewcontroller中进行了创建工作，具体代码如下：
- (void)viewDidLoad {
[super viewDidLoad];
LPPerson *person = [LPPerson alloc];
LPPerson *person1 = [person init];
LPPerson *person2 = [person init];
NSLog(@"%@--%p--%p",person,person,&person);
NSLog(@"%@--%p--%p",person1,person1,&person1);
NSLog(@"%@--%p--%p",person2,person2,&person2);
}
我们看下运行结果：
<LPPerson: 0x600001844b60>--0x600001844b60--0x7ffee5f8c168
<LPPerson: 0x600001844b60>--0x600001844b60--0x7ffee5f8c160
<LPPerson: 0x600001844b60>--0x600001844b60--0x7ffee5f8c158
从上面的结果我们可以得到一个信息：
上面三个对象的内存空间是同一个，所以其内容和指针地址是相同的，但是其对象的内存地址是不一样的
那是不是我们可以得到结论---alloc实际上就是为对象分配内存空间的呢？
接下来我们结合源码来验证下：
- 在源码中搜索
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：
// 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));
}
这里就发现代码不是很简单了，根据断点我们知道接下里会走_objc_rootAllocWithZone
slowpath & fastpath
这两个宏，在源码中定义如下：
#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的概率很大。
4、fastpath定义中__builtin_expect((x),1)表示 x 的值为真的可能性更大；即 执行if 里面语句的机会更大
5、slowpath定义中的__builtin_expect((x),0)表示 x 的值为假的可能性更大。即执行 else 里面语句的机会更大
cls->ISA()->hasCustomAWZ()
其中fastpath中的 cls->ISA()->hasCustomAWZ()表示判断一个类是否有自定义的 +allocWithZone实现，这里通过断点调试，是没有自定义的实现，所以会执行到 if 里面的代码，即走到_objc_rootAllocWithZone
- 进入
_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)
{
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;
// 1:要开辟多少内存
size = cls->instanceSize(extraBytes);
if (outAllocatedSize) *outAllocatedSize = size;
id obj;
if (zone) {
obj = (id)malloc_zone_calloc((malloc_zone_t *)zone, 1, size);
} else {
// 2;怎么去申请内存
obj = (id)calloc(1, size);
}
if (slowpath(!obj)) {
if (construct_flags & OBJECT_CONSTRUCT_CALL_BADALLOC) {
return _objc_callBadAllocHandler(cls);
}
return nil;
}
// 3: 将 cls类 与 obj指针（即isa） 关联
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);
}
if (zone) {
obj = (id)malloc_zone_calloc((malloc_zone_t *)zone, 1, size);
}
zone这种方式已经被废弃了，所以会直接走calloc函数
_class_createInstanceFromZone这部分是alloc源码的核心操作，我们可以看到，其中非常关键的三个步骤：
-
cls->instanceSize：计算开辟内存空间 -
calloc：申请内存 -
obj->initInstanceIsa：将 cls类 与 obj指针（即isa） 关联
1.instanceSize：计算开辟内存空间
进入instanceSize中，
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);
}
1.这里为什么要进行内存对齐呢？
CPU 并不是以字节为单位存取数据的。CPU把内存当成是一块一块的，块的大小可以是2，4，8，16字节大小，因此CPU在读取内存时是一块一块进行读取的。每次内存存取都会产生一个固定的开销，减少内存存取次数将提升程序的性能。即我们常说的空间换时间。所以 CPU 一般会以 2/4/8/16/32 字节为单位来进行存取操作。我们将上述这些存取单位也就是块大小称为（memory access granularity）内存存取粒度。
2.那为什么要使用16字节对齐？
在一个对象中，至少包含一个isa指针，isa指针就会占据8字节的空间，除了isa，对象可能会有其他的属性，如果没有其它属性，就会预留8字节的空间，如果有其它属性会继续增加，但是大小永远是16的倍数。
3.对齐算法解析：
image.png
2. calloc申请内存，返回地址指针
通过instanceSize计算的内存大小，向内存中申请 大小 为 size的内存，并赋值给obj，因此 obj是指向内存地址的指针。
obj = (id)calloc(1, size);
在calloc执行之前，obj为nil，但是calloc执行后，obj就为非nil了
image.png
3.obj->initInstanceIsa：类与isa关联
在执行完initInstanceIsa后，就可以得出一个对象指针了
- 通过对
alloc源码的分析，可以得知alloc的主要目的就是开辟内存，而且开辟的内存需要使用16字节对齐算法，现在开辟的内存的大小基本上都是16的整数倍 - 开辟内存的核心步骤有3步：计算大小-- 申请内存 -- 关联class
alloc具体流程如下：
image.png
三、探索init
init的流程就相对简单很多，查看objc源码可知主要分为类方法和实例方法：
- 类方法
+ (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;
}
四、探索new
同样的，查看源码:
+ (id)new {
return [callAlloc(self, false/*checkNil*/) init];
}
可以看到，new和alloc init本质上没有区别，new = [alloc init].但是在我们的开发中，如果一个类，你重写了init构法，就不要使用new来创建了，new可能并不会执行你重新的方法。
觉得不错记得点赞哦！听说看完点赞的人逢考必过，逢奖必中。ღ( ´･ᴗ･` )比心
