Objective-C Associated Objects 的實現原理

本人錄製技術視頻地址：https://edu.csdn.net/lecturer/1899 歡迎觀看。

我們知道，在 Objective-C 中可以通過 Category 給一個現有的類添加屬性，但是卻不能添加實例變量，這似乎成爲了 Objective-C 的一個明顯短板。然而值得慶幸的是，我們可以通過 Associated Objects 來彌補這一不足。本文將結合 runtime 源碼深入探究 Objective-C 中 Associated Objects 的實現原理。

在閱讀本文的過程中，讀者需要着重關注以下三個問題：

1. 關聯對象被存儲在什麼地方，是不是存放在被關聯對象本身的內存中？
2. 關聯對象的五種關聯策略有什麼區別，有什麼坑？
3. 關聯對象的生命週期是怎樣的，什麼時候被釋放，什麼時候被移除？

這是我寫這篇文章的初衷，也是本文的價值所在。

使用場景

按照 Mattt Thompson 大神的文章 Associated Objects 中的說法，Associated Objects 主要有以下三個使用場景：

1. 爲現有的類添加私有變量以幫助實現細節；
2. 爲現有的類添加公有屬性；
3. 爲 KVO 創建一個關聯的觀察者。

從本質上看，第1、2 個場景其實是一個意思，唯一的區別就在於新添加的這個屬性是公有的還是私有的而已。就目前來說，我在實際工作中使用得最多的是第2個場景，而第3個場景我還沒有使用過。

相關函數

與 Associated Objects 相關的函數主要有三個，我們可以在 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 用於移除一個對象的所有關聯對象。

注：objc_removeAssociatedObjects函數我們一般是用不上的，因爲這個函數會移除一個對象的所有關聯對象，將該對象恢復成“原始”狀態。這樣做就很有可能把別人添加的關聯對象也一併移除，這並不是我們所希望的。所以一般的做法是通過給objc_setAssociatedObject函數傳入 nil 來移除某個已有的關聯對象。

key 值

關於前兩個函數中的 key 值是我們需要重點關注的一個點，這個key 值必須保證是一個對象級別（爲什麼是對象級別？看完下面的章節你就會明白了）的唯一常量。一般來說，有以下三種推薦的key 值：

1. 聲明static char kAssociatedObjectKey;，使用&kAssociatedObjectKey作爲key值;
2. 聲明static void *kAssociatedObjectKey = &kAssociatedObjectKey;，使用kAssociatedObjectKey作爲key值；
3. 用 selector，使用getter方法的名稱作爲key值。

我個人最喜歡的（沒有之一）是第3種方式，因爲它省掉了一個變量名，非常優雅地解決了計算科學中的兩大世界難題之一（命名）。

關聯策略

在給一個對象添加關聯對象時有五種關聯策略可供選擇：

關聯策略	等價屬性	說明
OBJC_ASSOCIATION_ASSIGN	@property (assign) or @property (unsafe_unretained)	弱引用關聯對象
OBJC_ASSOCIATION_RETAIN_NONATOMIC	@property (strong, nonatomic)	強引用關聯對象，且爲非原子操作
OBJC_ASSOCIATION_COPY_NONATOMIC	@property (copy, nonatomic)	複製關聯對象，且爲非原子操作
OBJC_ASSOCIATION_RETAIN	@property (strong, atomic)	強引用關聯對象，且爲原子操作
OBJC_ASSOCIATION_COPY	@property (copy, atomic)	複製關聯對象，且爲原子操作

其中，第2種與第4種、第3種與第5種關聯策略的唯一差別就在於操作是否具有原子性。由於操作的原子性不在本文的討論範圍內，所以下面的實驗和討論就以前三種以例進行展開。

實現原理

在探究 Associated Objects 的實現原理前，我們還是先來動手做一個小實驗，研究一下關聯對象什麼時候會被釋放。本實驗主要涉及ViewController類和它的分類ViewController+AssociatedObjects。注：本實驗的完整代碼可以在這裏 AssociatedObjects 找到，其中關鍵代碼如下：

@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 *)associatedObject_assign {
    objc_setAssociatedObject(self, @selector(associatedObject_assign), associatedObject_assign, OBJC_ASSOCIATION_ASSIGN);
}

- (NSString *)associatedObject_retain {
    return objc_getAssociatedObject(self, _cmd);
}

