iOS原理探索系列-alloc&init原理探索

時間 2020-03-23

標籤 ios 原理探索系列 alloc&init alloc init 欄目 iOS 简体版

原文原文鏈接

歡迎你們繼續閱讀iOS原理探索系列篇章（後續陸續完善補充）算法

iOS原理探索系列之序章

iOS原理探索系列之alloc&init原理探索

1.探索背景

在序章中，初步探索了iOS程序啓動流程，可是不少東西都涉及系統底層庫的加載，以及一系列晦澀難懂的資料，因此爲了由淺入深的總結梳理，我這裏就從咱們最熟悉的陌生人對象開始。緩存

做爲程序猿，沒對象不可怕，可怕的是咱們竟然只能本身new一個對象出來，咱們新建對象的方式有兩種，以下： bash

那麼到底這兩種建立對象的方法在系統底層作了哪些事情，這個就是咱們今天要探索的方向。

2.探索方式

想要知道對象建立方法在底層到底作了哪些事情，咱們就須要去看源代碼的實現，正常咱們使用的方式就是跳轉到方法定義去查看實現，以下圖所示，咱們最多能到NSObject的方法聲明，沒法去查看具體的源代碼了，可是咱們仍是有其餘的方式能夠去查看源碼實現。 app

3.三種源碼調教手段

小斷點調試正常咱們打完斷點以下圖：函數

下面咱們按住control鍵，再看斷點，能夠看到出現了變化以下圖：

接下來咱們按住control的同時，點擊中間的下箭頭，能夠看到程序來到彙編：

咱們能夠知道，在咱們調用alloc方法時，系統底層調用了objc_alloc，因此咱們能夠添加符號斷點objc_alloc查看底層庫

能夠看到alloc底層庫是libobjc.A.dylib庫。
符號斷點調試一樣咱們能夠直接添加符號斷點alloc來查看底層庫實現，以下圖：源碼分析

而後咱們就能夠看到出現了很是多的alloc的調用

一樣能夠看到底層是libobjc.A.dylib庫實現。
開啓Debug Workflow模式經過前兩種方式咱們能夠看到，底層都是彙編，由於OC是高級語言，最終能被機器識別的仍是彙編語言，因此咱們能夠直接開啓查看彙編代碼模式，以下圖： post

開啓後，能夠看到以下效果，能夠看到彙編代碼中一樣出現了objc_alloc

而後咱們按照方式一按住control+下箭頭，繼續進入到objc_alloc的斷點，繼續往下走，看到以下，一樣可以看到objc_alloc

4. `libobjc.A.dylib`源碼分析

Apple其實開源了不少源碼給咱們，libobjc也是其中之一，想要直接查看源碼實現能夠按照以下操做：優化

官方objc源碼下載，最新版本是objc4-779.1

官方源碼調試編譯請查看Cooci老司機的這篇文章最新macOS 10.15下objc4-779.1源碼編譯調試

這裏我也下載編譯了最新的779.1，而後咱們能夠查看源代碼，可是咱們能夠看到源代碼很是多，大部分人一開始看確定很懵逼，因此咱們不用所有文件去看，只須要看咱們的目標代碼便可。 ui

就如同咱們在斷點調試中已經知道， alloc方法最終底層都是到NSObject的alloc方法，因此咱們能夠直接找到NSObject的頭文件，查看alloc方法的實現，也能夠全局搜索alloc {，以下圖： this

接下來咱們就能夠逐步去查看alloc的底層實現原理了。

5.`alloc`流程分析

咱們查看_objc_rootAlloc的具體實現能夠看到以下代碼，其實從註釋能夠很清晰的看到，全部建立類的初始化方法最終都是調用了callAlloc函數。
接下里咱們來具體分析下callAlloc函數到底作了作什麼，以下，因爲咱們目前基本上都是在objctive-c 2.0環境下，因此只須要看__OBJC2__這個判斷下的代碼便可。

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())) {
        // 這是判斷一個類是否有自定義的 +allocWithZone 實現。
        //hasCustomAWZ : hasCustomAllocWithZone
        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));
}
NEVER_INLINE
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);
}
複製代碼

