您现在的位置: IOS教程網 >> IOS系統 >  >> iOS 程式開發 >> iOS 開發基礎

Objc 物件的一生:從 alloc 到 dealloc 的源碼之旅

編輯:iOS 開發基礎

前言

在物件導向開發裡,我們每天 new 物件、用物件描述整個世界。但你有沒有想過:一個物件是怎麼被孕育、誕生、成長,最後走向銷毀的?本文沿著 runtime 源碼走一遍這趟旅程。

一、孕育物件:alloc 做了什麼

每天在寫的 alloc,本質上只是一層皮:

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

所有物件的 alloc 都會走到這個 root 方法,而它又轉手交給 callAlloc:

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

由於入參 checkNil = false,這條路徑不會回傳 nil。callAlloc 內部有兩個關鍵判斷:

bool hasCustomAWZ() {
    return ! bits.hasDefaultAWZ();
}

如上圖,物件 data 段的 class_rw_t 中有一個 flags 欄位:

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 中。

分支一:有預設的 allocWithZone

若 cls->ISA()->hasCustomAWZ() 為真,代表類沒有覆寫 alloc 相關方法,可以直接配置記憶體:

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

_objc_rootAllocWithZone 在 __OBJC2__ 下會直接忽略 zone 參數,交由 class_createInstance(cls, 0) 處理;舊版本則會先檢查 zone 是否有空間、是否啟用垃圾回收,再決定走 class_createInstance 還是 class_createInstanceFromZone。不論新舊版本,最終都匯流到 _class_createInstanceFromZone。

若配置失敗,會交由 callBadAllocHandler 處理,最終由 _objc_fatal 印出 "attempt to allocate object of class ... failed"。

分支二:沒有預設的 allocWithZone

此時還要再判斷 class 是否支援快速配置。可以就走捷徑:直接 calloc 一塊 bits.fastInstanceSize() 大小的記憶體,成功後初始化 isa 與 dtor 標記;不支援則老實回到 class_createInstance(cls, 0)。

bool hasCxxDtor() {
    return data()->flags & RW_HAS_CXX_DTOR;
}
#define RW_HAS_CXX_DTOR (1<<17)

dtor 判斷的是當前 class 或 superclass 是否有 .cxx_destruct 的實現。

種種判斷之後,「孕育」的最後一哩路落在 _class_createInstanceFromZone:

static __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());

    // 一次讀取所有 info bits,效能考量
    bool hasCxxCtor = cls->hasCxxCtor();
    bool hasCxxDtor = cls->hasCxxDtor();
    bool fast = cls->canAllocIndexed();
    size_t size = cls->instanceSize(extraBytes);
    if (outAllocatedSize) *outAllocatedSize = size;

    id obj;
    if (!UseGC && !zone && fast) {
        obj = (id)calloc(1, size);
        if (!obj) return nil;
        obj->initInstanceIsa(cls, hasCxxDtor);
    } else {
        // zone / GC 等非快速路徑,使用 non-indexed isa
        ...
        obj->initIsa(cls);
    }

    if (cxxConstruct && hasCxxCtor) {
        obj = _objc_constructOrFree(obj, cls);
    }
    return obj;
}

其中 ctor 與 dtor 分別判斷當前 class 或 superclass 是否有 C++ 的構造/析構實現:

bool hasCxxCtor() { return data()->flags & RW_HAS_CXX_CTOR; }   // 1<<18
bool hasCxxDtor() { return data()->flags & RW_HAS_CXX_DTOR; }   // 1<<17

而配置空間所需的大小由 instanceSize 決定,會存在 isa_t 結構體中,經過對齊後回傳:

size_t instanceSize(size_t extraBytes) {
    size_t size = alignedInstanceSize() + extraBytes;
    // CF 要求所有物件至少 16 bytes
    if (size < 16) size = 16;
    return size;
}
uint32_t alignedInstanceSize() { return word_align(unalignedInstanceSize()); }
uint32_t unalignedInstanceSize() { return data()->ro->instanceSize; }

接著就是 calloc。這個函數會把配置的記憶體全部初始化為 0——這正是為什麼我們 new 出來的物件,成員變量預設都是 0 或 nil。

The calloc() function contiguously allocates enough space for count objects that are size bytes of memory each and returns a pointer to the allocated memory. The allocated memory is filled with bytes of value zero.

記憶體配置完畢,最後一步是初始化 isa:

obj->initInstanceIsa(cls, hasCxxDtor);
obj->initIsa(cls);

兩者最終都呼叫同一個 initIsa,只是入參不同。而初始化的過程,本質上就是對 isa_t 這個位元欄位結構體的赋值:

#if __arm64__
# define ISA_MASK         0x0000000ffffffff8ULL
# define ISA_MAGIC_MASK   0x000003f000000001ULL
# define ISA_MAGIC_VALUE  0x000001a000000001ULL

