Objective-C 有個眾所皆知的限制:Category 可以替既有類別加上屬性,卻無法加上實例變數。Associated Objects 正是為了填補這個缺口而生。本文不打算停在「怎麼用」,而是往下追進 runtime 源碼,把三個問題問清楚。
先給答案,後面的實作與源碼用來佐證:
OBJC_ASSOCIATION_RETAIN_NONATOMIC,這能確保我們持有該對象。OBJC_ASSOCIATION_ASSIGN 關聯的對象往往很早就被釋放了,卻沒有從關聯表中移除,此時再取用就會 Crash。依照 Mattt Thompson 在〈Associated Objects〉一文中的歸納,主要有三類:
本質上第 1、2 類是同一件事,差別只在新屬性是公開還是私有。就我的工作經驗而言,第 2 類用得最多,第 3 類還沒實際碰過。
在 runtime 原始碼的 runtime.h 中可以找到它們的宣告:
void objc_setAssociatedObject(id object, const void *key, id value, objc_AssociationPolicy policy); id objc_getAssociatedObject(id object, const void *key); void objc_removeAssociatedObjects(id object);
命名非常直白:
objc_setAssociatedObject 用於添加關聯對象,傳入 nil 即可移除既有關聯;objc_getAssociatedObject 用於讀取關聯對象;objc_removeAssociatedObjects 移除某對象的所有關聯對象。注意:第三個函數實務上幾乎用不到。它會把該對象恢復成「原始狀態」,等於連別人添加的關聯對象一起清掉,這通常不是我們想要的。正確做法是把 nil 傳給 objc_setAssociatedObject,只解除你自己那一筆。
key 必須是對象層級的唯一常量(原因看後面的源碼就明白了)。常見有三種寫法:
static char kAssociatedObjectKey;,用 &kAssociatedObjectKey 當 key;static void *kAssociatedObjectKey = &kAssociatedObjectKey;,直接用 kAssociatedObjectKey;我偏好第三種。它省掉一個變數名,優雅地繞開了計算科學的兩大難題之一:命名。

其中第 2 種與第 4 種、第 3 種與第 5 種的唯一差別在於操作是否具原子性。原子性不在本文討論範圍,因此下面的實驗以前三種為例。
實驗涉及 ViewController 類別與它的分類 ViewController+AssociatedObjects。分類中宣告三個屬性,限定符分別是 assign/nonatomic、strong/nonatomic、copy/nonatomic,並在實作中對應使用 OBJC_ASSOCIATION_ASSIGN、OBJC_ASSOCIATION_RETAIN_NONATOMIC、OBJC_ASSOCIATION_COPY_NONATOMIC 三種策略。
@interface ViewController (AssociatedObjects)
@property (assign, nonatomic) NSString *associatedObject_assign;
@property (strong, nonatomic) NSString *associatedObject_retain;
@property (copy, nonatomic) NSString *associatedObject_copy;
@end
@implementation ViewController (AssociatedObjects)
- (NSString *)associatedObject_assign {
return objc_getAssociatedObject(self, _cmd);
}
- (void)setAssociatedObject_assign:(NSString *)v {
objc_setAssociatedObject(self, @selector(associatedObject_assign), v, OBJC_ASSOCIATION_ASSIGN);
}
- (NSString *)associatedObject_retain {
return objc_getAssociatedObject(self, _cmd);
}
- (void)setAssociatedObject_retain:(NSString *)v {
objc_setAssociatedObject(self, @selector(associatedObject_retain), v, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}
- (NSString *)associatedObject_copy {
return objc_getAssociatedObject(self, _cmd);
}
- (void)setAssociatedObject_copy:(NSString *)v {
objc_setAssociatedObject(self, @selector(associatedObject_copy), v, OBJC_ASSOCIATION_COPY_NONATOMIC);
}
@end
在主類別中用三個全域 __weak 變數觀察各對象的釋放時機:
__weak NSString *string_weak_assign = nil;
__weak NSString *string_weak_retain = nil;
__weak NSString *string_weak_copy = nil;
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
self.associatedObject_assign = [NSString stringWithFormat:@"leichunfeng1"];
self.associatedObject_retain = [NSString stringWithFormat:@"leichunfeng2"];
self.associatedObject_copy = [NSString stringWithFormat:@"leichunfeng3"];
string_weak_assign = self.associatedObject_assign;
string_weak_retain = self.associatedObject_retain;
string_weak_copy = self.associatedObject_copy;
}
- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event {
// NSLog(@"self.associatedObject_assign:%@", self.associatedObject_assign); // 這行會 Crash
NSLog(@"self.associatedObject_retain:%@", self.associatedObject_retain);
NSLog(@"self.associatedObject_copy:%@", self.associatedObject_copy);
}
@end
建議先自己想一想:這三個對象分別會在什麼時候消失?想清楚再往下看實驗結果,理解會更紮實。
在 viewDidLoad 的賦值處下斷點,執行後 push 到該頁面,程式停在斷點。接著用 lldb 的 watchpoint 指令對三個全域變數設觀察點,console 會輸出類似下面的內容:

