二 OC底层原理 探究 OC 对象创建过程

前言

在 iOS 的开发中使用的 Objective C 语言，它是一种面向对象的语言，但是对象是怎么产生吗，怎么被创建的呢？ 下面我们就来看看

对象的创建

在 OC 中，我们创建对象 一般有两种方法

• [[class alloc] ] init]
• [class new]

先看个案例

我们先定一个 Object 的类

@interface TObject : NSObject

@end

@implementation TObject

@end

案例

    TObject *ob = [TObject alloc];
    TObject * oba = [TObject alloc];
    TObject * ob1 = [ob init];
    TObject * ob2 = [ob1 init];
    
    NSLog(@"%p -- %p",ob,&ob);
    NSLog(@"%p -- %p",ob1,&ob1);
    NSLog(@"%p -- %p",ob2,&ob2);
    NSLog(@"%p -- %p",oba,&oba);
======= 输出结果如下======
2020-12-05 23:04:23.493569+0800 OC[2258:77272] 0x600003c80290 -- 0x7ffee9ee01a8
2020-12-05 23:04:23.493781+0800 OC[2258:77272] 0x600003c80290 -- 0x7ffee9ee01a0
2020-12-05 23:04:23.493918+0800 OC[2258:77272] 0x600003c80290 -- 0x7ffee9ee0198
2020-12-05 23:04:23.494045+0800 OC[2258:77272] 0x600003c8c8e0 -- 0x7ffee9ee0190

从案例可以看出，三者对象地址相同，说明是同一个对象，但是对象指针地址又不一样，为什么会这样呢？alloc 和 init 到底做了什么呢？

带着疑问 我们接下来探究

我们先看看 alloc init 是如何创建的

1. alloc 源码探索

---

通过断点 汇编调试， callq汇编指令 也就是调用函数的意思

1. 可以看见第一步调用了 objc_alloc 函数
   

   image.png

2. 接着调用了 alloc
   

   image.png

3. 调用 objc_rootAlloc

image.png

4. 调用了 _objc_rootAllocWithZone

相关源码展示

objc_alloc(Class cls)
{
    return callAlloc(cls, true/*checkNil*/, false/*allocWithZone*/);
}


static ALWAYS_INLINE id
callAlloc(Class cls, bool checkNil, bool allocWithZone=false)
{
#if __OBJC2__
    if (slowpath(checkNil && !cls)) return nil;
    // 当类指针存在并实现了 allocWithZone 就不会走这里的代码
    if (fastpath(!cls->ISA()->hasCustomAWZ())) {
        return _objc_rootAllocWithZone(cls, nil);
    }
#endif

    // No shortcuts available.
    if (allocWithZone) {
        return ((id(*)(id, SEL, struct _NSZone *))objc_msgSend)(cls, @selector(allocWithZone:), nil);
    }
    return ((id(*)(id, SEL))objc_msgSend)(cls, @selector(alloc));
}

+ (id)alloc {
    return _objc_rootAlloc(self);
}

_objc_rootAlloc(Class cls)
{
    return callAlloc(cls, false/*checkNil*/, true/*allocWithZone*/);
}
// Replaced by ObjectAlloc
+ (id)allocWithZone:(struct _NSZone *)zone {
    return _objc_rootAllocWithZone(self, (malloc_zone_t *)zone);
}
_objc_rootAllocWithZone(Class cls, malloc_zone_t *zone __unused)
{
    // allocWithZone under __OBJC2__ ignores the zone parameter
    return _class_createInstanceFromZone(cls, 0, nil,
                                         OBJECT_CONSTRUCT_CALL_BADALLOC);
}

 // 这个方法表示 当类或者父类有自定义的 alloc/allocWithZone 方法时 返回 false 否则 返回 true
bool hasCustomAWZ() const {
// FAST_CACHE_HAS_DEFAULT_AWZ:
//class or superclass has default alloc/allocWithZone: implementation
        return !cache.getBit(FAST_CACHE_HAS_DEFAULT_AWZ);
   }

#define fastpath(x) (__builtin_expect(bool(x), 1))
#define slowpath(x) (__builtin_expect(bool(x), 0))
两者都是指令优化编译器编译时的代码布局
fastpath 很有可能为 true，slowpath表示很有可能为 false

顺序分为两种情况

当该类第一次被使用的时候
objc_alloc -> callAlloc(cls,true,false)
在 callAlloc 方法中 由于cls 还没有 指针 isa，当然也就没有所谓的 allocWithZone 方法了
所以调用了objc_msgSend(cls, @selector(alloc));
alloc -> callAlloc(cls, false, true) 

objc_alloc-> callAlloc(cls,true,false) 

未实现allocWithZone 方法时,就会运行 fastpath(!cls->ISA()->hasCustomAWZ()) 中的代码
这是的顺序就是
objc_alloc->callAlloc(cls,true,false)->_objc_rootAllocWithZone

实现的话
objc_alloc->callAlloc(cls,true,false)->allocWithZone -> _objc_rootAllocWithZone(self, (malloc_zone_t *)zone);

解析一下 _class_createInstanceFromZone

到底做了什么

