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;
}
至此，关联的内部实现逻辑，基本上就看完了。
总结
- 存储关联对象的是一个全局的hash表，通过将object
DISGUISE转化作为key来索引object的关联关系hash表 - 对象的关联关系hash表，是通过我们传入的key来索引关联对象的
- 初步认识了类的isa，优化后的isa指针有一些位是标记位，存储了类的一些信息，节省了空间也提高了效率
