简介

Associated Objects 是 Objective-C 2.0 中 Runtime 的特性之一。
在中定义的三个方法，

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 用于移除一个对象的所有关联对象。
object：传入关联对象的所属对象，也就是增加成员的实例对象，一般来说传入 self。
key：唯一标记，即可以使用 static char 作为 key 值，也可以使用 static void *kAssociatedObjectKey 指针作为 key 值，当然推荐使用用 selector，使用 getter 方法的名称作为 key 值，可以利用 _cmd 来方便的取出 selector。
value：传入关联对象。
policy：objc_AssociationPolicy 是一个 Objective-C 枚举类型，也代表关联策略。

注意：objc_removeAssociatedObjects这个方法会移除一个对象的所有关联对象，一般通过给 objc_setAssociatedObject 函数传入 nil 来移除某个已有的关联对象。

关联策略

OBJC_ASSOCIATION_ASSIGN：弱引用关联对象，一般修饰词为 assign、unsafe_unretained。
OBJC_ASSOCIATION_RETAIN_NONATOMIC：强引用关联对象，非原子操作，修饰词为 strong、nonatomic。
OBJC_ASSOCIATION_COPY_NONATOMIC：复制关联对象，非原子操作，修饰词为 copy、nonatomic。
OBJC_ASSOCIATION_RETAIN：强引用关联对象，原子操作，修饰词为 strong、atomic。
OBJC_ASSOCIATION_COPY：复制关联对象，原子操作，修饰词为 copy、atomic。

注意：OBJC_ASSOCIATION_ASSIGN 弱引用关联对象，一般修饰词为 assign、unsafe_unretained 和 weak 有区别，当对象销毁时，指针的地址还是存在的，也就是说指针并没有被置为 nil，再次访问会造成野指针。

实现原理

objc_setAssociatedObject

下面我们看下 Runtime 的源码。
以下源码来自于[opensource.apple.com]

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

通过调用关系，Associated Objects 核心实现在 _object_set_associative_reference 方法里面。

_object_set_associative_reference 函数

void _object_set_associative_reference(id object, void *key, id value, uintptr_t policy) {
    // retain the new value (if any) outside the lock.
    // 创建一个ObjcAssociation对象
    ObjcAssociation old_association(0, nil);
    // 通过policy为value创建对应属性，如果policy不存在，则默认为assign
    id new_value = value ? acquireValue(value, policy) : nil;
    {
        // 创建AssociationsManager对象
        AssociationsManager manager;
        // 在manager取_map成员，其实是一个map类型的映射
        AssociationsHashMap &associations(manager.associations());
        // 创建指针指向即将拥有成员的Class
        // 至此该类已经包含这个关联对象
        disguised_ptr_t disguised_object = DISGUISE(object);
         // 以下是记录强引用类型成员的过程
        if (new_value) {
            // break any existing association.
            // 在即将拥有成员的Class中查找是否已经存在改关联属性
            AssociationsHashMap::iterator i = associations.find(disguised_object);
            if (i != associations.end()) {
                // secondary table exists
                // 当存在时候，访问这个空间的map
                ObjectAssociationMap *refs = i->second;
                // 遍历其成员对应的key
                ObjectAssociationMap::iterator j = refs->find(key);
                if (j != refs->end()) {
                    // 如果存在key，重新更改Key的指向到新关联属性
                    old_association = j->second;
                    j->second = ObjcAssociation(policy, new_value);
                } else {
                    // 否则以新的key创建一个关联
                    (*refs)[key] = ObjcAssociation(policy, new_value);
                }
            } else {
                // create the new association (first time).
                // key不存在的时候，直接创建关联
                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.
            // 这种情况是policy不存在或者为assign的时候
            // 在即将拥有的Class中查找是否已经存在Class
            // 其实这里的意思就是如果之前有这个关联对象，并且是非assign形的，直接erase
            AssociationsHashMap::iterator i = associations.find(disguised_object);
            if (i != associations.end()) {
                // 如果有该类型成员检查是否有key
                ObjectAssociationMap *refs = i->second;
                ObjectAssociationMap::iterator j = refs->find(key);
                if (j != refs->end()) {
                    // 如果有key，记录旧对象，释放
                    old_association = j->second;
                    refs->erase(j);
                }
            }
        }
    }
    // release the old value (outside of the lock).
    // 如果存在旧对象，则将其释放
    if (old_association.hasValue()) ReleaseValue()(old_association);
}

源码中得出结论

Associated Objects 是一个 AssociationsManager 的结构体，维护了一个 spinlock_t 锁和一个 _map 的哈希表。
_map 哈希表中的键为 disguised_ptr_t。

inline disguised_ptr_t DISGUISE(id value) { return ~uintptr_t(value); }
#ifndef _UINTPTR_T
#define _UINTPTR_T
typedef unsigned long       uintptr_t;
#endif /* _UINTPTR_T */

其实 DISGUISE 函数其实仅仅对 object 做了下位运算，得到一个指向 self 地址的指针，通过这个指针，可以找到对应的 value，即一个 AssociationsHashMap 哈希表。

ObjectAssociationMap

#if TARGET_OS_WIN32
    typedef hash_map ObjectAssociationMap;
    typedef hash_map AssociationsHashMap;
#else
    typedef ObjcAllocator > ObjectAssociationMapAllocator;
    class ObjectAssociationMap : public std::map {
    public:
        void *operator new(size_t n) { return ::malloc(n); }
        void operator delete(void *ptr) { ::free(ptr); }
    };
    typedef ObjcAllocator > AssociationsHashMapAllocator;
    class AssociationsHashMap : public unordered_map {
    public:
        void *operator new(size_t n) { return ::malloc(n); }
        void operator delete(void *ptr) { ::free(ptr); }
    };
#endif

在 AssociationsHashMap 中 key 是 disguised_ptr_t，Value 则是ObjectAssociationMap。
在 ObjectAssociationMap 中以 key 是 self 指针，Value 则是 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; }
};