/***********************************************************************
* class_createInstance
* fixme
* Locking: none
*
* Note: this function has been carefully written so that the fastpath
* takes no branch.
**********************************************************************/
static ALWAYS_INLINE id
_class_createInstanceFromZone(Class cls, size_t extraBytes, void *zone,
                              int construct_flags = OBJECT_CONSTRUCT_NONE,
                              bool cxxConstruct = true,
                              size_t *outAllocatedSize = nil)
{
    ASSERT(cls->isRealized());

    // Read class's info bits all at once for performance
    // 判断当前 Class 或者 superClass 是否有 cxxConstruct 构造方法的实现
    bool hasCxxCtor = cxxConstruct && cls->hasCxxCtor();
    // 判断当前 Class 或者 superClass 是否有 destruct 构造方法的实现
    bool hasCxxDtor = cls->hasCxxDtor();
    bool fast = cls->canAllocNonpointer();
    size_t size;
    // 计算对象内存大小
    size = cls->instanceSize(extraBytes);
    // 额外的空间
    if (outAllocatedSize) *outAllocatedSize = size;
    // 开辟内存空间
    id obj;
    //  zone 永远都是 false
    if (zone) {
        obj = (id)malloc_zone_calloc((malloc_zone_t *)zone, 1, size);
    } else {
        obj = (id)calloc(1, size);
    }
    // false
    if (slowpath(!obj)) {
        if (construct_flags & OBJECT_CONSTRUCT_CALL_BADALLOC) {
            return _objc_callBadAllocHandler(cls);
        }
        return nil;
    }

    if (!zone && fast) {
        // 到这里     初始化 isa, 关联 cls
        obj->initInstanceIsa(cls, hasCxxDtor);
    } else {
        // Use raw pointer isa on the assumption that they might be
        // doing something weird with the zone or RR.
        obj->initIsa(cls);
    }

    if (fastpath(!hasCxxCtor)) { 
        // 最终
        return obj;
    }

    construct_flags |= OBJECT_CONSTRUCT_FREE_ONFAILURE;
    return object_cxxConstructFromClass(obj, cls, construct_flags);
}

cls->instanceSize(extraBytes)是进行内存对齐得到的实例大小

    size_t instanceSize(size_t extraBytes) const {
        if (fastpath(cache.hasFastInstanceSize(extraBytes))) {
            return cache.fastInstanceSize(extraBytes);
        }

        size_t size = alignedInstanceSize() + extraBytes;
        // CF requires all objects be at least 16 bytes.
        if (size < 16) size = 16;
        return size;
    }
   // May be unaligned depending on class's ivars.
    uint32_t unalignedInstanceSize() const {
        ASSERT(isRealized());
        return data()->ro()->instanceSize;
    }

    // Class's ivar size rounded up to a pointer-size boundary.
    uint32_t alignedInstanceSize() const {
        return word_align(unalignedInstanceSize());
    }

static inline uint32_t word_align(uint32_t x) {
    return (x + WORD_MASK) & ~WORD_MASK;
}
#ifdef __LP64__
#   define WORD_SHIFT 3UL
#   define WORD_MASK 7UL
#   define WORD_BITS 64
#else
#   define WORD_SHIFT 2UL
#   define WORD_MASK 3UL
#   define WORD_BITS 32
#endif

由于 TObject 对象中没有任何属性,所以 extraBytes 是为0的,但是内存空间并不是0，因为 TObject 还有一个 isa 指针

@interface NSObject  {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wobjc-interface-ivars"
    Class isa  OBJC_ISA_AVAILABILITY;
#pragma clang diagnostic pop
}

通过计算可以得知，有一个对象指针，这个大小是8字节，所以到word_align 方法中 x 就是8，其中WORD_MASK在64位系统下是7，否则是3，因此，word_align()方法在64位系统下进行计算是8字节对齐按照里面的算法就是相当于8的倍数。返回到instanceSize()方法中的size就是对象需要的空间大小为8，因为里面有小于16的返回16。

所以 按照现在的算法 经过instanceSize 计算，内存最小是16，内存是8的倍数
-- 具体的下一篇详细探索

init 解析

- (id)init {
    return _objc_rootInit(self);
}
id
_objc_rootInit(id obj)
{
    // In practice, it will be hard to rely on this function.
    // Many classes do not properly chain -init calls.
    return obj;
}

没有任何操作 就是返回它本身的
可能是设计原则的关系，这样设计 方便开发者更好的自定义吧，可以在其中初始化一些设置

new 解析

可见 new 就是 callAlloc 和 init 方法的结合

+ (id)new {
    return [callAlloc(self, false/*checkNil*/) init];
}

问题

• 通过源码定义 jumpDefinition 时，alloc 应该是直接调用类方法 alloc 函数的，为什么会调用 objc_alloc 呢?

可能:

static void 
fixupMessageRef(message_ref_t *msg)
{    
   msg->sel = sel_registerName((const char *)msg->sel);

   if (msg->imp == &objc_msgSend_fixup) { 
// 当改方法的方法编号时 alloc 时，将方法函数实现 指向了 objc_alloc
       if (msg->sel == @selector(alloc)) {
           msg->imp = (IMP)&objc_alloc;
       } else if (msg->sel == @selector(allocWithZone:)) {
           msg->imp = (IMP)&objc_allocWithZone;
       } else if (msg->sel == @selector(retain)) {
           msg->imp = (IMP)&objc_retain;
       } else if (msg->sel == @selector(release)) {
           msg->imp = (IMP)&objc_release;
       } else if (msg->sel == @selector(autorelease)) {
           msg->imp = (IMP)&objc_autorelease;
       } else {
           msg->imp = &objc_msgSend_fixedup;
       }
   } 
   else if (msg->imp == &objc_msgSendSuper2_fixup) { 
       msg->imp = &objc_msgSendSuper2_fixedup;
   } 
   else if (msg->imp == &objc_msgSend_stret_fixup) { 
       msg->imp = &objc_msgSend_stret_fixedup;
   } 
   else if (msg->imp == &objc_msgSendSuper2_stret_fixup) { 
       msg->imp = &objc_msgSendSuper2_stret_fixedup;
   } 

最后 附上一张初始化流程图

image.png