目錄

• 簡介
• Runtime中的一些數(shù)據(jù)結(jié)構(gòu)
• 消息轉(zhuǎn)發(fā)
• 關(guān)聯(lián)對象的實現(xiàn)原理

簡介

因為Objc是一門動態(tài)語言，所以它總是想辦法把一些決定工作從編譯連接推遲到運行時流酬。也就是說只有編譯器是不夠的币厕，還需要一個運行時系統(tǒng) (runtime system) 來執(zhí)行編譯后的代碼。這就是 Objective-C Runtime 系統(tǒng)存在的意義芽腾，它是整個 Objc 運行框架的一塊基石旦装。

Runtime其實有兩個版本: “modern” 和 “l(fā)egacy”。我們現(xiàn)在用的 Objective-C 2.0 采用的是現(xiàn)行 (Modern) 版的 Runtime 系統(tǒng)摊滔，只能運行在 iOS 和 macOS 10.5 之后的 64 位程序中阴绢。而 maxOS 較老的32位程序仍采用 Objective-C 1 中的（早期）Legacy 版本的 Runtime 系統(tǒng)店乐。這兩個版本最大的區(qū)別在于當(dāng)你更改一個類的實例變量的布局時，在早期版本中你需要重新編譯它的子類呻袭，而現(xiàn)行版就不需要眨八。

在OC中調(diào)用一個函數(shù)，其實就是向一個對象（類也是一個對象）發(fā)送一條消息左电，比如：
[receiver message]
會被編譯器轉(zhuǎn)化為
objc_msgSend(receiver, selector)
了解Runtime其實就是了解OC動態(tài)特性的底層實現(xiàn)廉侧，這對于我們理解OC這門語言非常有必要。

下面篓足，你可以下載runtime的源碼然后來跟我一起探索

一段誊、Runtime中的一些數(shù)據(jù)結(jié)構(gòu)

首先，在runtime源碼的objc-private.h文件中我們可以看到對象和類都是一個結(jié)構(gòu)體：

對象與類的定義

點進(jìn)去我們一個一個查看

對象的結(jié)構(gòu)體

可以看到栈拖，對象主要就是一個包含isa變量的結(jié)構(gòu)體连舍，這個變量主要就是包含一個指向Class的指針。

isa_t

再來看看Class結(jié)構(gòu)體的具體定義涩哟。
在objc-runtime-old.h中索赏，它主要包含這樣一些數(shù)據(jù)結(jié)構(gòu)：

struct objc_class : objc_object {
    //繼承自objc_object的isa指針
    Class superclass;                       //指向父類的指針
    const char *name;                       //類名
    uint32_t version;                       //類的版本信息
    uint32_t info;                          //類信息，提供一些運行期使用的一些標(biāo)示位
    uint32_t instance_size;                 //類的實例變量的大小
    struct old_ivar_list *ivars;            //類的成員變量鏈表
    struct old_method_list **methodLists;   //方法定義的鏈表
    Cache cache;                            //方法緩存（用于消息發(fā)送時的查找）
    struct old_protocol_list *protocols;    //協(xié)議鏈表
}

可以看到染簇，objc_class是繼承自objc_object的参滴，所以別忘了强岸，objc_class也有一個isa指針锻弓。為什么類也有isa指針呢？我前面的文章曾經(jīng)提到過蝌箍，在創(chuàng)建類的時候青灼，Runtime其實創(chuàng)建了元類(Meta Class)，妓盲，所以類對象的所屬類型就是元類杂拨，具體信息可以參考這篇文章。關(guān)于類的信息全都存在這個數(shù)據(jù)結(jié)構(gòu)中悯衬，操作類其實就是操作這個結(jié)構(gòu)體弹沽。
但是這是之前的runtime實現(xiàn)，現(xiàn)行版的Runtime源碼在objc-runtime-new.h中：

現(xiàn)行版的Class結(jié)構(gòu)體

cacge_t

cacge_t

cache_t筋粗，顧名思義策橘，其實就是緩存，對應(yīng)于老版本的cache娜亿。
_buckets 存儲IMP丽已，_mask 和_occupied 對應(yīng) vtable。

bucket_t

bucket_t

bucket_t 中就是存儲了指針與 IMP 的鍵值對买决，以在方法查找的時候能夠?qū)彺孢^的方法進(jìn)行快速響應(yīng)沛婴。

class_data_bits_t

objc_class中最負(fù)責(zé)的就是bits吼畏，對類的操作幾乎就是圍繞它展開