最終來到實現函數_class_createInstanceFromZone，在實現函數中咱們能夠看到，咱們先爲obj申請分配了內存空間，而且綁定地址

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());
    //hasCxxCtor() 是判斷當前 class 或者 superclass 是否有 .cxx_construct 構造方法的實現。
    bool hasCxxCtor = cxxConstruct && cls->hasCxxCtor();
    //hasCxxDtor() 是判斷判斷當前 class 或者 superclass 是否有 .cxx_destruct 析構方法的實現。
    bool hasCxxDtor = cls->hasCxxDtor();
    //具體標記某個類是否支持優化的isa.
    bool fast = cls->canAllocNonpointer();
    size_t size;

    //獲取類的大小 （傳入額外字節的大小）
    size = cls->instanceSize(extraBytes);
    //若是傳入分配大小就須要修改
    if (outAllocatedSize) *outAllocatedSize = size;
    id obj; 
    if (zone) {
        obj = (id)malloc_zone_calloc((malloc_zone_t *)zone, 1, size);
    } else {
        /**
        *  void    *calloc(size_t __count, size_t __size)
        *  在內存的動態存儲區中分配 __count 個長度爲 __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) {
        // 對象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);
}&emsp;
複製代碼

6.`alloc`原理分析

關於_objc_rootAlloc，咱們經過代碼調試發現，這裏alloc點擊進入的爲_objc_rootAlloc其實咱們斷點後發現進入的是objc_alloc。（關於這個緣由，我後面會單獨分析下，這裏暫時不展開，由於最終你們調用的都是callAlloc這個函數）

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

//  這裏傳入了一個`Class`參數
typedef struct objc_class *Class;

// 咱們看下objc_class的結構
struct objc_class : objc_object {
    // Class ISA;
    Class superclass;
    cache_t cache;             // formerly cache pointer and vtable
    class_data_bits_t bits;    // class_rw_t * plus custom rr/alloc flags

    class_rw_t *data() const {
        return bits.data();
    }
...
// 再看看objc_object的結構
struct objc_class {
    Class _Nonnull isa  OBJC_ISA_AVAILABILITY;
} OBJC2_UNAVAILABLE;
複製代碼

因爲咱們新建的是一個objc_class類，objc_class又繼承於objc_class，objc_class存儲了isa的一個Class結構體，指向當前是什麼類。

關於callAlloc函數
- if (slowpath(checkNil && !cls)) return nil;斷定當前類是否存在
```
//__builtin_expect 經常使用於 if-else 的判斷爲了優化判斷的速度。
//bool(x) 爲真的可能性更大,if 下的代碼執行的可能性更高
#define fastpath(x) (__builtin_expect(bool(x), 1))
//bool(x) 爲假的可能性更大,else 下的代碼執行的可能性更高
#define slowpath(x) (__builtin_expect(bool(x), 0))
複製代碼
```
- if (fastpath(!cls->ISA()->hasCustomAWZ()))的判斷
  hasCustomAWZ其實就是 hasCustomAllocWithZone的意思，因此這裏用來斷定繼承了NSObject/NSProxy的類纔會進入這裏。
- 關於_class_createInstanceFromZone函數能夠看到_objc_rootAllocWithZone裏面最終調用的就是_class_createInstanceFromZone
- hasCxxCtor() bool hasCxxCtor = cls->hasCxxCtor(); hasCxxCtor()是判斷當前class或者 superclass是否有.cxx_construct構造方法的實現。
- hasCxxDtor() bool hasCxxDtor = cls->hasCxxDtor(); hasCxxDtor()是判斷判斷當前class或者superclass是否有.cxx_destruct析構方法的實現。
- canAllocNonpointer() bool fast = cls->canAllocNonpointer();具體標記某個類是否支持優化的isa.
- instanceSize()
```
size_t size = 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;
}
複製代碼
```
- 內存對齊(alignedInstanceSize()) 在unalignedInstanceSize方法中 data()->ro->instanceSize獲取類所佔用空間的大小，實際上是在MacO的data段的ro中的獲取類所佔用的大小。
  
  關於字節對齊OC是8字節對齊，在 word_align這個方法中計算了字節對齊。
```
static inline uint32_t word_align(uint32_t x) {
    //字節對齊
    return (x + WORD_MASK) & ~WORD_MASK;
}
複製代碼
```
- 關於對齊算法，能夠參考下面的示例說明：以下計算過程就能看到 OC 採用了 8 字節對齊，能夠看到咱們建立一個空類的大小是8字節（只有一個ISA指針），可是蘋果對於類作了限制，最小須要16字節。
```
假設傳入的參數： x = 9
x + WORD_MASK = 9 + 7 = 16
WORD_MASK 二進制 ：0000 0111 = 7（4+2+1）
~WORD_MASK : 1111 1000
16二進制爲  : 0001 0000
1111 1000
0001 0000
·········
0001 0000 = 16
因此 x = 16（原始值：9） 也就是 8的倍數對齊，即 8 字節對齊
也能夠用相似位運算來實現此算法
好比 (x >> 3) <<3 也能夠實現對等功能
複製代碼
```
- initInstanceIsa() 上一步咱們獲取到了obj的內存空間，接下來使用 obj->initInstanceIsa(cls, hasCxxDtor) 綁定isa指針，說明這塊內存空間是爲誰開闢的。而後返回obj。

7.關於`new`和`init`

init方法，以下，能夠看到其實init方法什麼都沒作，只是返回了對象自己

// Replaced by CF (throws an NSException)
+ (id)init {
    return (id)self;
}
- (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其實最終調用了objc_opt_new，本質上就至關於[[cls alloc] init]

id
objc_opt_new(Class cls)
{
#if __OBJC2__
    if (fastpath(cls && !cls->ISA()->hasCustomCore())) {
        return [callAlloc(cls, false/*checkNil*/, true/*allocWithZone*/) init];
    }
#endif
    return ((id(*)(id, SEL))objc_msgSend)(cls, @selector(new));
}
複製代碼