探索AssociatedObject关联对象的内部实现

AssociatedObject关联对象

为什么要引入关联对象？

• 一般我们需要对现有的类做扩展，可以通过继承、类别等方式去实现；当我们使用类别的方式扩展，如果对现有的类增加属性的话，编译器是不会生成实例变量；类别的结构体中没有ivar的结构体，同时类的ivar设计的是一个const
• 类别是运行时装载到类中的，当类realizeClass之后它的instanceSize就已经确定无法修改了，这些操作都是在load之前，main函数之前
• 如果想通过runtime的方法class_addIvar它只适用于新建一个类的时候增加，对于类别中增加实例就不适用
• 关联对象就是在不改变类的结构的情况下，将类需要关联的对象存储在关联表中，那么类别中添加的属性的值的存取就可以通过关联来解决

关联的介绍

1. 主要函数

// 设置关联对象函数
OBJC_EXPORT void
objc_setAssociatedObject(id _Nonnull object, const void * _Nonnull key,
                         id _Nullable value, objc_AssociationPolicy policy)
    OBJC_AVAILABLE(10.6, 3.1, 9.0, 1.0, 2.0);
// 获取关联的对象函数
OBJC_EXPORT id _Nullable
objc_getAssociatedObject(id _Nonnull object, const void * _Nonnull key)
    OBJC_AVAILABLE(10.6, 3.1, 9.0, 1.0, 2.0);
// 删除对象的关联对象函数
OBJC_EXPORT void
objc_removeAssociatedObjects(id _Nonnull object)
    OBJC_AVAILABLE(10.6, 3.1, 9.0, 1.0, 2.0);

• objc_setAssociatedObject -- 关联对象value到object
  object：宿主对象
  key：关联对象的key，一般传入一个常量的地址作为唯一标识
  value：被关联的对象
  policy：关联的规则，主要是内存管理的规则
• objc_getAssociatedObject -- 从object中根据key获取关联的对象的value
  object：宿主对象
  key：关联对象的key，传入设置时候传入的key
• objc_removeAssociatedObjects -- 删除object的所有的关联的对象
  object：宿主对象

2. 原理介绍

通过开源的objc源码查看内部实现逻辑

2.1 objc_setAssociatedObject
内部调用了_object_set_associative_reference

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);
    // 根据入参policy对value进行内存管理返回value
    id new_value = value ? acquireValue(value, policy) : nil;
    {
        AssociationsManager manager;
        // 获取存储关联信息的哈希表
        AssociationsHashMap &associations(manager.associations());
        // 将object转化为disguised_ptr_t类型，每个对象转化之后的值都是不一样的，达到一个唯一性的效果
        disguised_ptr_t disguised_object = DISGUISE(object);
        if (new_value) { // 如果关联的对象非空
            // break any existing association.
            // 根据object转化之后的值disguised_object去hash表中查找存储这个对象的关联对象的hash表
            AssociationsHashMap::iterator i = associations.find(disguised_object);
            if (i != associations.end()) { // object的关联对象的hash表存在
                // secondary table exists
                ObjectAssociationMap *refs = i->second;
                //根据传入的key去hash表中查找是否已经存在key对应的关联对象
                ObjectAssociationMap::iterator j = refs->find(key);
                if (j != refs->end()) { // 已经存在
                    old_association = j->second; // 将旧值保存起来
                    j->second = ObjcAssociation(policy, new_value); // 设置新值
                } else { // hash表中没有key对应的对象
                    (*refs)[key] = ObjcAssociation(policy, new_value); // 
                }
            } else { // object的关联对象的hash表不存在
                // create the new association (first time).
                // 创建一个hash表，以disguised_object为key存储起来，并将关联对象存在hash表中
                ObjectAssociationMap *refs = new ObjectAssociationMap;
                associations[disguised_object] = refs;
                (*refs)[key] = ObjcAssociation(policy, new_value);
                // 设置对象的isa标记位，有关联对象，主要是在对象释放的时候，有关联对象释放的时候回去清除关联表
                object->setHasAssociatedObjects();
            }
        } else {
            // setting the association to nil breaks the association.
            // value为nil则进行删除操作，删除hash表中key对应的对象
            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);
}

• acquireValue -- 对传入的对象根据内存管理策略做内存管理

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

• setHasAssociatedObjects -- 更新isa的has_assoc标记位