ObjcAssociation 存储着 _policy、_value，而这两个值是调用 objc_setAssociatedObject 函数传入的值。

总结：AssociationsHashMap 以 key-value 的形式保存从对象的 disguised_ptr_t 到 ObjectAssociationMap 的映射，而 ObjectAssociationMap 则保存了从 key 到关联对象 ObjcAssociation 的映射，这个数据结构保存了当前对象对应的所有关联对象，最后的 ObjcAssociation 存储了 policy 以及 value。

new_value

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

根据 acquireValue 函数，把传入的 value 通过对策略的判断返回新的 new_value。

当 new_value != nil 设置/更新关联对象的值

// break any existing association.
// 在即将拥有成员的Class中查找是否已经存在改关联属性
AssociationsHashMap::iterator i = associations.find(disguised_object);
if (i != associations.end()) {
    // secondary table exists
    // 当存在时候，访问这个空间的map
    ObjectAssociationMap *refs = i->second;
    // 遍历其成员对应的key
    ObjectAssociationMap::iterator j = refs->find(key);
    if (j != refs->end()) {
        // 如果存在key，重新更改Key的指向到新关联属性
        old_association = j->second;
        j->second = ObjcAssociation(policy, new_value);
    } else {
        // 否则以新的key创建一个关联
        (*refs)[key] = ObjcAssociation(policy, new_value);
    }
} else {
    // create the new association (first time).
    // key不存在的时候，直接创建关联
    ObjectAssociationMap *refs = new ObjectAssociationMap;
    associations[disguised_object] = refs;
    (*refs)[key] = ObjcAssociation(policy, new_value);
    object->setHasAssociatedObjects();
}

获取唯一的保存关联对象的哈希表 AssociationsHashMap。
使用 DISGUISE(object) 作为 key 寻找对应的 ObjectAssociationMap。
如果没有找到，初始化一个 ObjectAssociationMap，再实例化 ObjcAssociation 对象添加到 Map 中，并调用 setHasAssociatedObjects 方法，表明当前对象已经含有关联对象。
如果找到了对应的 ObjectAssociationMap，遍历其成员对应的 key 是否存在，如果存在 key，重新更改 Key 的指向到新关联属性，否则以新的 key 创建一个关联。

如果 new_value == nil，就要删除对应 key 的关联对象。

// setting the association to nil breaks the association.
// 这种情况是policy不存在或者为assign的时候
// 在即将拥有的Class中查找是否已经存在Class
// 其实这里的意思就是如果之前有这个关联对象，并且是非assign形的，直接erase
AssociationsHashMap::iterator i = associations.find(disguised_object);
if (i != associations.end()) {
    // 如果有该类型成员检查是否有key
    ObjectAssociationMap *refs = i->second;
    ObjectAssociationMap::iterator j = refs->find(key);
    if (j != refs->end()) {
        // 如果有key，记录旧对象，释放
        old_association = j->second;
        refs->erase(j);
    }
}

当 policy 不存在或者为 assign 的时候，

根据 DISGUISE(object) 作为 key 寻找对应的 ObjectAssociationMap。
如果找到了对应的 ObjectAssociationMap，遍历其成员对应的 key 是否存在，如果存在 key，调用 erase 方法，移除关联关系。

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

如果存在旧对象，则将其释放。

借助一张图objc_setAssociatedObject 原理

image

objc_getAssociatedObject

objc_getAssociatedObject 内部调用的是 _object_get_associative_reference

id objc_getAssociatedObject(id object, const void *key) {
    return objc_getAssociatedObject_non_gc(object, key);
}

_object_get_associative_reference

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

获取唯一的保存关联对象的哈希表 AssociationsHashMap。
使用 DISGUISE(object) 作为 key 寻找对应的 ObjectAssociationMap。
如果找到了对应的 ObjectAssociationMap，遍历其成员对应的 key 是否存在，如果存在 key，获取 ObjcAssociation。
返回关联对象 ObjcAssociation 的值。

objc_removeAssociatedObjects

objc_removeAssociatedObjects 用来删除所有的关联对象，objc_removeAssociatedObjects 函数内部调用的是 _object_remove_assocations 函数。

_object_remove_assocations

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

获取唯一的保存关联对象的哈希表 AssociationsHashMap。
如果哈希表 AssociationsHashMap 的 size 为 0，直接 return。
使用 DISGUISE(object) 作为 key 寻找对应的 ObjectAssociationMap。
如果找到了对应的 ObjectAssociationMap，遍历其成员对应的 key 是否存在，如果存在 key，然后将所有的关联结构保存到 vector 中。
删除关联关系，释放关联对象。

参考链接

https://www.jianshu.com/p/79479a09a8c0
http://blog.leichunfeng.com/blog/2015/06/26/objective-c-associated-objects-implementation-principle/

浅谈 Objective-C Associated Objects

简介