- (void)setAssociatedObject_retain:(NSString *)associatedObject_retain {
    objc_setAssociatedObject(self, @selector(associatedObject_retain), associatedObject_retain, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}

- (NSString *)associatedObject_copy {
    return objc_getAssociatedObject(self, _cmd);
}

- (void)setAssociatedObject_copy:(NSString *)associatedObject_copy {
    objc_setAssociatedObject(self, @selector(associatedObject_copy), associatedObject_copy, OBJC_ASSOCIATION_COPY_NONATOMIC);
}

@end

在ViewController+AssociatedObjects.h中聲明瞭三個屬性，限定符分別爲assign, nonatomic、strong, nonatomic和copy, nonatomic，而在ViewController+AssociatedObjects.m中相應的分別用OBJC_ASSOCIATION_ASSIGN、OBJC_ASSOCIATION_RETAIN_NONATOMIC、OBJC_ASSOCIATION_COPY_NONATOMIC三種關聯策略爲這三個屬性添加“實例變量”。

__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); // Will Crash
    NSLog(@"self.associatedObject_retain: %@", self.associatedObject_retain);
    NSLog(@"self.associatedObject_copy:   %@", self.associatedObject_copy);
}

@end

在ViewController的viewDidLoad方法中，我們對三個屬性進行了賦值，並聲明瞭三個全局的__weak變量來觀察相應對象的釋放時機。此外，我們重寫了touchesBegan:withEvent:方法，在方法中分別打印了這三個屬性的當前值。

在繼續閱讀下面章節前，建議讀者先自行思考一下self.associatedObject_assign、self.associatedObject_retain和 self.associatedObject_copy指向的對象分別會在什麼時候被釋放，以加深理解。

實驗

我們先在viewDidLoad方法的第28行打上斷點，然後運行程序，點擊導航欄右上角的按鈕Push到ViewController界面，程序將停在斷點處。接着，我們使用lldb的watchpoint命令來設置觀察點，觀察全局變量string_weak_assign、string_weak_retain和 string_weak_copy的值的變化。正確設置好觀察點後，將會在console中看到如下的類似輸出：

點擊繼續運行按鈕，有一個觀察點將被命中。我們先查看console中的輸出，通過將這一步打印的old value和上一步的 new value進行對比，我們可以知道本次命中的觀察點是string_weak_assign，string_weak_assign的值變成了 0x0000000000000000，也就是nil。換句話說self.associatedObject_assign指向的對象已經被釋放了，而通過查看左側調用棧我們可以知道，這個對象是由於其所在的autoreleasepool被drain而被釋放的，這與我前面的文章《Objective-C Autorelease Pool 的實現原理》中的表述是一致的。提示，待會你也可以放開touchesBegan:withEvent:中第31行的註釋，在ViewController出現後，點擊一下它的view，進一步驗證一下這個結論。

接下來，我們點擊ViewController導航欄左上角的按鈕，返回前一個界面，此時，又將有一個觀察點被命中。同理，我們可以知道這個觀察點是string_weak_retain。我們查看左側的調用棧，將會發現一個非常敏感的函數調用 _object_remove_assocations，調用這個函數後ViewController的所有關聯對象被全部移除。最終，self.associatedObject_retain指向的對象被釋放。

點擊繼續運行按鈕，最後一個觀察點string_weak_copy被命中。同理，self.associatedObject_copy指向的對象也由於關聯對象的移除被最終釋放。

結論

由這個實驗，我們可以得出以下結論：

1. 關聯對象的釋放時機與被移除的時機並不總是一致的，比如上面的self.associatedObject_assign所指向的對象在ViewController出現後就被釋放了，但是self.associatedObject_assign仍然有值，還是保存的原對象的地址。如果之後再使用self.associatedObject_assign就會造成 Crash ，所以我們在使用弱引用的關聯對象時要非常小心；
2. 一個對象的所有關聯對象是在這個對象被釋放時調用的_object_remove_assocations函數中被移除的。

接下來，我們就一起看看 runtime 中的源碼，來驗證下我們的實驗結論。

objc_setAssociatedObject

我們可以在objc-references.mm文件中找到objc_setAssociatedObject函數最終調用的函數：

void _object_set_associative_reference(id object, void *key, id value, uintptr_t policy) {
    // retain the new value (if any) outside the lock.
    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) {
            // break any existing association.
            AssociationsHashMap::iterator i = associations.find(disguised_object);
            if (i != associations.end()) {
                // secondary table exists
                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 {
                // create the new association (first time).
                ObjectAssociationMap *refs = new ObjectAssociationMap;
                associations[disguised_object] = refs;
                (*refs)[key] = ObjcAssociation(policy, new_value);
                object->setHasAssociatedObjects();
            }
        } else {
            // setting the association to nil breaks the association.
            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);
                }
            }
        }
    }
    // release the old value (outside of the lock).
    if (old_association.hasValue()) ReleaseValue()(old_association);
}

