Objc源码之对象创立alloc和init
Objc源码之对象创立alloc和init
Objc源码之initialize实现
Objc源码之Load方法实现
Objc源码之NSObject和isa
Objc源码之引用计数实现
objc源码之Method消息发送
前言
我们平常经常会写下这样的代码:
NSObject *obj1 = [[NSObject alloc] init];NSObject *obj2 = [NSObject new];那么alloc和init还有new,到底是怎样创立对象和初始化对象的呢???
注:本文分析基于objc4-750源码进行的。
一、alloc具体实现
下面我们就来看下alloc和init的源码,来分析对象的创立过程:
+ (id)alloc { return _objc_rootAlloc(self);}当调用alloc的时候,会继续调用_objc_rootAlloc函数,下面看下_objc_rootAlloc函数的实现:
id _objc_rootAlloc(Class cls){ return callAlloc(cls, false/*checkNil*/, true/*allocWithZone*/);}_objc_rootAlloc函数会继续调用callAlloc函数,我们看下callAlloc实现:
static ALWAYS_INLINE id callAlloc(Class cls, bool checkNil, bool allocWithZone=false){ if (slowpath(checkNil && !cls)) return nil;#if __OBJC2__ //1.判断能否有自己设置allocWithZone,没有的话,调用下面的方法。 if (fastpath(!cls->ISA()->hasCustomAWZ())) { // 1.1查看一下类能否能快速分配内存 if (fastpath(cls->canAllocFast())) { //1.1.1 能否有析构函数 bool dtor = cls->hasCxxDtor(); //1.1.2 分配内存 id obj = (id)calloc(1, cls->bits.fastInstanceSize()); //1.1.3能否分配成功 if (slowpath(!obj)) return callBadAllocHandler(cls); //1.1.4 初始化isa指针 obj->initInstanceIsa(cls, dtor); return obj; } else { // 1.2.1分配内存 id obj = class_createInstance(cls, 0); //1.2.2能否分配成功 if (slowpath(!obj)) return callBadAllocHandler(cls); return obj; } }#endif //2. 假如allocWithZone使用 allocWithZone分配内存 if (allocWithZone) return [cls allocWithZone:nil]; //3.继续调用alloc return [cls alloc];}关于fastpath和slowpath
所以fastpath的含义是,为1的概率大,slowpath的含义是为0的概率大。是为了优化编译器使用的。总结callAlloc函数的过程如下:
1.假如没有自己设置allocWithZone。
fastpath(!cls->ISA()->hasCustomAWZ()??bool hasCustomAWZ() { return ! bits.hasDefaultAWZ();}??bool hasDefaultAWZ() { return data()->flags & RW_HAS_DEFAULT_AWZ;}??#define RW_HAS_DEFAULT_AWZ (1<<16)这里是通过判断class_rw_t* data()中的flags中的值的第16位,来判断是重写了allocWithZone。关于class_rw_t和flags我会在其它文章解释。
1.1假如能快速分配内存
fastpath(cls->canAllocFast())??bool canAllocFast() { assert(!isFuture()); return bits.canAllocFast();}??#if FAST_ALLOC bool canAllocFast() { return bits & FAST_ALLOC; }#else bool canAllocFast() { return false; }#endif??#define FAST_ALLOC (1UL<<2)是否快速分配内存,是根据cls->bits->FAST_ALLOC来判断的,最终是通过
bits中的第二位来判断能否能快速分配内存。
1.1.2 分配内存
id obj = (id)calloc(1, cls->bits.fastInstanceSize());这里是通过calloc函数和 cls->bits.fastInstanceSize()分配的内存的。calloc函数是分配加初始化一起进行的。
C语言跟内存申请相关的函数主要有 alloca、calloc、malloc、realloc等.
1)alloca是向栈申请内存,因而无需释放.
2)malloc分配的内存是位于堆中的,并且没有初始化内存的内容,因而基本上malloc之后,调用函数memset来初始化这部分的内存空间.
3)calloc则将初始化这部分的内存,设置为0.
4)realloc则对malloc申请的内存进行大小的调整.
1.1.3 能否分配成功
if (slowpath(!obj)) return callBadAllocHandler(cls);1.1.4 初始化isa指针
obj->initInstanceIsa(cls, dtor);??inline void objc_object::initInstanceIsa(Class cls, bool hasCxxDtor){ initIsa(cls, true, hasCxxDtor);}??inline void objc_object::initIsa(Class cls, bool nonpointer, bool hasCxxDtor) { assert(!isTaggedPointer()); if (!nonpointer) { isa.cls = cls; } else { assert(!DisableNonpointerIsa); assert(!cls->instancesRequireRawIsa()); isa_t newisa(0); newisa.bits = ISA_MAGIC_VALUE; newisa.has_cxx_dtor = hasCxxDtor; newisa.shiftcls = (uintptr_t)cls >> 3; isa = newisa; }}这里重点看下说下isa的初始化,从上面可以看到isa初始化主要是bits、has_cxx_dtor、shiftcls这三个字段,那么这三个字段是什么呢
bits一共64位,包含类指针、能否有关联对象,析构函数等等,下面是arm64和x86_64架构下bits的含义
# if __arm64__# define ISA_MASK 0x0000000ffffffff8ULL# define ISA_MAGIC_MASK 0x000003f000000001ULL# define ISA_MAGIC_VALUE 0x000001a000000001ULL struct { uintptr_t indexed : 1; uintptr_t has_assoc : 1; uintptr_t has_cxx_dtor : 1; uintptr_t shiftcls : 33; // MACH_VM_MAX_ADDRESS 0x1000000000 uintptr_t magic : 6; uintptr_t weakly_referenced : 1; uintptr_t deallocating : 1; uintptr_t has_sidetable_rc : 1; uintptr_t extra_rc : 19;# define RC_ONE (1ULL<<45)# define RC_HALF (1ULL<<18) };# elif __x86_64__# define ISA_MASK 0x00007ffffffffff8ULL# define ISA_MAGIC_MASK 0x001f800000000001ULL# define ISA_MAGIC_VALUE 0x001d800000000001ULL struct { uintptr_t indexed : 1; uintptr_t has_assoc : 1; uintptr_t has_cxx_dtor : 1; uintptr_t shiftcls : 44; // MACH_VM_MAX_ADDRESS 0x7fffffe00000 uintptr_t magic : 6; uintptr_t weakly_referenced : 1; uintptr_t deallocating : 1; uintptr_t has_sidetable_rc : 1; uintptr_t extra_rc : 8;# define RC_ONE (1ULL<<56)# define RC_HALF (1ULL<<7) };
arm64
X86_64
arm64下 ISA_MAGIC_VALUE对应的二进制是11010000000000000000000000000000000000001,结构如下图:
ISA_MAGIC_VALUE初始化
has_cxx_dtor
表示该对象能否有 C++ 或者者 Objc 的析构器
shiftcls
类的指针。arm64架构中有33位可以存储类指针。
源码中isa.shiftcls = (uintptr_t)cls >> 3;
将当前地址右移三位的主要起因是用于将 Class 指针中无用的后三位清理减小内存的消耗,由于类的指针要按照字节(8 bits)对齐内存,其指针后三位都是没有意义的 0。
这就是ISA指针的初始化内容,暂且先理解这么多。
1.2 假如不能快速分配内存
1.2.1分配内存
假如不能快速分配内存,使用class_createInstance来分配内存
id obj = class_createInstance(cls, 0);??id class_createInstance(Class cls, size_t extraBytes){ return _class_createInstanceFromZone(cls, extraBytes, nil);}??id _class_createInstanceFromZone(Class cls, size_t extraBytes, void *zone, bool cxxConstruct = true, size_t *outAllocatedSize = nil){ if (!cls) return nil; assert(cls->isRealized()); // Read class's info bits all at once for performance bool hasCxxCtor = cls->hasCxxCtor(); bool hasCxxDtor = cls->hasCxxDtor(); bool fast = cls->canAllocNonpointer(); size_t size = cls->instanceSize(extraBytes); if (outAllocatedSize) *outAllocatedSize = size; id obj; if (!zone && fast) { obj = (id)calloc(1, size); if (!obj) return nil; obj->initInstanceIsa(cls, hasCxxDtor); } else { if (zone) { obj = (id)malloc_zone_calloc ((malloc_zone_t *)zone, 1, size); } else { obj = (id)calloc(1, size); } if (!obj) return nil; obj->initIsa(cls); } if (cxxConstruct && hasCxxCtor) { obj = _objc_constructOrFree(obj, cls); } return obj;}我们看到这里面zone为nil,最终也是通过calloc来分配内存,之后初始化isa指针,假如有构造函数,调用构造函数。
1.2.2能否分配成功
if (slowpath(!obj)) return callBadAllocHandler(cls);2. 假如allocWithZone为True ,使用 allocWithZone分配内存
if (allocWithZone) return [cls allocWithZone:nil];3.继续调用alloc进行内存分配
return [cls alloc];以上就是这就是alloc的整个过程,总结为三步:
1.假如没有自己设置allocWithZone
2. 假如allocWithZone为True ,使用 allocWithZone分配内存
3. 继续调用alloc进行内存分配
二、init实现
下面我们看下init的代码实现:
- (id)init { return _objc_rootInit(self);}??id _objc_rootInit(id obj){ return obj;}从上面代码可以看出,init只是返回了对象本身。并没有初始化对象,其实这里的初始化操作已经在alloc中做了,这里跟我们认为的alloc负责内存分配,init负责初始化的还是挺不一样的。
于是我又做了试验:
TestObject.h@interface TestObject : NSObject@property(nonatomic, assign) NSInteger num;@property(nonatomic, strong) NSObject *obj;@endmain.mTestObject *obj = [TestObject alloc];NSLog(@"TestObject.num=%ld",(long)obj.num);NSLog(@"TestObject.obj=%@",obj.obj);结果:
2019-08-04 14:31:13.294387+0800 objc-debug[5002:2825779] TestObject.num=02019-08-04 14:31:13.294401+0800 objc-debug[5002:2825779] TestObject.obj=(null)所以,以后我们创立对象的时候,是不是可以不写init了???
于是我又查看了之前的objc源码,较早包含NSObject.mm版本是objc4-532,里面的init也只是返回self。那么假如是直接继承自NSObject,并且没有重写init方法的类,可以不写init,直接使用alloc,但是像NSString、NSArray这种,就不能不调用init方法,会报错,会要调用init。
三、new的实现
我们可以看到new的实现,其实是和alloc调用的同一个函数callAlloc,所以可以说[NSObject new]和[[NSObject alloc] init]是等价的,源码如下:
+ (id)new { return [callAlloc(self, false/*checkNil*/) init];}四、对象的内存分配
首先我们看下这个实例:
TestObject.h@interface TestObject : NSObject@property(nonatomic, assign) long num;@property(nonatomic, assign) int num1;@property(nonatomic, assign) long num2;@property(nonatomic, strong) NSObject *obj;@endmain.mint main(int argc, const char * argv[]) { @autoreleasepool { TestObject *obj = [TestObject new]; NSLog(@"InstanceSize:%zd",class_getInstanceSize([obj class])); NSLog(@"ClassSize:%zd",malloc_size((__bridge const void *)obj)); NSObject *obj1 = [NSObject new]; NSLog(@"InstanceSize:%zd",class_getInstanceSize([obj1 class])); NSLog(@"ClassSize:%zd",malloc_size((__bridge const void *)obj1)); } return 0;}arm64下打印结果是:
TestObject:InstanceSize:40ClassSize:48NSObject:InstanceSize:8ClassSize:16下面我们来分析下打印结果:
我们先分析下NSObject对象:
struct NSObject_IMPL{ class isa}由于NSObject只含有一个isa指针,多有实例变量的内存是8字节。那ClassSize为什么是16呢?
不论是使用new还是alloc,底层都是用callAlloc来给对象分配内存的,下面我们看下callAlloc的部分源码:
static ALWAYS_INLINE idcallAlloc(Class cls, bool checkNil, bool allocWithZone=false){ ... id obj = class_createInstance(cls, 0); if (slowpath(!obj)) return callBadAllocHandler(cls); return obj; ...}这里是使用class_createInstance分配内存的,接下来看其源码:
id class_createInstance(Class cls, size_t extraBytes){ return _class_createInstanceFromZone(cls, extraBytes, nil);}static __attribute__((always_inline)) id _class_createInstanceFromZone(Class cls, size_t extraBytes, void *zone, bool cxxConstruct = true, size_t *outAllocatedSize = nil){ if (!cls) return nil; assert(cls->isRealized()); // Read class's info bits all at once for performance bool hasCxxCtor = cls->hasCxxCtor(); bool hasCxxDtor = cls->hasCxxDtor(); bool fast = cls->canAllocNonpointer(); size_t size = cls->instanceSize(extraBytes); if (outAllocatedSize) *outAllocatedSize = size; id obj; if (!zone && fast) { obj = (id)calloc(1, size); if (!obj) return nil; obj->initInstanceIsa(cls, hasCxxDtor); } else { if (zone) { obj = (id)malloc_zone_calloc ((malloc_zone_t *)zone, 1, size); } else { obj = (id)calloc(1, size); } if (!obj) return nil; // Use raw pointer isa on the assumption that they might be // doing something weird with the zone or RR. obj->initIsa(cls); } if (cxxConstruct && hasCxxCtor) { obj = _objc_constructOrFree(obj, cls); } return obj;}我们在_class_createInstanceFromZone中看到非常重要的一句,size_t size = cls->instanceSize(extraBytes);也就是最后分配对象的内存大小,我们是在instanceSize中:
size_t instanceSize(size_t extraBytes) { size_t size = alignedInstanceSize() + extraBytes; // CF requires all objects be at least 16 bytes. if (size < 16) size = 16; return size;}我们看到这里面再分配对象的时候,假如对象小于16个字节,也要分配16字节的,具体起因是什么呢?有一行注释说明CF requires all objects be at least 16 bytes.
下面我们再看下TestObject的内存分配,对应的结构应该是:
struct TestObject_IMPL{ class isa;//8 long _num;//8 int _num1;//4 long _num2;//8 NSObject _obj;//8}TestObjects的实例对象应该是8+8+4+8+8,一共36字节,但是实际是40,这是为什么呢,这是因内存对齐的起因:
结构体存在一个内存对其的操作,这样有利于CPU的访问,结构体为了保证内存对其 最重的真用内存肯定是占用最大的一个变量的倍数, 在这里我们isa占用了8个字节数, 所以尽管实际上只使用了36个字节,但是为了保证内存对其的规则 所以使用了40个字节.
这里TestObjects的类对象大小是48,而不是40,这里也是因为内存对齐的起因。
参考:
objc4-750源码
神经病院 Objective-C Runtime 入院第一天—— isa 和 Class
Objective-C Runtime
窥探iOS底层实现–OC对象的本质(一) – 掘金
iOS底层原理探索- NSObject 所占内存 – 掘金
iOS内存管理的那些事儿-原理及实现
从NSArray看类簇
1. 本站所有资源来源于用户上传和网络,如有侵权请邮件联系站长!
2. 分享目的仅供大家学习和交流,您必须在下载后24小时内删除!
3. 不得使用于非法商业用途,不得违反国家法律。否则后果自负!
4. 本站提供的源码、模板、插件等等其他资源,都不包含技术服务请大家谅解!
5. 如有链接无法下载、失效或广告,请联系管理员处理!
6. 本站资源售价只是摆设,本站源码仅提供给会员学习使用!
7. 如遇到加密压缩包,请使用360解压,如遇到无法解压的请联系管理员
开心源码网 » Objc源码之对象创立alloc和init