阅读 113

Objc源码——对象创建alloc和init

前言

我们平时经常会写下这样的代码:

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;

@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,这里也是由于内存对齐的原因。

作为一个开发者,有一个学习的氛围和一个交流圈子特别重要,这是我的交流群(123),大家有兴趣可以进群里一起交流学习

如果您觉得写得不错,请给我一个赞!


关注下面的标签,发现更多相似文章
评论