struct class_data_bits_t {
    // Values are the FAST_ flags above.
    uintptr_t bits;
    class_rw_t* data() {
        return (class_rw_t *)(bits & FAST_DATA_MASK);
    }
}

結(jié)合前面objc_class 的data方法，就是直接將 class_data_bits_t 的data 方法返回嘁灯，返回的是 class_rw_t類型泻蚊，而這個值是bits與FAST_DATA_MASK按位與得到的結(jié)果。bits在內(nèi)存中每個位的含義如下：

32位：

32位

64位兼容版：

64位兼容版

64位不兼容版：

64位不兼容版

其中64位不兼容版每個宏對應(yīng)如下：

// class is a Swift class
#define FAST_IS_SWIFT           (1UL<<0)
// class's instances requires raw isa
#define FAST_REQUIRES_RAW_ISA   (1UL<<1)
// class or superclass has .cxx_destruct implementation
//   This bit is aligned with isa_t->hasCxxDtor to save an instruction.
#define FAST_HAS_CXX_DTOR       (1UL<<2)
// data pointer
#define FAST_DATA_MASK          0x00007ffffffffff8UL
// class or superclass has .cxx_construct implementation
#define FAST_HAS_CXX_CTOR       (1UL<<47)
// class or superclass has default alloc/allocWithZone: implementation
// Note this is is stored in the metaclass.
#define FAST_HAS_DEFAULT_AWZ    (1UL<<48)
// class or superclass has default retain/release/autorelease/retainCount/
//   _tryRetain/_isDeallocating/retainWeakReference/allowsWeakReference
#define FAST_HAS_DEFAULT_RR     (1UL<<49)
// summary bit for fast alloc path: !hasCxxCtor and 
//   !instancesRequireRawIsa and instanceSize fits into shiftedSize
#define FAST_ALLOC              (1UL<<50)
// instance size in units of 16 bytes
//   or 0 if the instance size is too big in this field
//   This field must be LAST
#define FAST_SHIFTED_SIZE_SHIFT 51

可以看到丑婿，這里面除了FAST_DATA_MASK 是一段控件存儲數(shù)據(jù)以外藕夫，其它都是用1bit來存儲bool值保存信息class_data_bits_t提供了三個方法用于位操作：getBit,setBits和clearBits，對應(yīng)到每個bool值的掩碼都有函數(shù)封裝枯冈，如：

    bool hasDefaultRR() {
        return getBit(FAST_HAS_DEFAULT_RR);
    }
    void setHasDefaultRR() {
        setBits(FAST_HAS_DEFAULT_RR);
    }
    void setHasCustomRR() {
        clearBits(FAST_HAS_DEFAULT_RR);
    }

具體的你可以看看源碼毅贮，我就不詳細(xì)貼出來了。

前面我們說了尘奏，這個data返回的是bits與FAST_DATA_MASK位與得到的值滩褥，而這里FAST_DATA_MASK其實就存儲了指向class_rw_t的指針。

class_rw_t

class_rw_t

乍一看炫加，這個好像是存儲類的方法瑰煎、屬性、協(xié)議等的俗孝，但是我們看到酒甸，這里還有一個class_ro_t，再繼續(xù)看看

class_ro_t

class_ro_t

梳理一下赋铝，整個結(jié)構(gòu)是這樣的：objc_class包含了class_data_bits_t插勤，class_data_bits_t存儲了class_rw_t的指針，而class_rw_t結(jié)構(gòu)體又包含class_ro_t指針革骨。lass_ro_t中的method_list_t, Ivar_list_t,property_list_t 結(jié)構(gòu)體都繼承自entsize_list_tt<Element, List, FlagMask>农尖。結(jié)構(gòu)為xxx_list_t的列表元素結(jié)構(gòu)為xxx_t，命名很工整良哲。protocol_list_t 與前三個不同盛卡，它存儲的是protocol_t *指針列表，實現(xiàn)比較簡單筑凫。

entsize_list_tt實現(xiàn)了 non-fragile特性的數(shù)組結(jié)構(gòu)滑沧。假如蘋果在新版本的 SDK 中向 NSObject類增加了一些內(nèi)容，NSObject的占據(jù)的內(nèi)存區(qū)域會擴(kuò)大巍实，開發(fā)者以前編譯出的二進(jìn)制中的子類就會與新的 NSObject 內(nèi)存有重疊部分滓技。于是在編譯期會給instanceStart和instanceSize賦值，確定好編譯時每個類的所占內(nèi)存區(qū)域起始偏移量和大小蔫浆，這樣只需將子類與基類的這兩個變量作對比即可知道子類是否與基類有重疊殖属，如果有，也可知道子類需要挪多少偏移量瓦盛。

