Runtime源碼 —— Associated Object

這玩意兒已經(jīng)在前面的文章里多次提到，但一直沒深入，這一篇就來研究研究。

runtime提供的和associated object有關(guān)的接口有3個：

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

選第一個作為切入點，詳細(xì)分析一下，其他兩個方法稍微說一說。

objc_setAssociatedObject

void objc_setAssociatedObject(id object, const void *key, id value, objc_AssociationPolicy policy) {
    _object_set_associative_reference(object, (void *)key, value, policy);
}

void _object_set_associative_reference(id object, void *key, id value, uintptr_t policy) {
    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 {
            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);
}

想要理解associated object的存取過程，就必須要對這個方法中提到的幾個類有足夠的了解，按照層次依次是：

  • AssociationsManager
// class AssociationsManager manages a lock / hash table singleton pair.
// Allocating an instance acquires the lock, and calling its assocations() method
// lazily allocates it.
class AssociationsManager {
    static spinlock_t _lock;
    static AssociationsHashMap *_map;               // associative references:  object pointer -> PtrPtrHashMap.
public:
    AssociationsManager()   { _lock.lock(); }
    ~AssociationsManager()  { _lock.unlock(); }
    
    AssociationsHashMap &associations() {
        if (_map == NULL)
            _map = new AssociationsHashMap();
        return *_map;
    }
};

注釋寫了，AssociationsManager管理了一個自旋鎖到哈希表的單例映射。通過associations()方法可以取到管理的AssociationsHashMap單例。

  • AssociationsHashMap
class AssociationsHashMap : public unordered_map
<disguised_ptr_t, 
ObjectAssociationMap *, 
DisguisedPointerHash, 
DisguisedPointerEqual, 
AssociationsHashMapAllocator> {
public:
    void *operator new(size_t n) { return ::malloc(n); }
    void operator delete(void *ptr) { ::free(ptr); }
};

這是一個無序哈希表，存儲的是對象地址(set方法的第一個參數(shù)取反)到ObjectAssociationMap的映射。

  • ObjectAssociationMap
class ObjectAssociationMap : public std::map
<void *, 
ObjcAssociation, 
ObjectPointerLess, 
ObjectAssociationMapAllocator> {
public:
    void *operator new(size_t n) { return ::malloc(n); }
    void operator delete(void *ptr) { ::free(ptr); }
};

此表存儲了key(set方法的第二個參數(shù))到被關(guān)聯(lián)對象ObjcAssociation的映射。

  • ObjcAssociation
class ObjcAssociation {
    uintptr_t _policy;
    id _value;
public:
    ObjcAssociation(uintptr_t policy, id value) : _policy(policy), _value(value) {}
    ObjcAssociation() : _policy(0), _value(nil) {}

    uintptr_t policy() const { return _policy; }
    id value() const { return _value; }
    
    bool hasValue() { return _value != nil; }
};

存儲關(guān)聯(lián)對象的信息，_value對應(yīng)第三個參數(shù)，_policy對應(yīng)第四個參數(shù)。

至此set方法的四個參數(shù)都用上了，再回過去把set方法分解一哈就很簡單了：

ObjcAssociation old_association(0, nil);

先聲明一個對象用來存放可能存在的舊的value，即如果你對一個對象調(diào)用了兩次set方法，那么在第二次set的時候，需要把第一個set進(jìn)去的value釋放掉。這個對象就是存儲前一次的value用于釋放。

id new_value = value ? acquireValue(value, policy) : nil;

static id acquireValue(id value, uintptr_t policy) {
    switch (policy & 0xFF) {
    case OBJC_ASSOCIATION_SETTER_RETAIN:
        return ((id(*)(id, SEL))objc_msgSend)(value, SEL_retain);
    case OBJC_ASSOCIATION_SETTER_COPY:
        return ((id(*)(id, SEL))objc_msgSend)(value, SEL_copy);
    }
    return value;
}

typedef OBJC_ENUM(uintptr_t, objc_AssociationPolicy) {
    OBJC_ASSOCIATION_ASSIGN = 0,    
    OBJC_ASSOCIATION_RETAIN_NONATOMIC = 1, 
    OBJC_ASSOCIATION_COPY_NONATOMIC = 3,  
    OBJC_ASSOCIATION_RETAIN = 01401,      
    OBJC_ASSOCIATION_COPY = 01403          
};

根據(jù)調(diào)用set方法傳的policy調(diào)用對應(yīng)的方法。比如retain或者copy。

AssociationsManager manager;
AssociationsHashMap &associations(manager.associations());
disguised_ptr_t disguised_object = DISGUISE(object);

inline disguised_ptr_t DISGUISE(id value) { return ~ uintptr_t(value); }
typedef uintptr_t disguised_ptr_t;

先獲取AssociationsManager，在構(gòu)造函數(shù)中會進(jìn)行加鎖。接著通過associations()方法獲取AssociationsHashMap單例，如果前兩步看起來有些不習(xí)慣，重寫一下就清楚了：

