iOS开发底层探究之路

iOS底层 - OC对象的创建流程

2020-09-06  本文已影响0人  Lcr111

iOS开发底层探究之路

iOS底层 - OC对象的创建流程（alloc流程图）

前言

生命在于不断学习，探索未知的世界！！！

本篇文章从对象的创建出发，探索iOS底层对象创建流程中所涉及到的相关知识点。

资料参考：

从OC对象创建开始

首先创建对象：
CRObject * obj = [CRObject alloc];

首先在此处打下断点。

接下来查看 alloc 方法的底层对应是什么。。。
插播三种查看 alloc 在iOS底层代码中实际调用方法的方式：

图片中就能清晰看出底层中的_objc_rootAlloc 方法。

那么问题来了！！！
我们外部调用的是 alloc 方法，为什么不调用，反而调用 objc_alloc 呢？
在查阅了一些资料，看到有两种情况：

  • Xcode 10会直接进入 alloc , Xcode 11 会直接进入 objc_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) { 
        if (msg->sel == SEL_alloc) {
            msg->imp = (IMP)&objc_alloc; // 这里就是符号绑定后对应所做的一些处理了.
        } else if (msg->sel == SEL_allocWithZone) {
            msg->imp = (IMP)&objc_allocWithZone;
        } else if (msg->sel == SEL_retain) {
            msg->imp = (IMP)&objc_retain;
        } else if (msg->sel == SEL_release) {
            msg->imp = (IMP)&objc_release;
        } else if (msg->sel == SEL_autorelease) {
            msg->imp = (IMP)&objc_autorelease;
        } else {
            msg->imp = &objc_msgSend_fixedup;
        }
    } 
    /*...*/
}

1、objc_alloc 与 alloc

alloc 类方法源码如下：

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

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

objc_alloc函数如下：

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

以上可以看出，不管是 alloc 还是 objc_alloc ，都会进入 callAlloc 这个函数。

2、callAlloc

static ALWAYS_INLINE id
callAlloc(Class cls, bool checkNil, bool allocWithZone=false)
{
#if __OBJC2__
    if (slowpath(checkNil && !cls)) return nil;
    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));
}

2.1 slowpath 与 fastpath

我们看到两个宏定义的函数：slowpath 与 fastpath 。
这里是编译器对代码进行了优化。意思大致是走 slowpath 的为小概率事件，走 fastpath 是大概率事件。

2.2 hasCustomAWZ

判断有没自己实现了 AllocWithZone 方法。这个可以根据类的结构体 objc_class 中的 hasCustomAWZ 方法判断。

bool hasCustomAWZ() const {
        return !(bits.data()->flags & RW_HAS_DEFAULT_AWZ);
    }

字面上可以看出 bits.data()->flags & RW_HAS_DEFAULT_AWZ 是判断是否有默认 AWZ ,也就是没有的话，那就是有CustomAWZ.
从下面 setHasDefaultAWZ 及 setHasCustomAWZ 可以看出，二者存一。

    void setHasDefaultAWZ() {
        bits.data()->setFlags(RW_HAS_DEFAULT_AWZ);
    }
    void setHasCustomAWZ() {
        bits.data()->clearFlags(RW_HAS_DEFAULT_AWZ);
    }

就像是在 RW 中做标记来标识用户有没有自己实现 allocWithZone .

由于类是懒加载概念的，当第一次给该类发消息之前，类并没有被加载，因此，当类第一次接收到 alloc ，进入到 !cls->ISA()->hasCustomAWZ() 时，最终为 false ，所以直接运行下面代码 return ((id(*)(id, SEL))objc_msgSend)(cls, @selector(alloc)), 就是 [cls alloc] .

2.3 _objc_rootAllocWithZone

此时代码进入下面：

if (fastpath(!cls->ISA()->hasCustomAWZ())) {
        return _objc_rootAllocWithZone(cls, nil);
    }

接着 进入 _objc_rootAllocWithZone :

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

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
    bool hasCxxCtor = cxxConstruct && cls->hasCxxCtor();
    bool hasCxxDtor = cls->hasCxxDtor();
    bool fast = cls->canAllocNonpointer();
    size_t size;
    // 1:要开辟多少内存
    size = cls->instanceSize(extraBytes);
    if (outAllocatedSize) *outAllocatedSize = size;

    id obj;
    if (zone) {
        obj = (id)malloc_zone_calloc((malloc_zone_t *)zone, 1, size);
    } else {
        // 2;怎么去申请内存
        obj = (id)calloc(1, size);
    }
    if (slowpath(!obj)) {
        if (construct_flags & OBJECT_CONSTRUCT_CALL_BADALLOC) {
            return _objc_callBadAllocHandler(cls);
        }
        return nil;
    }

    // 3: ?
    if (!zone && fast) {
        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);
}

