（五）RunTime中weak的实现原理

苹果提供的开源代码 objc

一、weak简单概述及使用场景

• 简单概述：weak弱引用，被修饰的对象在被引用时，计数不会+1，并且在引用对象被释放后，指向对象的指针会被自动置nil。
• 使用场景：我们一般在修饰delegate或者防止block的循环引用时会用到。

二、weak的底层实现

• 1.首先 生成一个弱引用对象

• 2.通过汇编查看底层调用原理

可以发现weak的底层调用的objc_initWeak。 我们去下载苹果为我们提供的底层开源代码objc。

• 3.在源码中搜索objc_initWeak

id
objc_initWeak(id *location, id newObj)
{
    if (!newObj) {
        *location = nil;
        return nil;
    }
    //false，true，true
    return storeWeak<DontHaveOld, DoHaveNew, DoCrashIfDeallocating>
        (location, (objc_object*)newObj);
}

- 参数1：id *location：指针的地址 即：&objc2
- 参数2：id newObj：引用的对象 即：objc1

1）判断条件是查看对象实例是否有效,无效对象直接释放指针。

2）有效就会调用objc_storeWeak()这个函数。

• 4.查看objc_storeWeak()参数为弱引用对象的指针和被引用对象

这个函数的内容比较多，一部分，一部分来

storeWeak(id *location, objc_object *newObj)
{
    assert(haveOld  ||  haveNew);
    if (!haveNew) assert(newObj == nil);

    Class previouslyInitializedClass = nil;
    id oldObj;
    SideTable *oldTable;
    SideTable *newTable; 
    ......
}

声明新旧两个SideTable,SideTable是一个结构体，里面包含自旋锁，引用计数，弱引用表等。

struct SideTable {
    spinlock_t slock;//自旋锁
    RefcountMap refcnts;//引用计数Map
    weak_table_t weak_table;//弱引用表
};

在往下看

    if (haveOld) {
        oldObj = *location;
        oldTable = &SideTables()[oldObj];
    } else {
        oldTable = nil;
    }
    //如果这个弱引用对象objc2之前弱引用过其他对象，则将之前对象对应的SideTable取出，赋值给oldTable
    if (haveNew) {
        newTable = &SideTables()[newObj];
    } else {
        newTable = nil;
    }
    // 如果这个弱引用对象objc2要弱引新的对象，则将新对象对应的SideTable取出，赋值给newTable
    
    SideTable::lockTwo<haveOld, haveNew>(oldTable, newTable);
    //将这两个SideTable锁上

1）oldTable：objc2对象之前引用对象对应的SideTable 2）newTable：objc2对象要引用新的对象对应的SideTable

if (haveOld  &&  *location != oldObj) {
    SideTable::unlockTwo<haveOld, haveNew>(oldTable, newTable);
    goto retry;
}
//location 应该与 oldObj 保持一致，如果不同，说明当前的 location 已经处理过 oldObj 可是又被其他线程所修改

// Prevent a deadlock between the weak reference machinery
// and the +initialize machinery by ensuring that no 
// weakly-referenced object has an un-+initialized isa.
if (haveNew  &&  newObj) {
    Class cls = newObj->getIsa();
    //如果cls还没有初始化，先初始化，再尝试设置weak
    if (cls != previouslyInitializedClass  &&  
        !((objc_class *)cls)->isInitialized()) 
    {
        SideTable::unlockTwo<haveOld, haveNew>(oldTable, newTable);
        _class_initialize(_class_getNonMetaClass(cls, (id)newObj));

        // If this class is finished with +initialize then we're good.
        // If this class is still running +initialize on this thread 
        // (i.e. +initialize called storeWeak on an instance of itself)
        // then we may proceed but it will appear initializing and 
        // not yet initialized to the check above.
        // Instead set previouslyInitializedClass to recognize it on retry.
        previouslyInitializedClass = cls;

        goto retry;// 重新获取一遍newObj，这时的newObj应该已经初始化过了
    }
}

防止弱引用机制和初始化出现死锁，在弱引用之前，要确保对象已经成功初始化。

// Clean up old value, if any.
if (haveOld) {
    weak_unregister_no_lock(&oldTable->weak_table, oldObj, location);
}

如果weak之前引用过其他对象，则调用weak_unregister_no_lock在旧的对象中weak_entry_t中移除弱引用objc2的地址。