AssociationsManager manager = AssociationsManager();
AssociationsHashMap &associations = manager.associations();

最后一行就是把object的地址取反，后面會用作AssociationsHashMap的鍵。

if (new_value) {
    AssociationsHashMap::iterator i = associations.find(disguised_object);
(1)  if (i != associations.end()) {
        ObjectAssociationMap *refs = i->second;
        ObjectAssociationMap::iterator j = refs->find(key);
(2)     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();
    }
}

先判斷是否傳入了新的value，如果傳入新的value，就進(jìn)入了設(shè)置關(guān)聯(lián)對象的流程。

首先通過上一步處理好的對象地址進(jìn)行查找：

  • (1) == true
    根據(jù)AssociationsHashMap的定義，直接獲取ObjectAssociationMap。

  • (2) == true
    代表曾經(jīng)設(shè)置過關(guān)聯(lián)對象，把原先的值存到old_association中，留作后面釋放，再把新值通過ObjcAssociation(policy, new_value)構(gòu)造函數(shù)存放進(jìn)去。

  • (2) == false
    通過key找不到關(guān)聯(lián)對象，直接構(gòu)造一個新的ObjcAssociation對象作為key的value。

  • (1) == false
    即通過對象地址就查找不到，代表從未設(shè)置過關(guān)聯(lián)對象，那么該創(chuàng)建的創(chuàng)建，該關(guān)聯(lián)的關(guān)聯(lián)。最后通過：

object->setHasAssociatedObjects()

將isa的has_assoc字段設(shè)為true。

隨著源代碼的閱讀，最開始那篇Runtime源碼 —— 對象、類和isa中對isa有些不熟悉的字段也就一個一個見到了。有種融會貫通的感覺，哈哈。

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

如果調(diào)用set方法沒有傳入新的值，那么就把關(guān)聯(lián)對象從ObjectAssociationMap中刪除掉。就好像把對象設(shè)為nil要release一樣。

// release the old value (outside of the lock).
if (old_association.hasValue()) ReleaseValue()(old_association);

struct ReleaseValue {
    void operator() (ObjcAssociation &association) {
        releaseValue(association.value(), association.policy());
    }
};

static void releaseValue(id value, uintptr_t policy) {
    if (policy & OBJC_ASSOCIATION_SETTER_RETAIN) {
        ((id(*)(id, SEL))objc_msgSend)(value, SEL_release);
    }
}

最后一步，把原先的值釋放掉。當(dāng)然只有policy是retain的才需要釋放，assign和copy的的就不需要了。

這就是set方法的全部過程。因為嵌套了兩層map，看起來有點繞。

objc_getAssociatedObject

理解了set的過程，再通過get方法的參數(shù)：

id _object_get_associative_reference(id object, void *key)

猜測一下get的過程應(yīng)該是這樣的：

  • 先獲取AssociationsManager單例，進(jìn)而獲取AssociationsHashMap
  • 通過object獲取ObjectAssociationMap
  • 通過key獲取ObjcAssociation
  • 取出ObjcAssociation中的value并返回

看起來合情合理，再看看源碼：

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

跟預(yù)測的流程幾乎一樣，只是從ObjcAssociation中獲取value的時候，需要根據(jù)policy進(jìn)行相應(yīng)的retain，autorelease。

objc_removeAssociatedObjects

這個方法用于刪除對象的全部關(guān)聯(lián)對象，參數(shù)就一個，就是想要清理的對象：

void objc_removeAssociatedObjects(id object) 
{
    if (object && object->hasAssociatedObjects()) {
        _object_remove_assocations(object);
    }
}

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

先判斷是否存在關(guān)聯(lián)對象，如果存在，才需要進(jìn)行清除。

清除的過程分為幾個部分：

  • 存儲ObjectAssociationMap中存在的所有的ObjcAssociation
  • 釋放ObjectAssociationMap內(nèi)存并從AssociationsHashMap中刪除
  • 釋放所有的ObjcAssociation，最后那個ReleaseValue()方法就是對有需要的對象調(diào)用release

全部完成之后AssociationsHashMap中就不存在此對象的任何關(guān)聯(lián)對象了。

總結(jié)

  • 被關(guān)聯(lián)的對象與關(guān)聯(lián)對象在數(shù)據(jù)結(jié)構(gòu)上并沒有什么關(guān)系，關(guān)聯(lián)對象是由AssociationsManager統(tǒng)一管理
  • 通常情況下不需要主動調(diào)用objc_removeAssociatedObjects(...)方法，移除關(guān)聯(lián)對象會在對象release -> dealloc的時候自動調(diào)用，如果想要移除某個關(guān)聯(lián)對象，調(diào)用objc_setAssociatedObject(...)方法，并設(shè)置value為nil。
  • 在category中通過關(guān)聯(lián)對象實現(xiàn)的get/set接口只是讓屬性看起來像是屬性，category本身還是無法添加實例變量。
最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時請結(jié)合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務(wù)。

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容