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下 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进行内存分配
二、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。
三、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;
@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，这里也是由于内存对齐的原因。
参考：
objc4-750源码
神经病院 Objective-C Runtime 入院第一天—— isa 和 Class
Objective-C Runtime
窥探iOS底层实现--OC对象的本质(一) - 掘金
iOS底层原理探究- NSObject 所占内存 - 掘金
iOS内存管理的那些事儿-原理及实现
从NSArray看类簇
