alloc&init 探索
- 首先要明确alloc做了什么，init做了什么。
#import "ViewController.h"
#import "Person.h"
@interface ViewController ()
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
// Do any additional setup after loading the view.
Person *p1 = [Person alloc];
Person *p2 = [p1 init];
Person *p3 = [p1 init];
SSNSLog(@"%@",p1);
SSNSLog(@"%@",p2);
SSNSLog(@"%@",p3);
}
@end
上方的p1/p2/p3经打印是一模一样的
截屏2021-03-22 下午2.15.39.png
分别打印p1/p2/p3的地址是否相同？
截屏2021-03-22 下午2.25.53.png
分别打印&p1/&p2/&p3的地址是否相同？
截屏2021-03-22 下午2.26.54.png
-
总结：为什么会出现这种情况？
因为init并没有对alloc出来的内存空间的指针进行任何修改，p2/p3的指针都是指向这块内存空间，这是为什么第二个是相等的。其实<Person: 0x600000b94040> 中冒号后面的0x600000b94040 就是指向的地址。
下图示意：
截屏2021-03-22 下午2.36.02.png
-
那么alloc是怎么开辟内存空间的呢，这里就需要看底层的实现了。这里记录三种方法去看
1.下符号断点的形式(Symbolic BreakPoint)跟流程，配合objc源码看源码；
2.通过摁住control-step into跟流程，配合objc源码；
3.汇编(Denug->Debug Workflow->Always Show Disassembly)查看跟流程。(最常用)
这里贴出苹果开源源码地址: https://opensource.apple.com
这个地址⽤的更直接 https://opensource.apple.com/tarballs/
- 我们可以在源码地址直接下载源码工程直接设置一个走读的工程，这样就可以直接打断点看源码了。这块的资料有很多就不再写了。我这里在github上防止一个配置好的objc4-781的工程，有需要的可以下载。
+ (id)alloc {
return _objc_rootAlloc(self);
}
// Replaced by ObjectAlloc
+ (id)allocWithZone:(struct _NSZone *)zone {
return _objc_rootAllocWithZone(self, (malloc_zone_t *)zone);
}
// Replaced by CF (throws an NSException)
+ (id)init {
return (id)self;
}
上面可以看到alloc调用的 _objc_rootAlloc 方法，接着往下找_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*/);
}
可以看到_objc_rootAlloc去调用了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));
}
上面我们看到callAlloc可能走两个方法：_objc_rootAllocWithZone 和 objc_msgSend。我们先看_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);
}
可以看到_objc_rootAllocWithZone直接调用的_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;
}
if (!zone && fast) {
//3.关联到相应的类
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);
}
这里_class_createInstanceFromZone 有三个关键的步骤instanceSize 和calloc和initInstanceIsa 作用备注了一下
首先看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;
}
这面是cache.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);
// 16 0 8
}
}
上面size=16 ；extra = 0 ； FAST_CACHE_ALLOC_DELTA16 = 8 最后16+0-8 = 8
#define FAST_CACHE_ALLOC_MASK 0x1ff8
#define FAST_CACHE_ALLOC_MASK16 0x1ff0
#define FAST_CACHE_ALLOC_DELTA16 0x0008
再看下align16的实现
static inline size_t align16(size_t x) {
return (x + size_t(15)) & ~size_t(15); //16字节对齐
}
这个函数明显是16字节对齐
0000 0000 0001 0111 8+15 = 23
& 1111 1111 1111 0000 ->15取反
相与后得到: 0000 0000 0001 0000 即16后面的都抹零，最后是16的倍数
- 所以，instanceSize作用是计算需要的内存空间大小。
现在去看calloc的实现，打断点po一下obj，打印出来是nil
截屏2021-03-22 下午5.44.11.png
走完calloc的实现，打断点po一下obj，打印出来是一个地址，现在已经开辟了内存了。但是只是一个指针，还没有关联到Person类
截屏2021-03-22 下午5.48.09.png
下面走到initInstanceIsa，把指针和类关联起来
截屏2021-03-22 下午5.53.09.png
- 所以alloc的流程图为：
截屏2021-03-22 下午6.08.03.png
- 从上面的结论看alloc已经完成了开辟空间并与Person类关联的工作，那么init的作用是什么呢？贴一下init的源码实现
+ (id)init {
return (id)self;
}
这是重写init的构造方法，工厂设计，给用户提供相应的入口
- 然后new的作用是什么呢？
+ (id)new {
return [callAlloc(self, false/*checkNil*/) init];
}
可以看到调用了alloc流程中的callAlloc流程，它把类对象也传了进去(Self),相当于调用了alloc+init
- 在这里回头看下_class_createInstanceFromZone 中的 size = cls->instanceSize(extraBytes); 当时走到这里的时候，看到大小是16,那么什么可以影响这个size大小呢？再把源码贴过来
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);
// 16 0 8
}
}
在这里我们先给Person增加一个name属性，再次走到这个方法看下size大小，可以看到仍然是16
截屏2021-03-23 上午10.29.42.png
然后我们再给Person增加一个nickName属性,再次走到这个方法看下size大小，可以看到已经变成了32
截屏2021-03-23 上午10.33.48.png
- 这里是字节对齐，所以对对象来说影响size大小的因素是属性，这里 8+8+8 = 24 然后字节对齐后是 32
- 今天听说[NSObject alloc]的流程的问题，跟了一下，附在这个后面，我是这样做的，在791的源码工程里main.m文件里
#import <Foundation/Foundation.h>
#import "Person.h"
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSObject *objc1 = [NSObject alloc];
Person *objc2 = [Person alloc];
NSLog(@"Hello, World! %@",objc2);
}
return 0;
}
打上断点，下图：
截屏2021-03-24 上午11.00.18.png
截屏2021-03-24 上午11.00.30.png
结果发生了，在main函数的14行直接走了第15行，并没有走+ (id)alloc。然后发现走的是objc_alloc函数
// Calls [cls alloc].
id
objc_alloc(Class cls)
{
return callAlloc(cls, true/*checkNil*/, false/*allocWithZone*/);
}
然后进入callAlloc 走 _objc_rootAllocWithZone 函数
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));
}
- 而[Person alloc] 的流程不是这样的，而是先后走了两次 callAlloc 函数
下面写下顺序：
- 先走objc_alloc函数
// Calls [cls alloc].
id
objc_alloc(Class cls)
{
return callAlloc(cls, true/*checkNil*/, false/*allocWithZone*/);
}
- 在callAlloc 函数中走的最后一行
return ((id(*)(id, SEL))objc_msgSend)(cls, @selector(alloc))
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));
}
这句去调用了alloc 函数，之后走的时候上面的alloc的流程。这才是一个最完整的流程
+ (id)alloc {
return _objc_rootAlloc(self);
}
- 所以为什么走两次呢？这里的分歧点在callAlloc 函数里 !cls->ISA()->hasCustomAWZ() 结果的不同导致的，在第一次进去callAlloc时，取true调用_objc_rootAllocWithZone，第二次取得值为false，走的最后((id(*)(id, SEL))objc_msgSend)(cls, @selector(alloc)), 去调用了alloc。这里大部分都写的是系统自己走的第一遍，没有过多研究。其实这里跟isa密切相关。
首先研究下ISA()这个函数，贴出源码
inline Class
objc_object::ISA()
{
ASSERT(!isTaggedPointer());
#if SUPPORT_INDEXED_ISA
if (isa.nonpointer) {
uintptr_t slot = isa.indexcls;
return classForIndex((unsigned)slot);
}
return (Class)isa.bits;
#else
return (Class)(isa.bits & ISA_MASK);
#endif
}
这里我们打断点走一下，在开始开始打印下isa 可以看到
截屏2021-03-24 下午1.35.17.png
然后向下走发现走的是最后一句return (Class)(isa.bits & ISA_MASK); 这句返回的是什么呢？ISA_MASK 查看宏定义是 0x00007ffffffffff8ULL ， 这里我特别看了下NSobject 和 Person的不同，如果是NSobject 打印的是
截屏2021-03-24 下午1.43.28.png
但是Person打印的是 ：
截屏2021-03-24 下午1.47.51.png
- 所以总结：Person 在第一次进入callAlloc里 !cls->ISA()->hasCustomAWZ()取得false(在ISA()函数里取得Person类，然后去获取hasCustomAWZ()取得false),取走的最后一句发消息调用alloc，而后第二次进去callAlloc，这时!cls->ISA()->hasCustomAWZ()拿到的true,才去开辟空间并关联了类。而NSobject的alloc流程早就在系统层面走完了。系统层面去研究就要看LLVM的源码了
网友评论