在分析alloc源碼之前，先來看看一下3個變量 指針 和 內存地址 區別：
如圖所示
分別輸出3個對象的內容、指針地址、對象地址，下圖是打印結果
如圖所示
結論：通過上圖可以看出，可以發現三個對象的指針地址是不一致的；
因此我們可以知道，alloc 會去申請 Person 對象的一塊內存空間，然后會用一個指針來指向這塊申請的內存空間，即 p1，而 init 不會對申請的內存空間做任何的操作，而是指向申請的同一片內存空間。
%p -> &p1：一個是內存地址，
%p -> p1： 是對象指針指向的的內存地址針
這就是本文需要探索的內容，alloc做了什么？init做了什么？
準備工作
- 下載 objc4-781 源碼
- 編譯源碼，可參考objc4-781 源碼編譯 & 調試
alloc 源碼探索,通過匯編探索流程
alloc + init 整體源碼的探索流程如下
alloc流程
- 1、找到 alloc 方法，發現 alloc 方法中調用了 _objc_rootAlloc 方法
//alloc源碼分析-第一步
+ (id)alloc {
return _objc_rootAlloc(self);
}
- 2、_objc_rootAlloc 中調用了 callAlloc 方法
//alloc源碼分析-第二步
id
_objc_rootAlloc(Class cls)
{
return callAlloc(cls, false/*checkNil*/, true/*allocWithZone*/);
}
- 3、callAlloc 中會調用 _objc_rootAllocWithZone 和 objc_msgSend
static ALWAYS_INLINE id
callAlloc(Class cls, bool checkNil, bool allocWithZone=false)// alloc 源碼 第三步
{
#if __OBJC2__ //有可用的編譯器優化
/*
參考鏈接：http://www.lxweimin.com/p/536824702ab6
*/
// checkNil 為false，!cls 也為false ，所以slowpath 為 false，假值判斷不會走到if里面，即不會返回nil
if (slowpath(checkNil && !cls)) return nil;
//判斷一個類是否有自定義的 +allocWithZone 實現，沒有則走到if里面的實現
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));
}
如上所示，在calloc方法中，當我們無法確定實現走到哪步時，可以通過斷點調試，判斷執行走哪部分邏輯。這里是執行到_objc_rootAllocWithZone
slowpath & fastpath
其中關于slowpath和fastpath這里需要簡要說明下，這兩個都是objc源碼中定義的宏，其定義如下
//x很可能為真， fastpath 可以簡稱為 真值判斷
#define fastpath(x) (__builtin_expect(bool(x), 1))
//x很可能為假，slowpath 可以簡稱為 假值判斷
#define slowpath(x) (__builtin_expect(bool(x), 0))
上面是 callAllco 方法的源碼實現，其中 if 語句中用到了 slowpath 和 fastpath，這是蘋果編譯器優化的結果。一般我們打包 release 版本的時候，會自動勾選上編譯器優化選項。
- 4、在 _objc_rootAllocWithZone 中會調用 _class_createInstanceFromZone 方法
id
_objc_rootAllocWithZone(Class cls, malloc_zone_t *zone __unused)// alloc 源碼 第四步
{
// allocWithZone under __OBJC2__ ignores the zone parameter
//zone 參數不再使用 類創建實例內存空間
return _class_createInstanceFromZone(cls, 0, nil,
OBJECT_CONSTRUCT_CALL_BADALLOC);
}
- 5、在 _class_createInstanceFromZone 中才是實現了主要的功能, 這部分是alloc源碼的核心操作，由下面的流程圖及源碼可知，該方法的實現主要分為三部分
-
cls->instanceSize：計算需要開辟的內存空間大小 -
calloc：申請內存，返回地址指針 -
obj->initInstanceIsa：將 類 與 isa 關聯
-
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)// alloc 源碼 第五步
{
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;
//計算需要開辟的內存大小，傳入的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 {
//申請內存
obj = (id)calloc(1, size);
}
if (slowpath(!obj)) {
if (construct_flags & OBJECT_CONSTRUCT_CALL_BADALLOC) {
return _objc_callBadAllocHandler(cls);
}
return nil;
}
if (!zone && fast) {
//將 cls類 與 obj指針（即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);
}
alloc 核心操作
1.instanceSize 方法：計算所需內存大小
- 1、跳轉至
instanceSize的源碼實現
size_t instanceSize(size_t extraBytes) const {
//編譯器快速計算內存大小
if (fastpath(cache.hasFastInstanceSize(extraBytes))) {
return cache.fastInstanceSize(extraBytes);
}
// 計算類中所有屬性的大小 + 額外的字節數0
size_t size = alignedInstanceSize() + extraBytes;
// CF requires all objects be at least 16 bytes.
//如果size 小于 16，最小取16
if (size < 16) size = 16;
return size;
}
通過斷點調試，會執行到cache.fastInstanceSize方法，快速計算內存大小
- 2、跳轉至
fastInstanceSize的源碼實現，通過斷點調試，會執行到align16
size_t fastInstanceSize(size_t extra) const
{
ASSERT(hasFastInstanceSize(extra));
//Gcc的內建函數 __builtin_constant_p 用于判斷一個值是否為編譯時常數，如果參數EXP 的值是常數，函數返回 1，否則返回 0
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
//刪除由setFastInstanceSize添加的FAST_CACHE_ALLOC_DELTA16 8個字節
return align16(size + extra - FAST_CACHE_ALLOC_DELTA16);
}
}
- 3、跳轉至
align16的源碼實現，這個方法是16字節對齊算法
//16字節對齊算法
static inline size_t align16(size_t x) {
return (x + size_t(15)) & ~size_t(15);
}
為什么需要16字節對齊
需要字節對齊的原因，有以下幾點：
- 通常內存是由一個個字節組成的，cpu在存取數據時，并不是以字節為單位存儲，而是以塊為單位存取，塊的大小為內存存取力度。頻繁存取字節未對齊的數據，會極大降低cpu的性能，所以可以通過
減少存取次數來降低cpu的開銷 - 16字節對齊，是由于在一個對象中，第一個屬性
isa占8字節，當然一個對象肯定還有其他屬性，當無屬性時，會預留8字節，即16字節對齊，如果不預留，相當于這個對象的isa和其他對象的isa緊挨著，容易造成訪問混亂 - 16字節對齊后，可以
加快CPU讀取速度，同時使訪問更安全，不會產生訪問混亂的情況
2.calloc：申請內存，返回地址指針
通過instanceSize計算的內存大小，向內存中申請 大小 為 size的內存，并賦值給obj，因此 obj是指向內存地址的指針
obj = (id)calloc(1, size);
3.obj->initInstanceIsa：類與isa關聯
經過calloc可知，內存已經申請好了，類也已經傳入進來了，接下來就需要將 類與 地址指針 即isa指針進行關聯，其關聯的流程圖如下所示
如圖所示
主要過程就是初始化一個isa指針，并將isa指針指向申請的內存地址，在將指針與cls類進行 關聯
同樣也可以通過斷點調試來印證上面的說法，在執行完initInstanceIsa后，在通過po obj可以得出一個對象指針
init 方法
alloc源碼探索完了，接下來探索init源碼，通過源碼可知，inti的源碼實現有以下兩種類方法 init 和 實例方法 init
+ (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;
}
這里的init是一個構造方法 ，是通過工廠設計（工廠方法模式）,主要是用于給用戶提供構造方法入口。這里能使用id強轉的原因，主要還是因為 內存字節對齊后，可以使用類型強轉為你所需的類型
new 方法
一般在開發中，初始化除了init，還可以使用new，兩者本質上并沒有什么區別，以下是objc中new的源碼實現，通過源碼可以得知，new函數中直接調用了callAlloc函數（即alloc中分析的函數），且調用了init函數，所以可以得出new 其實就等價于 [alloc init]的結論
+ (id)new {
return [callAlloc(self, false/*checkNil*/) init];
}
但是我們推薦使用 [alloc init] 方法，因為這樣我們可以自定義 init 方法，使我們的開發更加的靈活。
注：可在github下載已經編譯成功的objc-781源碼
