iOS底層探索 --- OC對象原理（上）

image

我們在日常開發(fā)中經(jīng)常會用到類似于下面的一段代碼來創(chuàng)建對象：

Person *p = [[Person alloc] init];

大家可以很明顯的注意到，創(chuàng)建一個對象，需要經(jīng)歷alloc和init兩個方法的調(diào)用才能實現(xiàn)。那么今天我們就來探索其中的alloc究竟做了什么。

其實作為iOS開發(fā)者，大家很清楚，alloc是用來給對象開辟內(nèi)存的。那么究竟是怎么開辟內(nèi)存的呢？這是我們今天探索的重點。
首先我們要下載objc4的源碼，盡量下載最新的版本的。
其次，下載下來的源碼是不能編譯的，這里給大家推薦一篇文章，iOS_objc4-756.2 最新源碼編譯調(diào)試。大家可以參考這篇文章編譯自己的源碼。

alloc源碼探索

1、創(chuàng)建Person對象，如下：

image

我們在此處埋下斷點，跳進(jìn)alloc函數(shù)，會發(fā)現(xiàn)如下的函數(shù)調(diào)用棧：

  • 「第一步」進(jìn)入alloc函數(shù)的源碼：
+ (id)alloc {
    return _objc_rootAlloc(self);
}
  • 「第二步」在alloc源碼中，我們會發(fā)下，函數(shù)進(jìn)入了_objc_rootAlloc，我們跟進(jìn)去查看：
// Base class implementation of +alloc. cls is not nil.
// Calls [cls allocWithZone:nil].
id
_objc_rootAlloc(Class cls)
{
    return callAlloc(cls, false/*checkNil*/, true/*allocWithZone*/);
}
  • 「第三步」同樣的操作，我們進(jìn)入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));
}

這個時候，就有點懵了，源碼中出現(xiàn)了不同的分支。這個時候就需要我們進(jìn)行斷點調(diào)試了。

在斷點調(diào)試之前，我們首先來搞清楚callAlloc方法里面幾個關(guān)鍵判斷的意思。
1、 hasCustomAWZ。
首先我們跟進(jìn)hasCustomAWZ，發(fā)現(xiàn)其源碼實現(xiàn)是這樣的：

bool hasCustomAWZ() const {
        return !cache.getBit(FAST_CACHE_HAS_DEFAULT_AWZ);
    }

接著我們繼續(xù)跟進(jìn)FAST_CACHE_HAS_DEFAULT_AWZ，此時我們發(fā)現(xiàn)了我們先要的（注意源碼注釋）：

// class or superclass has default alloc/allocWithZone: implementation
// Note this is is stored in the metaclass.
#define FAST_CACHE_HAS_DEFAULT_AWZ    (1<<14)

也就是說cls->ISA()->hasCustomAWZ()是用來獲取類或父類中，是否有alloc/allocWithZone:的實現(xiàn)。（很顯然，此時我們的Person并沒有）

2、 我們知道了fastpath函數(shù)的參數(shù)是什么意思，下面我們就要看fastpath是什么意思了。

我們跟進(jìn)入發(fā)現(xiàn)：

#define fastpath(x) (__builtin_expect(bool(x), 1))
#define slowpath(x) (__builtin_expect(bool(x), 0))

fastpath&slowpath是兩個objc源碼中定義的宏。
調(diào)用的都是__builtin_expect。

__builtin_expect(bool exp, probability)的主要作用是進(jìn)行條件分支預(yù)測。
函數(shù)主要有兩個參數(shù)：
第一個參數(shù)：是一個布爾表達(dá)式
第二個參數(shù)：表明第一個參數(shù)為真值的概率，這個參數(shù)只能是1或0；當(dāng)取值為1時，表示布爾表達(dá)式大部分情況下的值為真值；當(dāng)取值為0時，表示布爾表達(dá)式大部分情況下的值是假值。
函數(shù)的返回值，就是第一個參數(shù)的表達(dá)式的值。