void
参数1：weak_table：oldTable中的弱引用表
参数2：referent_id：oldObj：之前弱引用的对象oldObj
参数3：referrer_id：弱引用对象的地址值
weak_unregister_no_lock(weak_table_t *weak_table, id referent_id, 
                        id *referrer_id)
{
    objc_object *referent = (objc_object *)referent_id;//oldObjc的地址
    objc_object **referrer = (objc_object **)referrer_id;//objc2地址的指针

    weak_entry_t *entry;

    if (!referent) return;
    //根据oldObjc的地址 在 weak_table散列表中拿到weak_entry_t
    if ((entry = weak_entry_for_referent(weak_table, referent))) {
        //然后把objc2地址的指针从weak_entry_t中删除
        remove_referrer(entry, referrer);
        //empty标记为true
        bool empty = true;
        if (entry->out_of_line()  &&  entry->num_refs != 0) {
            empty = false;
        }
        else {
            for (size_t i = 0; i < WEAK_INLINE_COUNT; i++) {
                if (entry->inline_referrers[i]) {
                    empty = false; 
                    break;
                }
            }
        }
        //最后把weak_entry_t 从weak_table中删除
        if (empty) {
            weak_entry_remove(weak_table, entry);
        }
    }

    // Do not set *referrer = nil. objc_storeWeak() requires that the 
    // value not change.
}

上面这段代码讲的是如何将弱引用指针从oldObjc对应的散列表中移除：&oldObjc -> oldTable -> weak_table -> weak_entry_t 将弱引用的指针从weak_entry_t移除，然后删除weak_entry_t

static weak_entry_t *
//weak_table_t *weak_table 
weak_entry_for_referent(weak_table_t *weak_table, objc_object *referent)
{
    assert(referent);

    weak_entry_t *weak_entries = weak_table->weak_entries;

    if (!weak_entries) return nil;

    size_t begin = hash_pointer(referent) & weak_table->mask;
    size_t index = begin;
    size_t hash_displacement = 0;
    while (weak_table->weak_entries[index].referent != referent) {
        index = (index+1) & weak_table->mask;
        if (index == begin) bad_weak_table(weak_table->weak_entries);
        hash_displacement++;
        if (hash_displacement > weak_table->max_hash_displacement) {
            return nil;
        }
    }
    
    return &weak_table->weak_entries[index];
}

通过hash算法从找到索引index 根据oldObjc的地址从weak_table中找到对应的weak_entry_t

以上就是如何把objc2对象的地址指针从oldObjc的散列表中清除的 接下来 我们来看是如何存储新值的

// Assign new value, if any.
//有新值存储
if (haveNew) {
    newObj = (objc_object *)
    //新的weak_table
    //(id)newObj：新的对象objc对象
    //location：&objc2
        weak_register_no_lock(&newTable->weak_table, (id)newObj, location, 
                              crashIfDeallocating);
    // weak_register_no_lock returns nil if weak store should be rejected

    // Set is-weakly-referenced bit in refcount table.
    if (newObj  &&  !newObj->isTaggedPointer()) {
        newObj->setWeaklyReferenced_nolock();
    }

    // Do not set *location anywhere else. That would introduce a race.
    *location = (id)newObj;//弱应用对象objc2的地址指针指向新的对象
}
else {
    // No new value. The storage is not changed.
}

SideTable::unlockTwo<haveOld, haveNew>(oldTable, newTable);

return (id)newObj;

存储新值主要看weak_register_no_lock这个函数实现

id
//新的newTable-> weak_table
//(id)newObj：新的对象objc对象
//location：&objc2
weak_register_no_lock(weak_table_t *weak_table, id referent_id, 
                      id *referrer_id, bool crashIfDeallocating)
{
    objc_object *referent = (objc_object *)referent_id;//objc内存地址
    objc_object **referrer = (objc_object **)referrer_id;//objc2地址的指针

    if (!referent  ||  referent->isTaggedPointer()) return referent_id;

    // ensure that the referenced object is viable
    //判断是否析构函数 是就不需要存了
    bool deallocating;
    ......
    //此处省略内容
    //如果对象被析构了，就不需要存储了
    // now remember it and where it is being stored
    weak_entry_t *entry;
    //根据弱引用表获取实体
    if ((entry = weak_entry_for_referent(weak_table, referent))) {
        append_referrer(entry, referrer);//把objc2的地址指针加入weak_entry_t中
    } 
    else {//没有就会创建新的
        weak_entry_t new_entry(referent, referrer);
        weak_grow_maybe(weak_table);
        weak_entry_insert(weak_table, &new_entry);
    }

    // Do not set *referrer. objc_storeWeak() requires that the 
    // value not change.

    return referent_id;//将新objc内存地址返回
}