struct {
    uintptr_t indexed           : 1;
    uintptr_t has_assoc         : 1;
    uintptr_t has_cxx_dtor      : 1;
    uintptr_t shiftcls          : 33;
    uintptr_t magic             : 6;
    uintptr_t weakly_referenced : 1;
    uintptr_t deallocating      : 1;
    uintptr_t has_sidetable_rc  : 1;
    uintptr_t extra_rc          : 19;
#   define RC_ONE  (1ULL<<45)
#   define RC_HALF (1ULL<<18)
};

把位址右移三位的原因是清掉 Class 指標中無用的後三位以降低記憶體消耗。因為類的指標要按 8 bytes 對齊,後三位永遠是沒有意義的 0。多數機器架構是 byte-addressable,但物件位址必須對齊到字節倍數才能提升效能;在 iPhone 5s 中虛擬位址為 33 位,用於對齊的最後三位為 000,因此只需要 30 位來表示位址。

至此,「孕育物件」的階段完成。

二、物件的誕生: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;
}

就是這麼樸素——root 的 init 什麼也沒做,只是把物件原封不動地還回來。真正的初始化工作,交給子類自己。

三、物件的成長:isa、Class 與 metaclass

這一段想談的是:物件初始化之後,我們存取它的屬性與方法時,記憶體裡究竟是什麼光景。

@interface Student : NSObject
@property (strong, nonatomic) NSString *name;
+ (void)study;
- (void)run;
@end

@implementation Student
+ (void)study { NSLog(@"Study"); }
- (void)run   { NSLog(@"Run"); }
@end

就拿這個只有一個屬性、一個類方法、一個實例方法的 Student 來說明。

Student *stu = [[Student alloc] init];
NSLog(@"Student's class is %@", [stu class]);
NSLog(@"Student's meta class is %@", object_getClass([stu class]));
NSLog(@"Student's meta class's superclass is %@",
      object_getClass(object_getClass([stu class])));

Class currentClass = [Student class];
for (int i = 1; i < 5; i++) {
    NSLog(@"Following the isa pointer %d times gives %p %@",
          i, currentClass, currentClass);
    currentClass = object_getClass(currentClass);
}

輸出:

Student's class is Student
Student's meta class is Student
Student's meta class's superclass is NSObject
Following the isa pointer 1 times gives 0x100004d90 Student
Following the isa pointer 2 times gives 0x100004d68 Student
Following the isa pointer 3 times gives 0x7fffba0b20f0 NSObject
Following the isa pointer 4 times gives 0x7fffba0b20f0 NSObject

可以確定:一個類的實例,其 isa 指向它的 class。

如上圖,實例透過 isa 指向灰色的 Class pair 區域,裡面包含兩樣東西:class 與 metaclass。class 的 isa 指向 metaclass;由於 Student 繼承自 NSObject,所以 Student 的 metaclass 的 superclass 是 NSObject。

那這三個東西裡面各裝了什麼?繼續打印。

+ (NSArray *)instanceVariables {
    unsigned int outCount;
    Ivar *ivars = class_copyIvarList([self class], &outCount);
    NSMutableArray *result = [NSMutableArray array];
    for (unsigned int i = 0; i < outCount; i++) {
        NSString *type = [NSString decodeType:ivar_getTypeEncoding(ivars[i])];
        NSString *name = [NSString stringWithCString:ivar_getName(ivars[i])
                                            encoding:NSUTF8StringEncoding];
        [result addObject:[NSString stringWithFormat:@"%@ %@", type, name]];
    }
    free(ivars);
    return result.count ? [result copy] : nil;
}
po [0x100004d90 instanceVariables]   // 類
po [0x100004d68 instanceVariables]   // metaclass

輸出:

<__NSSingleObjectArrayI 0x100302460>(
    NSString* _name
)
nil

結論:屬性(實例變量)存在類裡。

至於 + 號與 - 號方法——記憶體裡其實沒有這個區分:

