iOS-alloc底层做了什么流程分析
引言
当我们创建一个对象的时候 比如: [[Person alloc] init] alloc 到底做了什么 init到底做了什么 ? 这就是这篇文档要给大家分享的一些个人见解,希望大家多提意见,共同学习.
探索路程
如下图 直接上代码
001.png
上述代码说明p1,p2,p3指向了相同的内存地址,init并没有创建空间 真正申请空间的是alloc申请了空间.
%p -> &p1：是对象的指针地址，
%p -> p1： 是对象指针指向的的内存地址
由p1,p2,p3的指针地址推断，栈内存是连续的（0x30 + 0x08 = 0x38, 0x28 + 0x08 = 0x30 [这里是16进制运算]），并且所占内存都是8字节（指针占内存8字节）
002.png
源码探索
要想知道alloc到底做了什么事我们需要知道他的源码里面到底怎么实现的,由于苹果API是点不进去的 我们只能根据符号断点或者其他方法去探索 我们可以从网上下载他的源码去分析.
苹果开源库：
1：https://opensource.apple.com/source 所以开源库都在里面，包括各个老版本
2：https://opensource.apple.com 可以根据系统版本选择更新的下载
3 : 编译源码，可参考https://github.com/LGCooci/objc4_debug
999
知道哪里下载库了，那我们怎么知道alloc属于哪个库呢？
这里为大家提供3个方法，供参考
方法一： 下符号断点的形式直接跟流程
下符号断点的方法如图
003.png
方法二：Ctrl + step into
004
按住Ctrl，多点几次下一步，来到了 objc_alloc
005
把objc_alloc作为符号断点，加上的一瞬间就又找到了libobjc.A.dylib
006
方法三：汇编查看跟流程（最常用的）
Debug -> Debug Workflow -> Always Show Disassembly 进入汇编
007
得到 objc_alloc
008
用方法二下符号断点又可以拿到libobjc.A.dylib
找到源码库libobjc.A.dylib 即 objc4
下载源码+编译源码请移步到 iOS_objc4-781.2 最新源码编译调试
打开源码工程，开始alloc源码探索
通过 command + 鼠标左键 一步一步进入源码看流程
如下图 NSObject 和它的子类是有点区别的 NSObject 没走alloc只走了一次callAlloc是因为系统帮我们做了(alloc底层会被hook去调用objc_alloc,所以先走objc_alloc再走alloc) MyNSObject走了两次callAlloc 第二次才是真正的去开辟空间.
666
444
所以可以看到在调用NSObject *objc = [NSObject alloc];时，其实调用的是objc中的objc_alloc方法。
二、OC 的 alloc 深入探究
经过上面一步，我们就能浅尝辄止吗？当然不能；所以我搞来一份objc4源码继续我们的探究。
看到源码 NSObject.mm 文件，里面的alloc方法
image
他会调用_objc_rootAlloc
image
- 问题：
我上面看到 [NSObject alloc]看到的不是会到objc_alloc来吗？怎么源码分析的到了_objc_rootAlloc？ - 答：我们知道OC代码有运行时的特点，即方法的调用不是在编译时确定的，而是运行时，不懂的补一下编译原理。我们在objc运行时源码中查找objc_alloc，发现如下的代码
static void
fixupMessageRef(message_ref_t *msg)
{
msg->sel = sel_registerName((const char *)msg->sel);
if (msg->imp == &objc_msgSend_fixup) {
if (msg->sel == @selector(alloc)) {
msg->imp = (IMP)&objc_alloc;
} else if (msg->sel == @selector(allocWithZone:)) {
msg->imp = (IMP)&objc_allocWithZone;
} else if (msg->sel == @selector(retain)) {
msg->imp = (IMP)&objc_retain;
} else if (msg->sel == @selector(release)) {
msg->imp = (IMP)&objc_release;
} else if (msg->sel == @selector(autorelease)) {
msg->imp = (IMP)&objc_autorelease;
} else {
msg->imp = &objc_msgSend_fixedup;
}
}
else if (msg->imp == &objc_msgSendSuper2_fixup) {
msg->imp = &objc_msgSendSuper2_fixedup;
}
else if (msg->imp == &objc_msgSend_stret_fixup) {
msg->imp = &objc_msgSend_stret_fixedup;
}
else if (msg->imp == &objc_msgSendSuper2_stret_fixup) {
msg->imp = &objc_msgSendSuper2_stret_fixedup;
}
#if defined(__i386__) || defined(__x86_64__)
else if (msg->imp == &objc_msgSend_fpret_fixup) {
msg->imp = &objc_msgSend_fpret_fixedup;
}
#endif
#if defined(__x86_64__)
else if (msg->imp == &objc_msgSend_fp2ret_fixup) {
msg->imp = &objc_msgSend_fp2ret_fixedup;
}
#endif
}
发现消息发送时，当msg->imp == &objc_msgSend_fixup 进行了方法实现(IMP)的替换。
什么时候
msg->imp == &objc_msgSend_fixup成立还没有确定的探究，后续了解会进一步更新。从源码的运行看[NSObject alloc]会走到objc_alloc；但是其子类的[LGPerson alloc]会调用_objc_rootAlloc
不管是_objc_rootAlloc或者objc_alloc从图4看都会进入callAlloc这个函数,不过最后两个参数不同；我们姑且往下走,进入callAlloc去看看究竟。代码如下
image
- 这里看到有两个宏定义函数:
slowpath,fastpath. 这两个函数是用于编译器优化；slowpath低概率会走;fastpath大概率会走,如果项目中有需求，自己也可以用上，让自己的代码质量提高。 -
hasCustomAWZ是否有自定义的AWZ；经过运行实际得出，当类的第一次运行时slowpath，fastpath判断都为false,后面在运行时fastpath为true;不过我们看到下面的函数又是消息的发送，调用的是alloc和allocWithZone，其实接着往下走，可以发现，他又回到了callAlloc,并且此时的fastpath为true;
那么函数此时应来到_objc_rootAllocWithZone
unsigned
class_createInstances(Class cls, size_t extraBytes,
id *results, unsigned num_requested)
{
return _class_createInstancesFromZone(cls, extraBytes, nil,
results, num_requested);
}
那么我们去看看_class_createInstancesFromZone
unsigned
_class_createInstancesFromZone(Class cls, size_t extraBytes, void *zone,
id *results, unsigned num_requested)
{
unsigned num_allocated;
if (!cls) return 0;
size_t size = cls->instanceSize(extraBytes);
num_allocated =
malloc_zone_batch_malloc((malloc_zone_t *)(zone ? zone : malloc_default_zone()),
size, (void**)results, num_requested);
for (unsigned i = 0; i < num_allocated; i++) {
bzero(results[i], size);
}
// Construct each object, and delete any that fail construction.
unsigned shift = 0;
bool ctor = cls->hasCxxCtor();
for (unsigned i = 0; i < num_allocated; i++) {
id obj = results[i];
obj->initIsa(cls); // fixme allow nonpointer
if (ctor) {
obj = object_cxxConstructFromClass(obj, cls,
OBJECT_CONSTRUCT_FREE_ONFAILURE);
}
if (obj) {
results[i-shift] = obj;
} else {
shift++;
}
}
return num_allocated - shift;
}
这里的逻辑大体分为
- 1、求出实例所需内存大小
size_t size = cls->instanceSize(extraBytes);
- 2、分配空间
num_allocated =
malloc_zone_batch_malloc((malloc_zone_t *)(zone ? zone : malloc_default_zone()),
size, (void**)results, num_requested);
3、绑定isa到类
obj->initIsa(cls); // fixme allow nonpointer
接下来返回对应类的首地址
内存分配分析
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) {
3：根据分配的内存情况管理对象
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：计算相关内存大小
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;
}
根据断点我们能进入到 return cache.fastInstanceSize(extraBytes);这里，再次进入代码到
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的数据返回类型，第一段代码告诉我们，系统是通过16字节对齐的方式，如果分配小于16字节，就直接等于16字节。所以此时的size 是16，
align16(size + extra - FAST_CACHE_ALLOC_DELTA16);
-
size : 16字节对齐，此时是16，
-
extra :是系统计算的额外信息，根据断点此时是0，
-
FAST_CACHE_ALLOC_DELTA16：是宏定义 ：此时是8
image
所以结合最终返回的align16的值是 align16(8)
我们在此进入align16的定义函数
static inline size_t align16(size_t x) {
return (x + size_t(15)) & ~size_t(15);
}
此处代码的意思就是，上一步计算结果 的值加上15，和15的值取反过后再进行 按位与操作，
什么意思呢：例如上一步我们计算的结果是8，再加上15 结果等于23，23在内存中的标识是这样的
0000 0000 0001 0111
15的内存表示
0000 0000 0000 1111
15取反操作的值是
1111 1111 1111 0000
所以按位与的操作就是 23 & ~15
0000 0000 0001 0111
1111 1111 1111 0000
0000 0000 0001 0000（结果）十进制的16
如果是内存分配大于16 的，比如 20 加上15表示成 35，内存表示（0000 0000 0010 0011）
按位与操作是 35 & ~15
0000 0000 0010 0011
1111 1111 1111 0000
0000 0000 0010 0000(结果) 十进制的32，
所以这就是16字节对齐的核心机制，相信我已经介绍的够清晰了，这就是iOS内存分配的最新机制。
-
步骤2 ：分配内存
根据计算的内存size_t size 进行内存的分配，
image
-
步骤3 关联对象类型
通过InitInstanceIsa 方法进行关联类对象实例，
objc_object::initInstanceIsa(Class cls, bool hasCxxDtor)
{
ASSERT(!cls->instancesRequireRawIsa());
ASSERT(hasCxxDtor == cls->hasCxxDtor());
initIsa(cls, true, hasCxxDtor);
}
objc_object::initIsa(Class cls, bool nonpointer, bool hasCxxDtor)
{
ASSERT(!isTaggedPointer());
if (!nonpointer) {
isa = isa_t((uintptr_t)cls);
} else {
ASSERT(!DisableNonpointerIsa);
ASSERT(!cls->instancesRequireRawIsa());
isa_t newisa(0);
#if SUPPORT_INDEXED_ISA
ASSERT(cls->classArrayIndex() > 0);
newisa.bits = ISA_INDEX_MAGIC_VALUE;
// isa.magic is part of ISA_MAGIC_VALUE
// isa.nonpointer is part of ISA_MAGIC_VALUE
newisa.has_cxx_dtor = hasCxxDtor;
newisa.indexcls = (uintptr_t)cls->classArrayIndex();
#else
newisa.bits = ISA_MAGIC_VALUE;
// isa.magic is part of ISA_MAGIC_VALUE
// isa.nonpointer is part of ISA_MAGIC_VALUE
newisa.has_cxx_dtor = hasCxxDtor;
newisa.shiftcls = (uintptr_t)cls >> 3;
#endif
isa = newisa;
}
}
总结
这就是 alloc 的完整流程；
通过ISA的关联，我们就完成了一个对象的内存分配情况，也就是一个对象的alloc 的完整流程，因为任何一个类对象都可以通过ISA指针找到相应的父类，以及元类，这样对象的各种初始化实例方法都能通过ISA指针指向找到相应的IMP。从而调用方法进行消息转发。
666
这就是alloc的大致流程
init 源码探索
alloc源码探索完了，接下来探索init源码，通过源码可知，inti的源码实现有以下两种
类方法 init
+ (id)init {
return (id)self;
}
这里的init是一个构造方法 ，是通过工厂设计（工厂方法模式）,主要是用于给用户提供构造方法入口。这里能使用id强转的原因，主要还是因为 内存字节对齐后，可以使用类型强转为你所需的类型
实例方法 init
- 通过以下代码进行探索实例方法 init
LGPerson *objc = [[LGPerson alloc] init];
- 通过
main中的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;
}
有上述代码可以，返回的是传入的self本身。
new 源码探索
一般在开发中，初始化除了init，还可以使用new，两者本质上并没有什么区别，以下是objc中new的源码实现，通过源码可以得知，new函数中直接调用了callAlloc函数（即alloc中分析的函数），且调用了init函数，所以可以得出new 其实就等价于 [alloc init]的结论
+ (id)new {
return [callAlloc(self, false/*checkNil*/) init];
}
但是一般开发中并不建议使用new，主要是因为有时会重写init方法做一些自定义的操作，例如 initWithXXX，会在这个方法中调用[super init]，用new初始化可能会无法走到自定义的initWithXXX部分。
例如，在CJLPerson中有两个初始化方法，一个是重写的父类的init，一个是自定义的initWithXXX方法，如下图所示
image
-
使用 alloc + init 初始化时，打印的情况如下
image
-
使用new 初始化时，打印的情况如下
image
总结
- 如果子类没有重写父类的init，new会调用父类的init方法
- 如果子类重写了父类的init，new会调用子类重写的init方法
- 如果使用 alloc + 自定义的init，可以帮助我们自定义初始化操作，例如传入一些子类所需参数等，最终也会走到父类的init，相比new而言，扩展性更好，更灵活。
谢谢你的阅读!
链接：https://www.jianshu.com/p/b72018e88a97
推荐参考:https://www.jianshu.com/p/dbba973c7446
