Objc源码——对象建立alloc和init
前言
咱们平时常常会写下这样的代码：bash
NSObject *obj1 = [[NSObject alloc] init];
NSObject *obj2 = [NSObject new];
复制代码
那么alloc和init还有new，到底是怎么建立对象和初始化对象的呢？？？
注：本文分析基于objc4-750源码进行的。架构
1、alloc具体实现
下面咱们就来看下alloc和init的源码，来分析对象的建立过程：app
+ (id)alloc {
return _objc_rootAlloc(self);
}
复制代码
当调用alloc的时候，会继续调用_objc_rootAlloc函数，下面看下_objc_rootAlloc函数的实现：ide
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我会在其它文章解释。ui
1.1若是能快速分配内存atom
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 分配内存spa
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下 ISA_MAGIC_VALUE对应的二进制是11010000000000000000000000000000000000001，结构以下图：
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进行内存分配
2、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;
@end
main.m
TestObject *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=0
2019-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。
3、new的实现
咱们能够看到new的实现，实际上是和alloc调用的同一个函数callAlloc,因此能够说[NSObject new]和[[NSObject alloc] init]是等价的，源码以下：
+ (id)new {
return [callAlloc(self, false/*checkNil*/) init];
}
复制代码
4、对象的内存分配
首先咱们看下这个实例：
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;
@end
main.m
int 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:40
ClassSize:48
NSObject:
InstanceSize:8
ClassSize:16
复制代码
下面咱们来分析下打印结果：
咱们先分析下NSObject对象：
struct NSObject_IMPL{
class isa
}
复制代码
由于NSObject只含有一个isa指针，多有实例变量的内存是8字节。那ClassSize为何是16呢？
不论是使用new仍是alloc，底层都是用callAlloc来给对象分配内存的，下面咱们看下callAlloc的部分源码：
static ALWAYS_INLINE id
callAlloc(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，这里也是因为内存对齐的缘由。
做为一个开发者，有一个学习的氛围和一个交流圈子特别重要，这是个人交流群（123），你们有兴趣能够进群里一块儿交流学习
若是您以为写得不错，请给我一个赞！
- 1. 汇编跟踪 Objc alloc 实现 & init
- 2. ObjC的initialize和init
- 3. objc源码解析-ObjectiveC对象结构
- 4. 随便说说 alloc 和 init
- 5. alloc init初始化后对象依然还在父视图
- 6. iOS 底层探索对象篇之 alloc & init
- 7. iOS之武功秘籍①：OC对象原理-上(alloc & init & new)
- 8. iOS的OC对象建立的alloc原理
- 9. iOS new 和alloc/init 的区别
- 10. IOS底层原理之alloc、init和new
- 更多相关文章...
- • Kotlin 类和对象 - Kotlin 教程
- • Scala 类和对象 - Scala教程
- • 适用于PHP初学者的学习线路和建议
- • IntelliJ IDEA 代码格式化配置和快捷键
-
每一个你不满意的现在，都有一个你没有努力的曾经。