+ (NSArray *)ClassMethodNames {
    NSMutableArray *array = [NSMutableArray array];
    unsigned int methodCount = 0;
    Method *methodList = class_copyMethodList([self class], &methodCount);
    for (unsigned int i = 0; i < methodCount; i++) {
        [array addObject:NSStringFromSelector(method_getName(methodList[i]))];
    }
    free(methodList);
    return array;
}
po [0x100004d90 ClassMethodNames]
po [0x100004d68 ClassMethodNames

輸出:

<__NSArrayM 0x100303310>(
    .cxx_destruct,
    name,
    setName:,
    run
)
<__NSArrayM 0x100303800>(
    study
)

0x100004d90 是類物件,裡面存的是 - 號方法,以及 getter、setter、.cxx_destruct;0x100004d68 是 metaclass,裡面存的是 + 號方法。

runtime 中還有一處特例:NSObject 的 metaclass,它的 superclass 是自己本身。這是為了攔截那些只有 - 號版本的協議方法(例如 -copy),避免消息拋到 NSObject 時崩潰,所以 NSObject 的 metaclass 把 NSObject 的 + 號方法重新實作了一遍。這也是為什麼同一個協議方法常常同時看得到 + 號與 - 號版本。

另外要記住:class 與 metaclass 都是單例。

物件的實質

所有物件在記憶體中都有一個 isa,它就像一具小「雷達」,有了它就能在 runtime 下給物件發送消息。所以:

Objective-C 中的物件,本質上是一個指向 ClassObject 位址的變量,即 id obj = &ClassObject。

而屬性的實質是:void *ivar = &obj + offset(N)。

NSString *myName = @"halfrost";
NSLog(@"myName 地址 = %p , 大小 = %lu ", &myName, sizeof(myName));

id cls = [Student class];
NSLog(@"Student class = %@ 地址 = %p, 大小 = %lu", cls, &cls, sizeof(cls));

void *obj = &cls;
NSLog(@"Void *obj = %@ 地址 = %p, 大小 = %lu", obj, &obj, sizeof(obj));
NSLog(@"%@  %p", ((__bridge Student *)obj).name, ((__bridge Student *)obj).name);

輸出:

myName 地址 = 0x7fff562eeaa8 , 大小 = 8
Student class = Student 地址 = 0x7fff562eeaa0, 大小 = 8
Void *obj = <Student: 0x7fff562eeaa0> 地址 = 0x7fff562eea98, 大小 = 8
halfrost  0x10a25c068

這個例子說明了:obj 就是一個指向類物件的指標。從 obj 的位址 0x7fff562eea98 往下偏移 8 個字節到 isa(class 位址 0x7fff562eeaa0),再偏移 8 個字節就到了 name 屬性(0x7fff562eeaa8)。name 裡存的是字串的指標,指向 0x10a25c068。

把這個位址印出來,裡面就是我們的字串內容。

要注意的是,類物件是在 main 函數執行之前就載入記憶體的:可執行檔與動態庫中的所有符號(Class、Protocol、Selector、IMP……)都已按格式載入並由 runtime 管理。也正因如此,runtime 那些動態添加 Class、method swizzling 的能力才能生效。

總結:每個物件的 isa 存的是 Class 的記憶體位址;Class 在 main 之前就載入並由 Runtime 管理,所以構造一個指向 Class 的指標(isa)就足以構成一個物件。而存取屬性,就是從物件首地址開始做偏移尋址取值。

四、物件的銷毀:dealloc

- (void)dealloc {
    _objc_rootDealloc(self);
}
void _objc_rootDealloc(id obj) {
    assert(obj);
    obj->rootDealloc();
}
inline void objc_object::rootDealloc() {
    assert(!UseGC);
    if (isTaggedPointer()) return;

    if (isa.indexed &&
        !isa.weakly_referenced &&
        !isa.has_assoc &&
        !isa.has_cxx_dtor &&
        !isa.has_sidetable_rc)
    {
        assert(!sidetable_present());
        free(this);          // 快速路徑:直接釋放
    }
    else {
        object_dispose((id)this);   // 慢速路徑
    }
}

這裡的判斷條件各自代表:TaggedPointer(直接 return)、是否開啟 isa 指標優化、是否被 ARC 弱變量指向過、是否含有关联引用、是否有 C++ 析構器、以及引用計數是否溢出到 side table。只要沒有這些「附帶包袱」,就能直接 free。

id object_dispose(id obj) {
    if (!obj) return nil;
    objc_destructInstance(obj);
    free(obj);
    return nil;
}
void *objc_destructInstance(id obj) {
    if (obj) {
        // 一次讀取所有 flags,效能考量
        bool cxx = obj->hasCxxDtor();
        bool assoc = !UseGC && obj->hasAssociatedObjects();
        bool dealloc = !UseGC;

        // This order is important.
        if (cxx) object_cxxDestruct(obj);
        if (assoc) _object_remove_assocations(obj);
        if (dealloc) obj->clearDeallocating();
    }
    return obj;
}

銷毀一個物件,最終靠的是底層的 C++ 析構函數,同時要清掉关聯引用。接著看這三件事。

1. object_cxxDestruct:執行 C++ 析構

void object_cxxDestruct(id obj) {
    if (!obj) return;
    if (obj->isTaggedPointer()) return;
    object_cxxDestructFromClass(obj, obj->ISA());
}

static void object_cxxDestructFromClass(id obj, Class cls) {
    void (*dtor)(id);
    // 先呼叫 cls 的 dtor,再往父類一路呼叫
    for (; cls; cls = cls->superclass) {
        if (!cls->hasCxxDtor()) return;
        dtor = (void(*)(id)) lookupMethodInClassAndLoadCache(cls, SEL_cxx_destruct);
        if (dtor != (void(*)(id))_objc_msgForward_impcache) {
            (*dtor)(obj);
        }
    }
}

從子類沿繼承鏈向上尋找 SEL_cxx_destruct,找到實現後執行。

值得注意的是 .cxx_destruct 這個方法的由來:

ARC actually creates a -.cxx_destruct method to handle freeing instance variables. This method was originally created for calling C++ destructors automatically when an object was destroyed.

When the compiler saw that an object contained C++ objects, it would generate a method called .cxx_destruct. ARC piggybacks on this method and emits the required cleanup code within it.

也就是說,.cxx_destruct 原本是用來自動呼叫 C++ 析構的,ARC 順勢「搭車」把成員變量的釋放程式碼塞了進去。因此:

  • ARC 下物件的成員變量,由編譯器插入的 .cxx_destruct 自動釋放。
  • ARC 下 [super dealloc] 也由編譯器自動插入;父類的 dealloc 會在子類 dealloc 返回後被呼叫。
  • 實例變量在根類(通常是 NSObject)的 dealloc 中釋放,且釋放順序不確定——同一個類內不確定,父子類之間也不確定,所以不需要依賴順序。

2. _object_remove_assocations:清掉关聯物件

只有在物件存在且 hasAssociatedObjects() 為真時,才會呼叫這個方法。它的目標是刪除第二張表 ObjcAssociationMap,也就是所有关聯物件:

void _object_remove_assocations(id object) {
    vector<ObjcAssociation, ObjcAllocator<ObjcAssociation> > elements;
    {
        AssociationsManager manager;
        AssociationsHashMap &associations(manager.associations());
        if (associations.size() == 0) return;

        disguised_ptr_t disguised_object = DISGUISE(object);
        AssociationsHashMap::iterator i = associations.find(disguised_object);
        if (i != associations.end()) {
            ObjectAssociationMap *refs = i->second;
            for (auto j = refs->begin(), end = refs->end(); j != end; ++j) {
                elements.push_back(j->second);
            }
            delete refs;
            associations.erase(i);      // 刪除第二張表
        }
    }
    // releaseValue() 的呼叫放在鎖外
    for_each(elements.begin(), elements.end(), ReleaseValue());
}

流程是:先在 AssociationsHashMap 中查找對應條目,把第二張表裡所有 ObjcAssociation 收集到 elements 陣列,刪除第二張表,最後逐一釋放。這與 Associated Object 那套 remove 邏輯完全一致。

3. clearDeallocating():清空弱引用

inline void objc_object::clearDeallocating() {
    if (!isa.indexed) {
        // 未開啟 isa 優化的慢速路徑
        sidetable_clearDeallocating();
    }
    else if (isa.weakly_referenced || isa.has_sidetable_rc) {
        clearDeallocating_slow();
    }
    assert(!sidetable_present());
}

只要物件曾被弱引用,或引用計數曾溢出到 side table,就走慢速路徑;兩條路最終都會呼叫 weak_clear_no_lock:

void weak_clear_no_lock(weak_table_t *weak_table, id referent_id) {
    objc_object *referent = (objc_object *)referent_id;
    weak_entry_t *entry = weak_entry_for_referent(weak_table, referent);
    if (entry == nil) return;

    weak_referrer_t *referrers;
    size_t count;
    if (entry->out_of_line) {
        referrers = entry->referrers;
        count = TABLE_SIZE(entry);
    } else {
        referrers = entry->inline_referrers;
        count = WEAK_INLINE_COUNT;
    }

    // 把所有指向該物件的 weak 指標設為 nil
    for (size_t i = 0; i < count; ++i) {
        objc_object **referrer = referrers[i];
        if (referrer) {
            if (*referrer == referent) {
                *referrer = nil;
            } else if (*referrer) {
                objc_weak_error();
            }
        }
    }
    weak_entry_remove(weak_table, entry);
}

這個函數會在 weak_table 中清空引用計數表與弱引用表,把所有 weak 指標置為 nil——這也是為什麼 weak 變量在物件釋放後會自動變成 nil,不會變成野指標。

總結

從 alloc 時的配置記憶體與初始化 isa,到 init 的誕生,再到透過 isa 鏈在 class 與 metaclass 之間查找方法、以偏移量存取屬性,最後在 dealloc 中依序執行 C++ 析構、清理关聯物件、置空弱引用並釋放記憶體——這就是一個 Objective-C 物件的今生今世。

如有理解偏差,還請多指教。

  1. 上一篇文章:
  2. 下一篇文章:
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © IOS教程網 All Rights Reserved