IOS底層原理之alloc、init和new

1、疑惑點

採用Object-C語言進行開發的時候，咱們都知道能夠經過 [XXX alloc]、[[XXX alloc]init]、[XXX new]的形式進行對象實例的建立，那麼咱們不由會疑惑alloc、init、new它們各自都作了什麼呢？一樣的都是進行實例建立，它們之間有什麼內在的關聯呢？它們之間又有着什麼樣的區別呢？帶着這些疑惑咱們一塊兒深刻底層探究一下。

Person *p = [Person alloc];
Person *p1 = [[Person alloc]init];
Person *p2 = [Person new];
NSLog(@"%p,%p,%p",p,p1,p2);
複製代碼

2、底層源碼探究

既然是深刻底層那咱們確定須要知道底層代碼是作了什麼，很幸運的是蘋果開源了這部分的代碼。能夠在這裏下載到。下載下來的源碼直接編譯是通不過的，須要本身修改下配置。

一、alloc探究

進入到alloc的源碼裏面，咱們發現alloc調用了_objc_rootAlloc方法，而_objc_rootAlloc調用了callAlloc方法。

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

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

static ALWAYS_INLINE id
callAlloc(Class cls, bool checkNil, bool allocWithZone=false)
{
    if (slowpath(checkNil && !cls)) return nil;

#if __OBJC2__
    if (fastpath(!cls->ISA()->hasCustomAWZ())) {
        if (fastpath(cls->canAllocFast())) {
            // No ctors, raw isa, etc. Go straight to the metal.
            bool dtor = cls->hasCxxDtor();
            id obj = (id)calloc(1, cls->bits.fastInstanceSize());
            if (slowpath(!obj)) return callBadAllocHandler(cls);
            obj->initInstanceIsa(cls, dtor);
            return obj;
        }
        else {
            // Has ctor or raw isa or something. Use the slower path.
            id obj = class_createInstance(cls, 0);
            if (slowpath(!obj)) return callBadAllocHandler(cls);
            return obj;
        }
    }
#endif

    // No shortcuts available.
    if (allocWithZone) return [cls allocWithZone:nil];
    return [cls alloc];
}
複製代碼

在callAlloc方法裏面吸引咱們注意的是if的判斷條件。fastpath(!cls->ISA()->hasCustomAWZ())都作了什麼呢？fastpath又是什麼呢？

fastpath的定義是這樣的

#define fastpath(x) (__builtin_expect(bool(x), 1))
複製代碼

咱們要搞清楚fastpath是什麼，就要知道__builtin_expect是什麼。萬能的google告訴了咱們答案。這個指令是gcc引入的，做用是容許程序員將最有可能執行的分支告訴編譯器。這個指令的寫法爲：__builtin_expect(EXP, N)。意思是：EXP==N的機率很大

!cls->ISA()->hasCustomAWZ()作了什麼呢？很明顯是調用了hasCustomAWZ這樣一個方法。

bool hasDefaultAWZ( ) {
    return data()->flags & RW_HAS_DEFAULT_AWZ;
}
#define RW_HAS_DEFAULT_AWZ (1<<16)
複製代碼

RW_HAS_DEFAULT_AWZ 這個是用來標示當前的class或者是superclass是否有默認的alloc/allocWithZone:。值得注意的是，這個值會存儲在metaclass 中。

hasDefaultAWZ( )方法是用來判斷當前class是否有重寫allocWithZone。若是cls->ISA()->hasCustomAWZ()返回YES，意味着當前的class有重寫allocWithZone方法，那麼就直接對class進行allocWithZone，申請內存空間。

if (allocWithZone) return [cls allocWithZone:nil];
+ (id)allocWithZone:(struct _NSZone *)zone {
    return _objc_rootAllocWithZone(self, (malloc_zone_t *)zone);
}
複製代碼

allocWithZone內部調用了_objc_rootAllocWithZone方法，接下來咱們分析下_objc_rootAllocWithZone方法。