繼續執行,第一個觀察點被命中。比對這次輸出的 old value 與上次的 new value,可以確認命中的是 string_weak_assign,其值已變成 nil。也就是說 self.associatedObject_assign 指向的對象已被釋放。查看左側呼叫堆疊可知,它是因為所處的 autoreleasepool 被排空而釋放,這與 Autorelease Pool 的實現原理一致。你也可以把 touchesBegan: 中那行註解打開,等頁面出現後點一下畫面,進一步驗證這個結論。

返回上一頁,第二個觀察點被命中,對應的是 string_weak_retain。此時呼叫堆疊中出現一個關鍵函數 _object_remove_assocations——呼叫它之後,ViewController 的所有關聯對象被一次清空,self.associatedObject_retain 指向的對象也就隨之釋放。

再繼續,最後一個觀察點 string_weak_copy 被命中,原因同上,也是因為關聯對象被移除而釋放。

_object_remove_assocations 統一移除的。在 objc-references.mm 中可以找到它最終呼叫的實作:
void _object_set_associative_reference(id object, void *key, id value, uintptr_t policy) {
// 先在鎖外 retain 新值
ObjcAssociation old_association(0, nil);
id new_value = value ? acquireValue(value, policy) : nil;
{
AssociationsManager manager;
AssociationsHashMap &associations(manager.associations());
disguised_ptr_t disguised_object = DISGUISE(object);
if (new_value) {
AssociationsHashMap::iterator i = associations.find(disguised_object);
if (i != associations.end()) {
// 二級表已存在
ObjectAssociationMap *refs = i->second;
ObjectAssociationMap::iterator j = refs->find(key);
if (j != refs->end()) {
old_association = j->second;
j->second = ObjcAssociation(policy, new_value);
} else {
(*refs)[key] = ObjcAssociation(policy, new_value);
}
} else {
// 第一次建立關聯
ObjectAssociationMap *refs = new ObjectAssociationMap;
associations[disguised_object] = refs;
(*refs)[key] = ObjcAssociation(policy, new_value);
object->setHasAssociatedObjects();
}
} else {
// 傳 nil 即解除關聯
AssociationsHashMap::iterator i = associations.find(disguised_object);
if (i != associations.end()) {
ObjectAssociationMap *refs = i->second;
ObjectAssociationMap::iterator j = refs->find(key);
if (j != refs->end()) {
old_association = j->second;
refs->erase(j);
}
}
}
}
// 鎖外釋放舊值
if (old_association.hasValue()) ReleaseValue()(old_association);
}
讀這段之前,先釐清四個資料結構的層級關係:
_policy(策略)與 _value(關聯對象)兩個成員。也就是說,每個對象位址對應一份 ObjectAssociationMap,而一份 ObjectAssociationMap 保存該對象的若干筆關聯記錄。這也解釋了為什麼 key 只要「對象層級唯一」就夠了——它是在二級表裡做查找的。釐清這層關係後,上面的程式碼其實並不難讀。

id _object_get_associative_reference(id object, void *key) {
id value = nil;
uintptr_t policy = OBJC_ASSOCIATION_ASSIGN;
{
AssociationsManager manager;
AssociationsHashMap &associations(manager.associations());
disguised_ptr_t disguised_object = DISGUISE(object);
AssociationsHashMap::iterator i = associations.find(disguised_object);
if (i != associations.end()) {
ObjectAssociationMap *refs = i->second;
ObjectAssociationMap::iterator j = refs->find(key);
if (j != refs->end()) {
ObjcAssociation &entry = j->second;
value = entry.value();
policy = entry.policy();
if (policy & OBJC_ASSOCIATION_GETTER_RETAIN)
((id (*)(id, SEL))objc_msgSend)(value, SEL_retain);
}
}
}
if (value && (policy & OBJC_ASSOCIATION_GETTER_AUTORELEASE)) {
((id (*)(id, SEL))objc_msgSend)(value, SEL_autorelease);
}
return value;
}
讀懂 setter 之後,getter 就是小菜一碟:先依對象位址在 AssociationsHashMap 中找到二級表,再依 key 找到對應的 ObjcAssociation,取回 value;找不到則回傳 nil。策略中的 GETTER_RETAIN 與 GETTER_AUTORELEASE 則決定了要不要對回傳值加工。
void _object_remove_assocations(id object) {
vector< ObjcAssociation, ObjcAllocator > 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 (ObjectAssociationMap::iterator j = refs->begin(), end = refs->end(); j != end; ++j) {
elements.push_back(j->second);
}
// 移除二級表
delete refs;
associations.erase(i);
}
}
// 鎖外執行釋放
for_each(elements.begin(), elements.end(), ReleaseValue());
}
流程是:依對象位址取出二級表,把所有關聯結構搬進 vector,然後釋放。這正好對應實驗中觀察到的現象——對象釋放時呼叫的就是這個函數。
可以。既然位址與哈希表是一一對應,元類(metaclass)的位址自然也適用同樣邏輯。實務上較少這樣做,因為類層級的變數用 static 就足夠了。我在分類裡示範性地替 ViewController 類對象加了一個關聯對象,有興趣可以自己呼叫驗證:
+ (NSString *)associatedObject; + (void)setAssociatedObject:(NSString *)associatedObject;
OBJC_ASSOCIATION_RETAIN_NONATOMIC,以確保持有關聯對象。