class_ro_t->flags則存儲了很多在編譯時期就確定的類的信息洗显，也是 ABI 的一部分外潜。

總結(jié)：
class_rw_t提供了運行時對類拓展的能力，而class_ro_t存儲的大多是類在編譯時就已經(jīng)確定的信息挠唆。二者都存有類的方法处窥、屬性（成員變量）、協(xié)議等信息玄组，不過存儲它們的列表實現(xiàn)方式不同滔驾。

class_rw_t中使用的 method_array_t, property_array_t, protocol_array_t都繼承自list_array_tt<Element, List>, 它可以不斷擴(kuò)張，因為它可以存儲 list 指針俄讹，內(nèi)容有三種：

• 空
• 一個 entsize_list_tt 指針
• entsize_list_tt 指針數(shù)組

class_rw_t的內(nèi)容是可以在運行時被動態(tài)修改的哆致，可以說運行時對類的拓展大都是存儲在這里的。

class_rw_t->flags 存儲的值并不是編輯器設(shè)置的患膛，其中有些值可能將來會作為 ABI 的一部分摊阀。

demangledName 是計算機(jī)語言用于解決實體名稱唯一性的一種方法，做法是向名稱中添加一些類型信息踪蹬，用于從編譯器中向鏈接器傳遞更多語義信息胞此。

Category

Category

category_t 存儲了類別中可以拓展的實例方法、類方法跃捣、協(xié)議漱牵、實例屬性和類屬性。類屬性是 Objective-C 2016 年新增的特性疚漆，沾 Swift 的光酣胀。所以 category_t中有些成員變量是為了兼容 Swift 的特性，Objective-C 暫沒提供接口愿卸，僅做了底層數(shù)據(jù)結(jié)構(gòu)上的兼容灵临。

還有很多數(shù)據(jù)結(jié)構(gòu)，我就不一一貼出來了趴荸，源碼中都是可以直接查看的。

二宦焦、消息轉(zhuǎn)發(fā)

當(dāng)一個對象能接收一個消息時发钝，就會走正常的方法調(diào)用流程。但如果一個對象無法接收指定消息時波闹，就會啟動所謂”消息轉(zhuǎn)發(fā)(message forwarding)“機(jī)制酝豪，通過這一機(jī)制，我們可以告訴對象如何處理未知的消息精堕。默認(rèn)情況下孵淘，對象接收到未知的消息，會導(dǎo)致程序崩潰歹篓。

消息轉(zhuǎn)發(fā)一共有三步：

1. 動態(tài)方法解析
2. 備用接收者
3. 完整轉(zhuǎn)發(fā)

動態(tài)方法解析

對象在接收到未知的消息時瘫证，首先會調(diào)用所屬類的類方法+resolveInstanceMethod:(實例方法)或者+resolveClassMethod:(類方法)揉阎。在這個方法中，我們有機(jī)會為該未知消息新增一個”處理方法””背捌。不過使用該方法的前提是我們已經(jīng)實現(xiàn)了該”處理方法”毙籽，只需要在運行時通過class_addMethod函數(shù)動態(tài)添加到類里面就可以了。

void functionForMethod1(id self, SEL _cmd) {
    NSLog(@"%@, %p", self, _cmd);
}

+ (BOOL)resolveInstanceMethod:(SEL)sel{
    NSString *selectorString = NSStringFromSelector(sel);
    if ([selectorString isEqualToString:@"method1"]) {
        class_addMethod(self.class, @selector(method1), (IMP)functionForMethod1, "@:");
    }
    return [super resolveInstanceMethod:sel];
}

備用接受者

如果在上一步無法處理消息毡庆，則Runtime會繼續(xù)調(diào)以下方法：

- (id)forwardingTargetForSelector:(SEL)aSelector

如果一個對象實現(xiàn)了這個方法坑赡，并返回一個非nil且非self的結(jié)果，則這個對象會作為消息的新接收者么抗，且消息會被分發(fā)到這個對象毅否。如果我們沒有指定相應(yīng)的對象來處理aSelector，則應(yīng)該調(diào)用父類的實現(xiàn)來返回結(jié)果蝇刀。

如：

- (id)forwardingTargetForSelector:(SEL)aSelector{
    return [Test2 new];
}

此時發(fā)送的消息就會交給Test2的一個對象

