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

每天在寫的 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 中。
若 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"。
此時還要再判斷 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,物件正式「出生」:
- (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 什麼也沒做,只是把物件原封不動地還回來。真正的初始化工作,交給子類自己。

這一段想談的是:物件初始化之後,我們存取它的屬性與方法時,記憶體裡究竟是什麼光景。
@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)就足以構成一個物件。而存取屬性,就是從物件首地址開始做偏移尋址取值。

- (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++ 析構函數,同時要清掉关聯引用。接著看這三件事。
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 順勢「搭車」把成員變量的釋放程式碼塞了進去。因此:
.cxx_destruct 自動釋放。[super dealloc] 也由編譯器自動插入;父類的 dealloc 會在子類 dealloc 返回後被呼叫。只有在物件存在且 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 邏輯完全一致。
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 物件的今生今世。
如有理解偏差,還請多指教。