objective-c中关联引用的底层实现
我们知道关联引用(associative references)可以为已存在的实例对象增加实例变量。该技术主要由以下三个函数实现相应的功能：
1. void objc_setAssociatedObject(id object, void *key, id value,objc_AssociationPolicy policy)
这个方法用于为对象object添加以key指定的地址作为关键字，以value为值的关联引用，第四个参数policy指定关联引用的存储策略。
通过将value置为nil就可以删除对应key的关联。
2. id objc_getAssociatedObject(id object, void *key)
返回对象object以key为关键字的关联对象。如果没有关联对象则返回nil。
3. void objc_removeAssociatedObjects(id object)
断开object的所有关联。
至于以上函数的具体用法就不多说了，相信来看原理的客官们已经都会了( ^_^ )
下面是一些源码中会用到的结构体和函数定义，不想太在意细节的可以直接略过，也可以在后面遇到的时候回过头来看：
enum {
OBJC_ASSOCIATION_SETTER_ASSIGN = 0,
OBJC_ASSOCIATION_SETTER_RETAIN = 1,
OBJC_ASSOCIATION_SETTER_COPY = 3, // NOTE: both bits are set, so we can simply test 1 bit in releaseValue below.
OBJC_ASSOCIATION_GETTER_READ = (0 << 8),
OBJC_ASSOCIATION_GETTER_RETAIN = (1 << 8),
OBJC_ASSOCIATION_GETTER_AUTORELEASE = (2 << 8)
};
enum {
OBJC_ASSOCIATION_ASSIGN = 0, /**< Specifies a weak reference to the associated object. */
OBJC_ASSOCIATION_RETAIN_NONATOMIC = 1, /**< Specifies a strong reference to the associated object.
* The association is not made atomically. */
OBJC_ASSOCIATION_COPY_NONATOMIC = 3, /**< Specifies that the associated object is copied.
* The association is not made atomically. */
OBJC_ASSOCIATION_RETAIN = 01401, /**< Specifies a strong reference to the associated object.
* The association is made atomically. */
OBJC_ASSOCIATION_COPY = 01403 /**< Specifies that the associated object is copied.
* The association is made atomically. */
};
inline disguised_ptr_t DISGUISE(id value) { return ~uintptr_t(value); }
inline id UNDISGUISE(disguised_ptr_t dptr) { return id(~dptr); }
class AssociationsManager {
static spinlock_t _lock;
static AssociationsHashMap *_map; // associative references: object pointer -> PtrPtrHashMap.
public:
AssociationsManager() { spinlock_lock(&_lock); }
~AssociationsManager() { spinlock_unlock(&_lock); }
AssociationsHashMap &associations() {
if (_map == NULL)
_map = new AssociationsHashMap();
return *_map;
}
};
spinlock_t AssociationsManager::_lock = SPINLOCK_INITIALIZER;
AssociationsHashMap *AssociationsManager::_map = NULL;
class ObjectAssociationMap : public std::map<void *, ObjcAssociation, ObjectPointerLess, ObjectAssociationMapAllocator>
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; }
};
if (value && (policy & OBJC_ASSOCIATION_GETTER_AUTORELEASE)) {
((id(*)(id, SEL))objc_msgSend)(value, SEL_autorelease);
}
return 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;
}
static void releaseValue(id value, uintptr_t policy) {
if (policy & OBJC_ASSOCIATION_SETTER_RETAIN) {
((id(*)(id, SEL))objc_msgSend)(value, SEL_release);
}
}
struct ReleaseValue {
void operator() (ObjcAssociation &association) {
releaseValue(association.value(), association.policy());
}
};
进入第一个函数（setAssociatedObject）的最终实现：（因为保存为代码的时候总是有莫名的字符添加上去，所以就直接贴出来了）
void_object_set_associative_reference(id object, void *key, id value, uintptr_tpolicy) {
// retain the new value (if any) outside the lock.
ObjcAssociation old_association(0, nil); //构造了一个表示旧值的对象
//根据相应的策略做retain或copy操作，见acquireValue函数
id new_value = value ? acquireValue(value,policy) : nil;
{
AssociationsManager manager;
//获得全局map对象的引用
AssociationsHashMap&associations(manager.associations());
disguised_ptr_t disguised_object =DISGUISE(object);
//如果新值不为空
if (new_value) {
// break any existing association.
//找到对应object的关联map容器
AssociationsHashMap::iterator i =associations.find(disguised_object);
if (i != associations.end()) {
// secondary table exists
//取得关联的map
ObjectAssociationMap *refs =i->second;
//取得关联的具体值
ObjectAssociationMap::iteratorj = 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 {//该object是第一次关联对象，新建一个map容器用于保存它的关联map
// create the new association (first time).
ObjectAssociationMap *refs =new ObjectAssociationMap;
//将该值设置在全局map中
associations[disguised_object]= refs;
//为具体的key赋值
(*refs)[key] =ObjcAssociation(policy, new_value);
//设置类中的标志
Class cls =object->getIsa();
cls->setInstancesHaveAssociatedObjects();
}
} else {//新值为空,可用于删除某个关联对象
// setting the association to nil breaks the association.
AssociationsHashMap::iterator i =associations.find(disguised_object);
//如果有绑定到该对象的关联引用
if (i != associations.end()) {
//取得绑定的关联对象引用表
ObjectAssociationMap *refs =i->second;
//查找key对应的关联对象
ObjectAssociationMap::iteratorj = refs->find(key);
if (j != refs->end()) {//如果已经绑定了关联引用
//保存旧值，后面还要进一步处理
old_association =j->second;
//从map中删掉该项
refs->erase(j);
}
}
}
}
// release the old value (outside of the lock).
//根据其原本绑定的策略，对删掉的值做一些善后处理
if (old_association.hasValue())ReleaseValue()(old_association);
}
第二个（objc_getAssociatedObject）实现：
id_object_get_associative_reference(id object, void *key) {
id value = nil;
//将policy的初值赋为0
uintptr_t policy = OBJC_ASSOCIATION_ASSIGN;
{
AssociationsManager manager;
//获得全局map对象的引用
AssociationsHashMap&associations(manager.associations());
//对object做DISGUISE操作
disguised_ptr_t disguised_object =DISGUISE(object);
//以object的DISGUISE操作结果作为key在HashMap中查找相应的值
AssociationsHashMap::iterator i =associations.find(disguised_object);
//有对应的结果执行下列语句；没有则返回nil；
if (i != associations.end()) {
//取得上次查找结果的second部分（该部分还是一个map）
ObjectAssociationMap *refs =i->second;
//根据传入的key进一步在上次的结果集中查找
ObjectAssociationMap::iterator j =refs->find(key);
//如果有对应的值，进行下一步；否则返回nil；
if (j != refs->end()) {
//取出关联对象的模型实体（包括了关联的策略和关联的具体对象）
ObjcAssociation &entry =j->second;
//取得关联的对象
value = entry.value();
//取得关联的策略
policy = entry.policy();
//根据相应的policy做一些后续操作
if (policy & OBJC_ASSOCIATION_GETTER_RETAIN)((id(*)(id, SEL))objc_msgSend)(value, SEL_retain);
}
}
}
//有值的时候进行policy的检测和处理
if (value && (policy &OBJC_ASSOCIATION_GETTER_AUTORELEASE)) {
((id(*)(id, SEL))objc_msgSend)(value,SEL_autorelease);
}
return value;
}
第三个（objc_removeAssociatedObjects）如下：
//清除所有关联的对象
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.
//找到它所关联的所有对象（一个map）
ObjectAssociationMap *refs =i->second;
//将所有要删除的对象保存起来
for (ObjectAssociationMap::iteratorj = refs->begin(), end = refs->end(); j != end; ++j) {
elements.push_back(j->second);
}
// remove the secondary table.
delete refs;
//在全局关联引用map中，删除该对象对应的表
associations.erase(i);
}
}
// the calls toreleaseValue() happen outside of the lock.
//删除指定对象所有的关联值，会根据设置的policy做一些后续的操作，详情见上面介绍的函数。
for_each(elements.begin(), elements.end(),ReleaseValue());
}
通过上面的分析我们也可以知道，其实关联引用就是一个二级map的建立、查找、删除的操作。假设已建好了所有需要的表结构，其搜索过程如下图所示：
综上所述我们可以得出如下结论：关联引用的关联是以实例对象为基本单位进行的，即使是同一个类的实例对象，它们所关联的对象个数和值都可以不同；已关联的对象可以选择性删除或全部删除；关联的对象只要设置合适的策略就可以在撤销关联时不用手动置为nil，相关函数会帮我们完成这项操作(*＾-＾*)