注意：如果想替換類方法的接受者搀突，需要覆寫 + (id)forwardingTargetForSelector:(SEL)aSelector方法，并返回類對象：

這里編譯器沒有代碼補全提醒熊泵，且你在文檔中是找不到這個方法的仰迁，但是經(jīng)過實驗確實是有這個方法的，且能順利轉(zhuǎn)發(fā)類方法顽分。

完整消息轉(zhuǎn)發(fā)

如果在上一步還不能處理未知消息徐许，則唯一能做的就是啟用完整的消息轉(zhuǎn)發(fā)機(jī)制了。此時會調(diào)用以下方法：

- (void)forwardInvocation:(NSInvocation *)anInvocation

這里需要注意的是參數(shù)anInvocation是從哪的來的呢卒蘸？其實在forwardInvocation:消息發(fā)送前雌隅，Runtime系統(tǒng)會向?qū)ο蟀l(fā)送methodSignatureForSelector:消息，并取到返回的方法簽名用于生成NSInvocation對象缸沃。所以我們在重寫forwardInvocation:的同時也要重寫methodSignatureForSelector:方法恰起，否則會拋異常。

這一步轉(zhuǎn)發(fā)和第二步轉(zhuǎn)發(fā)的主要區(qū)別就是趾牧，它可以指定多個對象進(jìn)行轉(zhuǎn)發(fā)检盼，且這些對象都需要實現(xiàn)相應(yīng)的方法，否則依然會拋出異常翘单。如：

- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector{
    NSString *sel = NSStringFromSelector(aSelector);
    if ([sel isEqualToString:@"add"]) {
        return [NSMethodSignature signatureWithObjCTypes:"v:@"];
    }
    return [super methodSignatureForSelector:aSelector];
}

- (void)forwardInvocation:(NSInvocation *)anInvocation{
    SEL sel = anInvocation.selector;
    if ([NSStringFromSelector(sel) isEqualToString:@"add"]) {
        [anInvocation invokeWithTarget:[Test2 new]];
        [anInvocation invokeWithTarget:[Test3 new]];
    }
}

此時Test2和Test3兩個類的對象都會轉(zhuǎn)發(fā)這條消息吨枉。

三、關(guān)聯(lián)對象的實現(xiàn)原理（Associated Objects）

這里我就不介紹關(guān)聯(lián)對象的使用了哄芜，網(wǎng)上相關(guān)博客有很多貌亭，這里我們介紹關(guān)聯(lián)對象是如果把一個對象關(guān)聯(lián)起來的。
我們直接看關(guān)聯(lián)對象相關(guān)的三個方法吧：

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

我們直接看objc-runtime.mm中的源碼

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) {
    // 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 (old_association.hasValue()) ReleaseValue()(old_association);
}

這里我省略了大多的實現(xiàn)代碼认臊，我們主要看它的實現(xiàn)原理就好圃庭。

主要注意這里的幾個類和數(shù)據(jù)結(jié)構(gòu)：

• AssociationsManager
• AssociationsHashMap
• ObjcAssociationMap
• ObjcAssociation

AssociationsManager 在源代碼中的定義是這樣的：

spinlock_t AssociationsManagerLock;

class AssociationsManager {
    // associative references: object pointer -> PtrPtrHashMap.
    static AssociationsHashMap *_map;
public:
    AssociationsManager()   { AssociationsManagerLock.lock(); }
    ~AssociationsManager()  { AssociationsManagerLock.unlock(); }
    
    AssociationsHashMap &associations() {
        if (_map == NULL)
            _map = new AssociationsHashMap();
        return *_map;
    }
};

它維護(hù)了spinlock_t 和 AssociationsHashMap的單例，初始化它的時候會調(diào)用 lock.lock() 方法，在析構(gòu)時會調(diào)用lock.unlock()剧腻，而 associations 方法用于取得一個全局的 AssociationsHashMap 單例拘央。

也就是說 AssociationsManager 通過持有一個自旋鎖 spinlock_t 保證對 AssociationsHashMap 的操作是線程安全的，即每次只會有一個線程對 AssociationsHashMap 進(jìn)行操作恕酸。

如何存儲ObjcAssociation

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

AssociationsHashMap用于保存從對象的 disguised_ptr_t 到 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); }
    };

ObjectAssociationMap則保存了從key 到關(guān)聯(lián)對象ObjcAssociation 的映射，這個數(shù)據(jù)結(jié)構(gòu)保存了當(dāng)前對象對應(yīng)的所有關(guān)聯(lián)對象

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