好！来到了本文章的重点了，这一步才开始创建对象，分配内存空间。

2.4 hasCxxCtor 和 hasCxxDtor

这两个其实一开始是 objc++ 中用来处理 c++ 成员变量的构造和析构的，后来用 在 ARC 下对象释放时候处理内存释放的（.cxx_destruct）。

2.5 instanceSize

这里就开始计算当前对象开辟内存空间了，也就涉及到了经常被提及的内存对齐。

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

可以看到如果缓存判断 hasFastInstanceSize ，则会直接进入 fastInstanceSize

size_t fastInstanceSize(size_t extra) const
    {
        ASSERT(hasFastInstanceSize(extra));

        if (__builtin_constant_p(extra) && extra == 0) {
            return _flags & FAST_CACHE_ALLOC_MASK16;
        } else {
            size_t size = _flags & FAST_CACHE_ALLOC_MASK;
            // remove the FAST_CACHE_ALLOC_DELTA16 that was added
            // by setFastInstanceSize
            return align16(size + extra - FAST_CACHE_ALLOC_DELTA16);
        }
    }

static inline size_t align16(size_t x) {
    return (x + size_t(15)) & ~size_t(15);
}

属性64位下满足8字节对齐，32位下满足4字节对齐。
64位下使用 (x + size_t(15)) & ~size_t(15) 做一个字节对齐的工作，同时，满足最小 16 字节 （if (size < 16) size = 16）.

2.6 calloc

obj = (id)calloc(1, size);
此处的 obj po 出来为 一个指针,指向 calloc 所开辟的空间。
在拿到对象需要的内存空间大小后，通过 calloc 去内存里面申请一块 size 大小的空间。

2.7 initInstanceIsa

inline void 
objc_object::initInstanceIsa(Class cls, bool hasCxxDtor)
{
    ASSERT(!cls->instancesRequireRawIsa());
    ASSERT(hasCxxDtor == cls->hasCxxDtor());

    initIsa(cls, true, hasCxxDtor);
}

inline void 
objc_object::initIsa(Class cls, bool nonpointer, bool hasCxxDtor) 
{ 
    ASSERT(!isTaggedPointer()); 
    
    if (!nonpointer) {
        isa = isa_t((uintptr_t)cls);
    } else {
        ASSERT(!DisableNonpointerIsa);
        ASSERT(!cls->instancesRequireRawIsa());

        isa_t newisa(0);

#if SUPPORT_INDEXED_ISA
        ASSERT(cls->classArrayIndex() > 0);
        newisa.bits = ISA_INDEX_MAGIC_VALUE;
        // isa.magic is part of ISA_MAGIC_VALUE
        // isa.nonpointer is part of ISA_MAGIC_VALUE
        newisa.has_cxx_dtor = hasCxxDtor;
        newisa.indexcls = (uintptr_t)cls->classArrayIndex();
#else
        newisa.bits = ISA_MAGIC_VALUE;
        // isa.magic is part of ISA_MAGIC_VALUE
        // isa.nonpointer is part of ISA_MAGIC_VALUE
        newisa.has_cxx_dtor = hasCxxDtor;
        newisa.shiftcls = (uintptr_t)cls >> 3;
#endif

        // This write must be performed in a single store in some cases
        // (for example when realizing a class because other threads
        // may simultaneously try to use the class).
        // fixme use atomics here to guarantee single-store and to
        // guarantee memory order w.r.t. the class index table
        // ...but not too atomic because we don't want to hurt instantiation
        isa = newisa;
    }
}

这里就是初始化 isa ，并绑定cls；

3 init

- (id)init {
    return _objc_rootInit(self);
}

id _objc_rootInit(id obj)
{
    return obj;
}

可以看到 init 默认返回方法调用者, 其实是为了方便初始化对象时候做一些初始化或者赋值操作。比如 构造方法，工厂设计.

4 new

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

new 相当于 alloc + init. 推荐使用 后者，并可以重写各种 init 的工厂方法。

不断学习，不断探索！！！

上一篇下一篇

猜你喜欢

热点阅读