objc_setAssociatedObject等关联对象原理探究

本文为学习记录所作,内容来源于雷纯锋的技术博客 Objective-C Associated Objects 的实现原理

我们在使用Category给指定类添加属性时,发现使用关联对象技术只能给原类增加属性,并不能增加实例变量. 即可以通过 class_copyPropertyList(Class _Nullable cls, unsigned int * _Nullable outCount) 来获取到添加的属性, 而通过 class_copyIvarList(Class _Nullable cls, unsigned int * _Nullable outCount) 发现没有同名带下划线的实例变量. 故本文一探究竟.

关联对象的的api就只有三个

// 用于给对象添加关联对象，传入 nil 则可以移除已有的关联对象;
  objc_setAssociatedObject(id _Nonnull object, const void * _Nonnull key,
                         id _Nullable value, objc_AssociationPolicy policy)

// 用于获取关联对象                        
  objc_getAssociatedObject(id _Nonnull object, const void * _Nonnull key)

// 移除所有的关联对象
  objc_removeAssociatedObjects(id _Nonnull object)

注: objc_removeAssociatedObjects 函数我们一般是用不上的, 因为这个函数会移除一个对象的所有关联对象, 将该对象恢复成“原始”状态. 这样做就很有可能把别人添加的关联对象也一并移除, 这并不是我们所希望的. 所以一般的做法是通过给 objc_setAssociatedObject 函数传入 nil 来移除某个已有的关联对象. 不过我猜测对象析构时系统会直接调用这个移除所有关联对象.

object

关联对象主体, 即谁需要绑定这个value. 由于关联对象原理(下文分析), A对象绑定了一个value, 丝毫不会影响同类型的B对象

key

声明 static char kAssociatedObjectKey , 使用 &kAssociatedObjectKey 作为 key 值;
声明 static void *kAssociatedObjectKey = &kAssociatedObjectKey , 使用 kAssociatedObjectKey 作为 key 值;
用 selector, 使用 getter 方法的名称作为 key 值.

selector 本质就是一个字符串, 故使用它即可, 因为它省掉了一个变量名, 非常优雅地解决了计算科学中的两大世界难题之一(命名)

关联策略

在给一个对象添加关联对象时有五种关联策略可供选择:

关联策略	等价属性	说明
OBJC_ASSOCIATION_ASSIGN	@property (assign) or 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)	复制关联对象，且为原子操作

实现原理

接下来，我们就一起看看 runtime 中的源码

objc_setAssociatedObject

我们可以在 objc-references.mm 文件中找到 objc_setAssociatedObject 函数最终调用的函数:(c++写的全靠猜)

void _object_set_associative_reference(id object, void *key, id value, uintptr_t policy) {
    // 申明一个临时变量, 下面会用来暂存一个旧值
    ObjcAssociation old_association(0, nil);
    // 引用一下传进来的value
    id new_value = value ? acquireValue(value, policy) : nil;
    {       
          // 管理者
        AssociationsManager manager;
        // 拿到整个大的AssociationsHashMap(所有对象的大表)
        AssociationsHashMap &associations(manager.associations());
        // 猜测是拿到object的地址
        disguised_ptr_t disguised_object = DISGUISE(object);
        // 如果传进来的value有值
        if (new_value) {
            // 以object的地址为key去找object对应的一个ObjectAssociationMap(当前object对应的小表)
            AssociationsHashMap::iterator i = associations.find(disguised_object);
            // 如果有这个小表
            if (i != associations.end()) {
                // 拿到这个小表
                ObjectAssociationMap *refs = i->second;
                // 以传进来的key在小表中找对应的ObjcAssociation
                ObjectAssociationMap::iterator j = refs->find(key);
                // 找到
                if (j != refs->end()) {
                        // 用上面的临时变量暂存一下旧值
                    old_association = j->second;
                    // 用新的value和策略生成一个新的ObjcAssociation并存进这个小表中(不清楚为啥不直接修改原  
                    来的值)
                    j->second = ObjcAssociation(policy, new_value);
                
                } else {  // 没有找则到用新的value和策略生成一个新的ObjcAssociation并存进这个小表中
                    (*refs)[key] = ObjcAssociation(policy, new_value);
                }
            } else { // 如果没有这个小表
                // 则首次创建一个当前对象对应的小表,并用新的value和策略生成一个新的ObjcAssociation.  
                小表以object地址为key存进整个大表中,新的ObjcAssociation以传进来的key为key存进小表中
                ObjectAssociationMap *refs = new ObjectAssociationMap;
                associations[disguised_object] = refs;
                (*refs)[key] = ObjcAssociation(policy, new_value);
                object->setHasAssociatedObjects();
            }
        } else { 
            // 如果传进来的value为空, 则是为了清空一个关联对象. 那么如果这个小表存在则去找小表中以传进来的key             
            对应的ObjectAssociation.如果存在这个ObjectAssociation则将旧值暂存一下,用新的value和策略生成一  
            个新的ObjcAssociation并存进小表中(同样不清楚为啥不直接修改原来的值,难道ObjcAssociation这个对象  
            不可变?)
            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);
}

AssociationsManager 是顶级管理者,维护了一个从 spinlock_t 锁到 AssociationsHashMap 哈希表的单例键值对映射;
AssociationsHashMap 是一个无序的哈希表, 维护了从对象地址到 ObjectAssociationMap 的映射; ObjectAssociationMap 是一个 C++ 中的 map ，维护了从 key 到 ObjcAssociation 的映射，即关联记录;
ObjcAssociation 是一个 C++ 的类,表示一个具体的关联结构, 主要包括两个实例变量, _policy 表示关联策略, _value表示关联对象.
每一个对象地址对应一个 ObjecAssociationMap 对象，而一个 ObjectAssociationMap 对象保存着这个对象的若干个关联记录ObjectAssociation, 每个 ObjectAssociation 则保存了被关联的对象和关联策略.

我们来看下面的流程图，一图胜千言:

setAssocition.png

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());
        // 取到object的地址
        disguised_ptr_t disguised_object = DISGUISE(object);
        // 以这个地址为key去大表中找ObjectAssociationMap类型的小表
        AssociationsHashMap::iterator i = associations.find(disguised_object);
        if (i != associations.end()) {
              // 拿到这个小表 
            ObjectAssociationMap *refs = i->second;
            // 以传进来的key在这个小表中找对应的ObjcAssociation
            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;
        // 取object地址
        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());
}

这个函数负责移除一个对象的所有关联对象, 具体实现也是先根据对象的地址获取其对应的 ObjectAssociationMap 对象，然后将所有的关联结构保存到一个 vector 中, 最终释放 vector 中保存的所有关联对象.

给类对象添加关联对象

看完源代码后,我们知道对象地址与 AssociationsHashMap 哈希表是一一对应的. 那么我们可能就会思考这样一个问题, 是否可以给类对象添加关联对象呢? 答案是肯定的. 我们完全可以用同样的方式给类对象添加关联对象. 只不过我们一般情况下不会这样做, 因为更多时候我们可以通过 static 变量来实现类级别的变量.

总结

关联对象与被关联对象本身的存储并没有直接的关系，它是存储在单独的哈希表中的;
关联对象的五种关联策略与属性的限定符非常类似，在绝大多数情况下，我们都会使用OBJC_ASSOCIATION_RETAIN_NONATOMIC 的关联策略,这可以保证我们持有关联对象;
关联对象的释放时机与移除时机并不总是一致, 移除只是解除掉当前对象和被引用对象的引用关系.