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

動手看源碼:Objective-C Associated Objects 的底層實現

編輯:iOS 開發綜合

Objective-C 有個眾所皆知的限制:Category 可以替既有類別加上屬性,卻無法加上實例變數。Associated Objects 正是為了填補這個缺口而生。本文不打算停在「怎麼用」,而是往下追進 runtime 源碼,把三個問題問清楚。

先拋出三個問題

  1. 關聯對象究竟存在哪裡?會不會就掛在被關聯對象自己的記憶體上?
  2. 五種關聯策略差別在哪,有哪些坑?
  3. 關聯對象的生命週期如何?什麼時候被釋放,什麼時候被移除?

先給答案,後面的實作與源碼用來佐證:

  1. 關聯對象與被關聯對象本身的儲存沒有直接關係,它存放在一張獨立的哈希表中。
  2. 五種關聯策略與屬性限定符高度相似。絕大多數情況下我們會用 OBJC_ASSOCIATION_RETAIN_NONATOMIC,這能確保我們持有該對象。
  3. 關聯對象的釋放時機與移除時機並不總是一致。以 OBJC_ASSOCIATION_ASSIGN 關聯的對象往往很早就被釋放了,卻沒有從關聯表中移除,此時再取用就會 Crash。

典型使用場景

依照 Mattt Thompson 在〈Associated Objects〉一文中的歸納,主要有三類:

  1. 為既有類別添加私有變數,以實作內部細節;
  2. 為既有類別添加公開屬性;
  3. 為 KVO 建立關聯的觀察者。

本質上第 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 的選法

key 必須是對象層級的唯一常量(原因看後面的源碼就明白了)。常見有三種寫法:

  1. 宣告 static char kAssociatedObjectKey;,用 &kAssociatedObjectKey 當 key;
  2. 宣告 static void *kAssociatedObjectKey = &kAssociatedObjectKey;,直接用 kAssociatedObjectKey;
  3. 直接用 selector,也就是 getter 方法名稱作為 key。

我偏好第三種。它省掉一個變數名,優雅地繞開了計算科學的兩大難題之一:命名。

五種關聯策略

其中第 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 被命中,原因同上,也是因為關聯對象被移除而釋放。

實驗結論

  1. 關聯對象的釋放時機與移除時機不一定相同。assign 策略下的對象在頁面出現後就被釋放了,但關聯記錄還在,仍保存著原對象位址。此時若再去存取它,就會 Crash。使用弱引用型關聯對象時務必小心。
  2. 一個對象的所有關聯對象,是在該對象釋放時由 _object_remove_assocations 統一移除的。

源碼驗證:objc_setAssociatedObject

在 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);
}

讀這段之前,先釐清四個資料結構的層級關係:

  1. AssociationsManager:最頂層,維護「鎖 → AssociationsHashMap」的單例映射;
  2. AssociationsHashMap:無序哈希表,維護「對象位址 → ObjectAssociationMap」的映射;
  3. ObjectAssociationMap:C++ 的 map,維護「key → ObjcAssociation」的映射,也就是關聯記錄本身;
  4. ObjcAssociation:表示一筆具體的關聯,含 _policy(策略)與 _value(關聯對象)兩個成員。

也就是說,每個對象位址對應一份 ObjectAssociationMap,而一份 ObjectAssociationMap 保存該對象的若干筆關聯記錄。這也解釋了為什麼 key 只要「對象層級唯一」就夠了——它是在二級表裡做查找的。釐清這層關係後,上面的程式碼其實並不難讀。

objc_getAssociatedObject

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 則決定了要不要對回傳值加工。

objc_removeAssociatedObjects

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;

總結

  1. 關聯對象與被關聯對象本身的儲存沒有直接關係,它獨立存放在 runtime 維護的哈希表中。
  2. 五種關聯策略與屬性限定符高度相似。絕大多數情況下選 OBJC_ASSOCIATION_RETAIN_NONATOMIC,以確保持有關聯對象。
  3. 關聯對象的釋放時機與移除時機並不總是一致。以 ASSIGN 策略關聯的對象可能早就被釋放,卻仍留在關聯表中,再次取用便會 Crash。
  1. 上一篇文章:
  2. 下一篇文章:
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © IOS教程網 All Rights Reserved