ObjcAssociation 包含了 policy以及 value

舉一個簡單的例子：

        NSObject *obj = [NSObject new];
        objc_setAssociatedObject(obj, @selector(hello), @"Hello", OBJC_ASSOCIATION_RETAIN_NONATOMIC);

這里的關(guān)聯(lián)對象 ObjcAssociation(OBJC_ASSOCIATION_RETAIN_NONATOMIC, @"Hello") 在內(nèi)存中是這么存儲的：

associateobjcect

好了蕊温，我們回到對 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);
}

1. 使用 old_association(0, nil) 創(chuàng)建一個臨時的 ObjcAssociation 對象（用于持有原有的關(guān)聯(lián)對象袱箱，方便在方法調(diào)用的最后釋放值）

當(dāng)new_value != nil的情況下

2. 調(diào)用 acquireValue對new_value進(jìn)行retain 或者 copy

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

3. 初始化一個 AssociationsManager，并獲取唯一的保存關(guān)聯(lián)對象的哈希表AssociationsHashMap

4. 先使用 DISGUISE(object) 作為 key 尋找對應(yīng)的 ObjectAssociationMap

5. 如果沒有找到义矛，初始化一個 ObjectAssociationMap发笔，再實例化 ObjcAssociation 對象添加到 Map 中，并調(diào)用 setHasAssociatedObjects 方法(它會將 isa 結(jié)構(gòu)體中的標(biāo)記位 has_assoc 標(biāo)記為 true)凉翻，表明當(dāng)前對象含有關(guān)聯(lián)對象

ObjectAssociationMap *refs = new ObjectAssociationMap;
associations[disguised_object] = refs;
(*refs)[key] = ObjcAssociation(policy, new_value);
object->setHasAssociatedObjects();

6. 如果找到了對應(yīng)的 ObjectAssociationMap了讨，就要看 key 是否存在了，由此來決定是更新原有的關(guān)聯(lián)對象制轰，還是增加一個

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

7. 最后前计，如果原來的關(guān)聯(lián)對象有值的話，會調(diào)用 ReleaseValue() 釋放關(guān)聯(lián)對象的值

當(dāng)new_value == nil的情況下垃杖，其實就是調(diào)用 erase 方法男杈，擦除 ObjectAssociationMap 中 key 對應(yīng)的節(jié)點，刪除對應(yīng)key的關(guān)聯(lián)對象调俘。

objc_getAssociatedObject
前面objc_setAssociatedObject已經(jīng)詳細(xì)介紹了伶棒，下面這兩個方法就很容易理解了。

id objc_getAssociatedObject(id object, const void *key) {
    return _object_get_associative_reference(object, (void *)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) {
                    objc_retain(value);
                }
            }
        }
    }
    if (value && (policy & OBJC_ASSOCIATION_GETTER_AUTORELEASE)) {
        objc_autorelease(value);
    }
    return value;
}

它的邏輯和objc_setAssociatedObject差不多

1. 獲取靜態(tài)變量AssociationsHashMap

2. 以 DISGUISE(object)為 key 查找AssociationsHashMap

3. 以void *key為key查找ObjcAssociation

4. 根據(jù) policy調(diào)用相應(yīng)的方法

if (policy & OBJC_ASSOCIATION_GETTER_RETAIN) {
      objc_retain(value);
 }

if (value && (policy & OBJC_ASSOCIATION_GETTER_AUTORELEASE)) {
     objc_autorelease(value);
 }

5. 返回關(guān)聯(lián)對象 ObjcAssociation 的值

objc_removeAssociatedObjects

直接放代碼吧

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

看到這里我想也沒啥需要說的了彩库，唯一需要注意一點的就是這里在刪除之前肤无，它加了個判斷if (object && object->hasAssociatedObjects())
我們來看看這個hasAssociatedObjects

objc_object::hasAssociatedObjects()
{
    if (isTaggedPointer()) return true;
    if (isa.nonpointer) return isa.has_assoc;
    return true;
}

如果是TaggedPointer，則返回true骇钦，正常對象則是根據(jù)isa的標(biāo)記位來判斷是否存在關(guān)聯(lián)對象宛渐。

總結(jié)

Runtime是支持OC的一個非常強大的庫，OC的很多特性都是依賴于Runtime司忱，所以想要更好的掌握這門語言皇忿，對Runtime的理解是必要的。

最后坦仍，文中有什么錯誤的地方希望大家指出，希望和大家共同進(jìn)步叨襟。