那也就是說fastpath(!cls->ISA()->hasCustomAWZ())的結(jié)果，其實就是!cls->ISA()->hasCustomAWZ()的結(jié)果。那么「第四步」就是進(jìn)入if里面的_objc_rootAllocWithZone。（這一點根據(jù)斷點調(diào)試也可以判斷出來）

3、這里還有一個判斷__OBJC2__
在源碼中，點不進(jìn)去，無法知道這個宏定義是干什么用的。但是我們可以根據(jù)下面的一段注釋來判斷大致意思：

image

由此可以推測__OBJC2__是用來判斷是否有編譯優(yōu)化。

  • 「第四步」_objc_rootAllocWithZone 
NEVER_INLINE
id
_objc_rootAllocWithZone(Class cls, malloc_zone_t *zone __unused)
{
    // allocWithZone under __OBJC2__ ignores the zone parameter
    // __OBJC2__ 下的 allocWithZone 忽略 zone 參數(shù)
    return _class_createInstanceFromZone(cls, 0, nil,
                                         OBJECT_CONSTRUCT_CALL_BADALLOC);
}
  • 「第五步」_class_createInstanceFromZone

_class_createInstanceFromZone是alloc整個流程的核心。

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)
{
    // 'Realized' --> '實現(xiàn)'
    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;

    // 計算需要開辟的內(nèi)存大小，根據(jù)上一個函數(shù)`_objc_rootAllocWithZone`可以知道，此時‘extraBytes’==‘0’
    size = cls->instanceSize(extraBytes);
    if (outAllocatedSize) *outAllocatedSize = size;

    id obj;
    if (zone) {
        obj = (id)malloc_zone_calloc((malloc_zone_t *)zone, 1, size);
    } else {
        // 同樣的根據(jù)`_objc_rootAllocWithZone`可以知道，`__OBJC2__`情況下，會進(jìn)入這里。
        // calloc --> 申請內(nèi)存，大小為`size`.
        obj = (id)calloc(1, size);
    }
    if (slowpath(!obj)) {
        if (construct_flags & OBJECT_CONSTRUCT_CALL_BADALLOC) {
            return _objc_callBadAllocHandler(cls);
        }
        return nil;
    }

    if (!zone && fast) {
        // 關(guān)聯(lián) cls(類) 與 objc指針(isa指針)
        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);
}

在整個_class_createInstanceFromZone中，最主要的是以下三個步驟：

  • size = cls->instanceSize(extraBytes);計算需要開辟的內(nèi)存大小。
  • obj = (id)calloc(1, size);申請內(nèi)存
  • obj->initInstanceIsa(cls, hasCxxDtor);關(guān)聯(lián)類和isa指針。
  • 「第六步」object_cxxConstructFromClass
    該函數(shù)的源碼也非常容易理解，因為官方的注釋給的很清楚。這里就截取關(guān)鍵部分，不再展示完整的源碼。
    image

    可以看到object_cxxConstructFromClass的返回值，如果是self就表示構(gòu)建成功；
    如果是nil就表示構(gòu)建失敗。

alloc流程圖

通過上面的探索，我們總結(jié)出alloc函數(shù)的調(diào)用流程圖如下：

image

Tips

上面我們探索了alloc的流程，里面有幾個知識點，這里我們擴(kuò)充一下：

1: 字節(jié)對齊 && 內(nèi)存對齊

這就是在_class_createInstanceFromZone中的size = cls->instanceSize(extraBytes);。
這里我們們進(jìn)入instanceSize:

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

在沒有緩存的情況下，我們會調(diào)用alignedInstanceSize()，那么我們就跟進(jìn)去：

```
// Class's ivar size rounded up to a pointer-size boundary.
// 類的 ivar 大小向上舍入到指針大小邊界
uint32_t alignedInstanceSize() const {
    return word_align(unalignedInstanceSize());
}
```

這里我們看一下unalignedInstanceSize()的返回值是多少，跟進(jìn)去我們發(fā)現(xiàn)，該返回值的大小由實例變量的大小決定，依賴于成員變量(ivars)：