在看這段代碼前，我們需要先了解一下幾個數據結構以及它們之間的關係：

AssociationsManager是頂級的對象，維護了一個從spinlock_t鎖到AssociationsHashMap哈希表的單例鍵值對映射；

AssociationsHashMap是一個無序的哈希表，維護了從對象地址到ObjectAssociationMap的映射；

ObjectAssociationMap是一個C++中的map，維護了從key到ObjcAssociation的映射，即關聯記錄；

1. ObjcAssociation是一個C++的類，表示一個具體的關聯結構，主要包括兩個實例變量，_policy表示關聯策略,_value表示關聯對象。

每一個對象地址對應一個ObjectAssociationMap對象，而一個ObjectAssociationMap對象保存着這個對象的若干個關聯記錄。

弄清楚這些數據結構之間的關係後，再回過頭來看上面的代碼就不難了。我們發現，在蘋果的底層代碼中一般都會充斥着各種if else，可見寫好if else後我們就距離成爲高手不遠了。開個玩笑，我們來看下面的流程圖，一圖勝千言：

objc_getAssociatedObject

同樣的，我們也可以在objc-references.mm文件中找到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;
}

看懂了objc_setAssociatedObject函數後，objc_getAssociatedObject函數對我們來說就是小菜一碟了。這個函數先根據對象地址在AssociationsHashMap中查找其對應的ObjectAssociationMap對象，如果能找到則進一步根據key在ObjectAssociationMap對象中查找這個key所對應的關聯結構ObjcAssociation，如果能找到則返回ObjcAssociation 對象的value值，否則返回nil。

objc_removeAssociatedObjects

同理，我們也可以在objc-references.mm文件中找到objc_removeAssociatedObjects函數最終調用的函數：

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()) {
            // copy all of the associations that need to be removed.
            ObjectAssociationMap *refs = i->second;
            for (ObjectAssociationMap::iterator j = refs->begin(), end = refs->end(); j != end; ++j) {
                elements.push_back(j->second);
            }
            // remove the secondary table.
            delete refs;
            associations.erase(i);
        }
    }
    // the calls to releaseValue() happen outside of the lock.
    for_each(elements.begin(), elements.end(), ReleaseValue());
}

這個函數負責移除一個對象的所有關聯對象，具體實現也是先根據對象的地址獲取其對應的ObjectAssociationMap對象，然後將所有的關聯結構保存到一個vector中，最終釋放 vector中保存的所有關聯對象。根據前面的實驗觀察到的情況，在一個對象被釋放時，也正是調用的這個函數來移除其所有的關聯對象。

給類對象添加關聯對象

看完源代碼後，我們知道對象地址與AssociationsHashMap哈希表是一一對應的。那麼我們可能就會思考這樣一個問題，是否可以給類對象添加關聯對象呢？答案是肯定的。我們完全可以用同樣的方式給類對象添加關聯對象，只不過我們一般情況下不會這樣做，因爲更多時候我們可以通過static變量來實現類級別的變量。我在分類ViewController+AssociatedObjects中給ViewController類對象添加了一個關聯對象associatedObject，讀者可以親自在viewDidLoad方法中調用一下以下兩個方法驗證一下：

+ (NSString *)associatedObject;
+ (void)setAssociatedObject:(NSString *)associatedObject;

總結

讀到這裏，相信你對開篇的那三個問題已經有了一定的認識，下面我們再梳理一下：

1. 關聯對象與被關聯對象本身的存儲並沒有直接的關係，它是存儲在單獨的哈希表中的；
2. 關聯對象的五種關聯策略與屬性的限定符非常類似，在絕大多數情況下，我們都會使用OBJC_ASSOCIATION_RETAIN_NONATOMIC的關聯策略，這可以保證我們持有關聯對象；
3. 關聯對象的釋放時機與移除時機並不總是一致，比如實驗中用關聯策略OBJC_ASSOCIATION_ASSIGN進行關聯的對象，很早就已經被釋放了，但是並沒有被移除，而再使用這個關聯對象時就會造成 Crash 。

在弄懂 Associated Objects 的實現原理後，可以幫助我們更好地使用它，在出現問題時也能儘快地定位問題，最後希望本文能夠對你有所幫助。

原文地址：http://blog.leichunfeng.com/blog/2015/06/26/objective-c-associated-objects-implementation-principle/