inline void
objc_object::setHasAssociatedObjects()
{
    if (isTaggedPointer()) return;

 retry:
    isa_t oldisa = LoadExclusive(&isa.bits);
    isa_t newisa = oldisa;
    if (!newisa.nonpointer  ||  newisa.has_assoc) {
        ClearExclusive(&isa.bits);
        return;
    }
    newisa.has_assoc = true;
    if (!StoreExclusive(&isa.bits, oldisa.bits, newisa.bits)) goto retry;
}

• has_assoc的作用 -- 通过设置isa的标记位的值，在对象释放的时候对应做释放处理
  isa的标记位如下所示

uintptr_t nonpointer : 1; // 0 表示普通的 isa 指针，1 表示使用优化，存储引用计数
uintptr_t has_assoc : 1; // 标记是否有关联对象
uintptr_t has_cxx_dtor : 1; // 标记是否有c++的稀构函数
uintptr_t shiftcls : 44; /MACH_VM_MAX_ADDRESS 0x7fffffe00000/ 类的指针
uintptr_t magic : 6; // 固定值为 0xd2，用于在调试时分辨对象是否未完成初始化。
uintptr_t weakly_referenced : 1; // 标记是否有弱引用
uintptr_t deallocating : 1; // 标记对象是否正在释放
uintptr_t has_sidetable_rc : 1; // 标记对象的引用计数是否是存储在引用计数表(引用计数值是否过大无法存储在 isa 指针就会存储到引用计数表中)
uintptr_t extra_rc : 8 // 存储引用计数值减一后的结果

看下面的源码发现if (assoc) _object_remove_assocations(obj)，在释放的时候，根据标记位来判断是否需要删除对象的关联对象hash表

inline void
objc_object::rootDealloc()
{
    if (isTaggedPointer()) return;  // fixme necessary?
    // 对象释放的时候会判断对象是否有weak引用、关联对象、c++稀构函数、引用计数的存放方式是否是在引用计数表中存放，都没有就直接free否则会走dispose方法
    if (fastpath(isa.nonpointer  &&  
                 !isa.weakly_referenced  &&  
                 !isa.has_assoc  &&  
                 !isa.has_cxx_dtor  &&  
                 !isa.has_sidetable_rc))
    {
        assert(!sidetable_present());
        free(this);
    } 
    else {
        object_dispose((id)this);
    }
}

id 
object_dispose(id obj)
{
    if (!obj) return nil;

    objc_destructInstance(obj);    
    free(obj);

    return nil;
}

void *objc_destructInstance(id obj) 
{
    if (obj) {
        // Read all of the flags at once for performance.
        bool cxx = obj->hasCxxDtor();
        bool assoc = obj->hasAssociatedObjects();

        // This order is important.
        if (cxx) object_cxxDestruct(obj);
        if (assoc) _object_remove_assocations(obj);
        obj->clearDeallocating();
    }

    return obj;
}

ReleaseValue() -- 内部调用objc_release释放关联对象

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) {
        return objc_release(value);
    }
}

2.2 objc_getAssociatedObject
内部调用了objc_getAssociatedObject

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

可以看到内部就是根据disguised_object找到存储object的关联对象的hash表，然后从hash表中根据key找到对应的关联对象的值，再根据内存策略如果需要会相应的retain autorelease

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

2.3 objc_removeAssociatedObjects -- 删除object的所有的关联对象

如果要删除object的某个key对应的关联对象则调用objc_setAssociatedObject传value为nil

函数内部实现：
判断是否已经关联了对象，有则删除

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

同样的根据disguised_object找到存储object的关联对象的hash表，将hash表中的元素存储到elements中，然后删除hash表，最后遍历删除elements中的元素

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

for_each(elements.begin(), elements.end(), ReleaseValue())遍历elements调用ReleaseValue释放elements的元素

inline _LIBCPP_INLINE_VISIBILITY
_Function
for_each(_InputIterator __first, _InputIterator __last, _Function __f)
{
    for (; __first != __last; ++__first)
        __f(*__first);
    return __f;
}

至此，关联的内部实现逻辑，基本上就看完了。

总结

1. 存储关联对象的是一个全局的hash表，通过将objectDISGUISE转化作为key来索引object的关联关系hash表
2. 对象的关联关系hash表，是通过我们传入的key来索引关联对象的
3. 初步认识了类的isa，优化后的isa指针有一些位是标记位，存储了类的一些信息，节省了空间也提高了效率