```
// May be unaligned depending on class's ivars.
uint32_t unalignedInstanceSize() const {
    ASSERT(isRealized());
    return data()->ro()->instanceSize;
}
```

此時，我們的Person沒有自定義的成員變量，但是，返回值是8；這是因為NSObject本身有一個isa。如下：

image

而Class是struct *類型的：
image

同時objc_class繼承自最原始的objc_object:

image

  • 字節(jié)的對齊是 --- 8字節(jié)對齊
    這一點我們進(jìn)入word_align函數(shù)就能夠知道：
    image

    注意WORD_MASK為7，根據(jù)算法，word_align返回值，永遠(yuǎn)是8的倍數(shù)。

算法講解：
首先我們知道此時：x = 8 && WORD_MASK = 7；
那么函數(shù)中的計算公式就是：(8 + 7) & ~7 也就是 15 & ~7。
15的二進(jìn)制是 ---> 0000 1111。
7的二進(jìn)制是 ---> 0000 0111，那么~7為 ---> 1111 1000。
那么15 & ~7 就是 0000 1111 & 1111 1000，結(jié)果為0000 1000 == 8

  • 內(nèi)存對齊是 --- 16字節(jié)對齊
    在instanceSize中，如果有緩存，會調(diào)用fastInstanceSize函數(shù)：
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);
        }
    }

大家可以看到，函數(shù)的最后，會調(diào)用align16：

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

這個也不難理解，算法跟上面字節(jié)對齊的算法是一樣的。但是這里保證的返回值是16的倍數(shù)。

2: __builtin_expect(bool exp, probability)

這個函數(shù)我們在上面已經(jīng)簡單介紹過了，這里我們再來詳細(xì)的介紹一下（參考文章：LLVM編譯器中的內(nèi)置(built-in)函數(shù)）：
這個函數(shù)的主要作用是進(jìn)行條件分支預(yù)測。函數(shù)主要有兩個參數(shù)：第一個參數(shù)是布爾表達(dá)式、第二個參數(shù)表明第一個參數(shù)的值為真值的概率，這個參數(shù)只能取1或0。

當(dāng)取值為1時，表示布爾表達(dá)式大部分情況下的值是真值，而取值為0時，表示布爾表達(dá)式大部分情況下的值是假值。

函數(shù)的返回值就是第一個參數(shù)的表達(dá)式的值。

在一條指令執(zhí)行時，由于流水線的作用，CPU可以完成下一條指令的取值，這樣可以提高CPU的利用率。在執(zhí)行一條條分支指令時，CPU也會預(yù)取下一條執(zhí)行，但是如果條件分支跳轉(zhuǎn)到其他指令，那么CPU預(yù)取的下一條指令就沒用了，這樣就降低了流水線的效率。__builtin_expect函數(shù)可以優(yōu)化程序編譯后的指令序列，使指令盡可能的順序執(zhí)行，從而提高CPU預(yù)取指令的正確率。
例如：

if (__builtin_expect (x, 0))
    foo();

表示：x的值大部分情況下可能為假，因此foo()函數(shù)得到執(zhí)行的機(jī)會比較少。這樣編譯器在編譯這段代碼的時候，就不會將foo()函數(shù)的匯編指令緊挨著if條件跳轉(zhuǎn)指令。
再比如：

if (__builtin_expect (x, 1))
    foo();

表示：x的值大部分情況下可能為真，因此foo()函數(shù)得到執(zhí)行的機(jī)會比較大。這樣編譯器在編譯這段代碼的時候，就會將foo()函數(shù)的匯編指令緊挨著if條件跳轉(zhuǎn)指令。

為了簡化函數(shù)使用，iOS系統(tǒng)使用兩個宏fastpath和slowpath來實現(xiàn)這種分支優(yōu)化判斷處理：

#define fastpath(x) (__builtin_expect(bool(x), 1))
#define slowpath(x) (__builtin_expect(bool(x), 0))
最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時請結(jié)合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務(wù)。

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容