id
_objc_rootAllocWithZone(Class cls, malloc_zone_t *zone)
{
    id obj;

#if __OBJC2__
    // allocWithZone under __OBJC2__ ignores the zone parameter
    (void)zone;
    obj = class_createInstance(cls, 0);//建立對象
#else
    if (!zone) {
        obj = class_createInstance(cls, 0);
    }
    else {
        obj = class_createInstanceFromZone(cls, 0, zone);
    }
#endif

    if (slowpath(!obj)) obj = callBadAllocHandler(cls);
    return obj;
}
複製代碼

咱們發現直接調用了class_createInstance方法來建立對象，好像已經逐漸接近alloc的真相了。

id class_createInstance(Class cls, size_t extraBytes)
{
    return _class_createInstanceFromZone(cls, extraBytes, nil);
}

tatic __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());
    //讀取class的信息
    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;
}
複製代碼

哇瑟，一眼看去就暈了！可是靜下心分析下來咱們發現了些端倪。建立對象就要爲對象開闢內存空間，這裏會不會就是爲對象開闢了空間呢？發現方法裏面調用了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;
}

uint32_t alignedInstanceSize() {
   return word_align(unalignedInstanceSize());
 }

//讀取當前的類的屬性數據大小
uint32_t unalignedInstanceSize() {
   assert(isRealized());
   return data()->ro->instanceSize;
}
//進行內存對齊
//WORD_MASK == 7
static inline uint32_t word_align(uint32_t x) {
    return (x + WORD_MASK) & ~WORD_MASK;
}
複製代碼

哇瑟，咱們的猜想是對的，instanceSize方法計算出了對象的大小，並且必須是大於或等於16字節，而後調用calloc函數爲對象分配內存空間了。 有必要說明的一點是，對齊算法使用很巧妙，關於內存對齊在上一篇文章中我有講解。 由此咱們總結一點alloc建立了一個對象而且爲其分配了很多於16字節的內存。

可是僅僅是申請了一塊內存空間嗎？咱們還注意到initInstanceIsa方法，那麼這個方法是幹什麼的呢？其實這個方法就是初始化isa指針，關於isa在這裏不作描述，在後續的文章中會專門講解isa。

剛纔咱們分析了hasDefaultAWZ( )方法返回Yes的狀況，那若是hasDefaultAWZ( )方法返回NO呢。

if (fastpath(cls->canAllocFast())) {
    // No ctors, raw isa, etc. Go straight to the metal.
    bool dtor = cls->hasCxxDtor();
    id obj = (id)calloc(1, cls->bits.fastInstanceSize());
    if (slowpath(!obj)) return callBadAllocHandler(cls);
    obj->initInstanceIsa(cls, dtor);
    return obj;
}
else {
    // Has ctor or raw isa or something. Use the slower path.
    id obj = class_createInstance(cls, 0);
    if (slowpath(!obj)) return callBadAllocHandler(cls);
    return obj;
}
複製代碼

這一段是hasDefaultAWZ( )返回NO的狀況，有去判斷當前的class是否支持快速alloc。若是能夠，直接調用calloc函數，而且申請1塊bits.fastInstanceSize()大小的內存空間，而後初始化isa指針，不然直接調用class_createInstance方法，這樣就走到了咱們上面分析流程了。

總結上面分析流程，咱們得出了一個結論

alloc爲咱們建立了一個對象而且申請了一塊很多於16字節的內存空間。

既然alloc爲咱們建立了對象，那還要init幹嗎呢？init有作了什麼呢？

二、init探究

咱們進入到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;
}

複製代碼

額的天吶，init啥都沒作，只是把當前的對象返回了。既然啥都沒作那咱們還須要調用init嗎？答案是確定的，其實init就是一個工廠範式，方便開發者自行重寫定義。

咱們在來看看new方法作了啥。

三、new探究

進入到new的底層代碼

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

發現new調用的是callAlloc方法和init，那麼能夠理解爲new實際上就是alloc+init的綜合體。

總結

1. alloc建立了對象而且申請了一塊很多於16字節的內存空間。
2. init其實什麼也沒作，返回了當前的對象。其做用在於提供一個範式，方便開發者自定義。
3. new實際上是alloc+init的一個綜合體。