Objc源码之对象创立alloc和init

作者 : 开心源码 本文共9128个字,预计阅读时间需要23分钟 发布时间: 2022-05-13 共281人阅读

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)    };

arm64X86_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

发表回复