通过objc1的内存地址找到newTable -> weak_table_t -> weak_entry_t -> append_referrer .上面就是我们如何将弱引用对象objc2的地址指针存到新的被引用对象objc1的散列表中的。

三、当weak对象释放时，weak值针nil

当对象释放时会走析构函数dealloc -> _objc_rootDealloc(self)-> obj->rootDealloc() -> 如果对象不可以被快速释放 -> object_dispose((id)this)

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

    objc_destructInstance(obj);    
    free(obj);

    return nil;
}

在对像释放之前会调用objc_destructInstance(obj)函数

void *objc_destructInstance(id obj) 
{
    if (obj) {
        ......
        obj->clearDeallocating();
    }
    return obj;
}

使用了sideTable的辅助引用计数（isa.has_sidetable_rc），进入慢析构路径
clearDeallocating_slow();

objc_object::clearDeallocating_slow()
{
    assert(isa.nonpointer  &&  (isa.weakly_referenced || isa.has_sidetable_rc));

    //在全局的SideTables中，以this指针为key，找到对应的SideTable
    SideTable& table = SideTables()[this];
    table.lock();
    if (isa.weakly_referenced) {如果obj1被弱引用
        weak_clear_no_lock(&table.weak_table, (id)this);
    }
    if (isa.has_sidetable_rc) {// 如果采用了SideTable做引用计数
        table.refcnts.erase(this);// 在SideTable的引用计数中移除this
    }
    table.unlock();
}

重点来了，让我们看来看weak_clear_no_lock函数是如何将弱引用的指针置nil。

void 
参数一weak_table：找到当前对象objc1对应的weak_table
参数二referent_id：被弱引用的对象objc1
weak_clear_no_lock(weak_table_t *weak_table, id referent_id) 
{
    objc_object *referent = (objc_object *)referent_id;
    //根据objc1的内存地址在weak_table中找到weak_entry_t
    weak_entry_t *entry = weak_entry_for_referent(weak_table, referent);
    if (entry == nil) {
        /// XXX shouldn't happen, but does with mismatched CF/objc
        //printf("XXX no entry for clear deallocating %p\n", referent);
        return;
    }

    // zero out references
    weak_referrer_t *referrers;
    size_t count;
    // 找出entry中weak指针地址数组(referrers)以及数组长度(count)
    if (entry->out_of_line()) {
        referrers = entry->referrers;
        count = TABLE_SIZE(entry);
    } 
    else {
        referrers = entry->inline_referrers;
        count = WEAK_INLINE_COUNT;
    }
    
    for (size_t i = 0; i < count; ++i) {
        //取出每个弱引用对象的的地址指针
        objc_object **referrer = referrers[i];
        if (referrer) {
            if (*referrer == referent) {//确定引用了，就将其置nil
                *referrer = nil;
            }
            else if (*referrer) {
                _objc_inform("__weak variable at %p holds %p instead of %p. "
                             "This is probably incorrect use of "
                             "objc_storeWeak() and objc_loadWeak(). "
                             "Break on objc_weak_error to debug.\n", 
                             referrer, (void*)*referrer, (void*)referent);
                objc_weak_error();
            }
        }
    }
    
    weak_entry_remove(weak_table, entry);//将entry移除weakTable
}

当引用计数为0的时候，当前对像会被释放，会调用dealloc析构函数,对象被弱引用的话，在释放前就会进行一些处理主要调用weak_clear_no_lock这个函数，根据当前对象的地址会拿到SideTable—>weak_table_t,再通过地址的指针拿到weak_entry_t这个结构体，遍历存放弱引用对象的指针weak_referrer_t，如果这个对象确实引用了该对象，就将这个对象的指针置nil，然后将整个weak_entry_t移除。这就是为什么该对象释放了，弱引用该对象的指针会被置nil了。

我画了个图用来总结上面的流程

还有一张数据的关系图

总结

1.当一个对象objc1被objc2弱引用了
2.首先查找objc2之前是否引用过其他的对象oldObjc，如果引用过，就将objc2的地址指针从oldObjc的散列表中删除，没引用就跳过。
3.objc2将要引用objc1，所以将objc2的地址指针存在objc1响应的散列表中。
4.当objc1要释放时，会根据objc的内存地址找到对应的sideTable -> weak_table -> referrers,遍历存放引用过objc1的对象地址指针referrers，置nil。