问题:为何weak修饰的变量可以打破循环引用?
因为weak修饰的变量存储在散列表中的弱引用表里,不参与引用计数器的使用,也就是说,在进行释放额时候,不管你怎么引用,直接就把你置空了。
基本概念
- SideTable :散列表:系统自动维护,用于存储/管理一些信息
SideTable的结构中能看到 其管理三种表:
spinlock_t slock
自旋锁表;
RefcountMap refcnts
引用计数表;
weak_table_t weak_table
弱引用表; - weak_table:弱引用对象存储的表,是SideTable中的一张表
- weak_entry_t:weak_table里面的一个单元,用于管理当前类的弱引用对象,可以理解为一个数组,查看weak_entry_t的结构,有助于更好的理解里面的存储结构,里面包含一个weak_referrer_t,相当于一个数组,这里面的就是存储的弱引用对象,还有其他的一些信息,比如mask(蒙版,容量-1)、num_refs (当前存储的数量)等
- weak_referrer_t :weak_entry_t 中的弱引用对象,相当于是 数组中的一个元素
存储原理
1、源码探索入口
写上这样的代码,打上断点,并打开汇编模式:debug->debug workflow -> alway show disassembly
- (instancetype)init
{
if (self = [super init]) {
️ id __weak weakSelf = self; //断点在这
}
return self;
}
运行后会进入断点,出现这样的一些信息
找到callq方法:objc_initWeak
,拿到这个方法就可以进入源码去调试了
源码探索
id objc_initWeak(id *location, id newObj)
{
.....
return storeWeak<DontHaveOld, DoHaveNew, DoCrashIfDeallocating> (location, (objc_object*)newObj);
}
1.1、内部做的操作是 存储weak—storeWeak
static id
storeWeak(id *location, objc_object *newObj)
{
......
SideTable::lockTwo<haveOld, haveNew>(oldTable, newTable);
if (haveOld && *location != oldObj) {
SideTable::unlockTwo<haveOld, haveNew>(oldTable, newTable);
goto retry;
}
//有新值,判断类有没有初始化,如果没有初始化,就进行初始化
if (haveNew && newObj) {
Class cls = newObj->getIsa();
if (cls != previouslyInitializedClass &&
!((objc_class *)cls)->isInitialized())
{
SideTable::unlockTwo<haveOld, haveNew>(oldTable, newTable);
class_initialize(cls, (id)newObj);
goto retry;
}
}
// 有旧值,进行 weak_unregister_no_lock操作
if (haveOld) {
weak_unregister_no_lock(&oldTable->weak_table, oldObj, location);
}
// 有新值 进行weak_register_no_lock 操作
if (haveNew) {
newObj = (objc_object *)
weak_register_no_lock(&newTable->weak_table, (id)newObj, location,
crashIfDeallocating);
if (newObj && !newObj->isTaggedPointer()) {
newObj->setWeaklyReferenced_nolock();
}
*location = (id)newObj;
}
else {
}
SideTable::unlockTwo<haveOld, haveNew>(oldTable, newTable);
return (id)newObj;
}
关键步骤:
1、如果cls还没有 初始化,先初始化这个类
2、如果weak对象有旧值,先对旧值 进行 weak_unregister_no_lock
,删除旧值
3、如果weak对象有新值 就对新值进行weak_register_no_lock
,新增新值
1.2、再来看weak_unregister_no_lock
,删除旧值
void weak_unregister_no_lock(weak_table_t *weak_table, id referent_id,
id *referrer_id)
{
objc_object *referent = (objc_object *)referent_id;
objc_object **referrer = (objc_object **)referrer_id;
weak_entry_t *entry;
if (!referent) return;
// 在 weak_table 中去找到 有 referent 的 entry (相当于在weak_table 表中去找到包含referent 元素的 数组)
if ((entry = weak_entry_for_referent(weak_table, referent))) {
// 找到了 这个 entry, 就删除 entry 中的 引用对象-referrer
remove_referrer(entry, referrer);
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;
}
}
}
// 如果 entry 中的引用对象 没有了 删除这个 entry
if (empty) {
weak_entry_remove(weak_table, entry);
}
}
}
关键步骤
1、在 weak_table 中去找到 有 referent-引用对象的 entry (相当于在weak_table 表中去找到包含referent 元素的 数组)
2、如果找到了 entry 就删除 entry中的 referent-引用对象
3、判断 entry 里面 还有没有其他对象,如果没有,就把entry也remove掉(相当于数组中的元素为空,就把这个数据也删掉)
1.3、 存储新值:weak_register_no_lock
id
weak_register_no_lock(weak_table_t *weak_table, id referent_id,
id *referrer_id, bool crashIfDeallocating)
{
......
weak_entry_t *entry;
// 在 weak_table 中去找到 有 referent 的 entry (相当于在weak_table 表中去找到包含referent 元素的 数组)
if ((entry = weak_entry_for_referent(weak_table, referent))) {
// 如果找到,直接append
append_referrer(entry, referrer);
}
else {
// 如果没有找到相应的 entry ,就创建一个entry 并插入 weak_table
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;
}
关键步骤
1、在 weak_table 中去找 有 referent 的 entry (相当于在weak_table 表中去找到包含referent 元素的 数组)
2、如果找到entry,进行添加操作:append_referrer
- 2.1、如果有空位,直接插进去
---- 这里有一个疑问:为什么会有一个空位?这里可以看new_entry的实现:初始容量为4,并默认4个空值
- 2.2、如果数量超过容量的3/4,进行扩容,再添加(这里想到,方法缓存机制,方法缓存也是超过3/4进行扩容,方法的扩容是:扩容之后,以前的方法删掉了,再把需要缓存的方法插进去)
3、如果没找到entry,创建一个entry,在进行插入
大概的过程是这样的:
释放原理
弱引用对象在释放的时候,可以在dealloc中去看具体是怎么释放的
dealloc -》
rootDealloc -》
object_dispose -》
objc_destructInstance -》
clearDeallocating -》
clearDeallocating_slow
void *objc_destructInstance(id obj)
{
if (obj) {
bool assoc = obj->hasAssociatedObjects();
// 如果有关联对象,就remove掉
if (assoc) _object_remove_assocations(obj);
// 弱引用的释放在这里
obj->clearDeallocating();
}
return obj;
}
inline void
objc_object::clearDeallocating()
{
if (slowpath(!isa.nonpointer)) {
// Slow path for raw pointer isa.
sidetable_clearDeallocating();
}
else if (slowpath(isa.weakly_referenced || isa.has_sidetable_rc)) {
// 在这里进行释放
clearDeallocating_slow();
}
assert(!sidetable_present());
}
// 找到散列表中的 weak_table 表,找到weak_table 中的 entry,将entry中的 引用对象referrer 置空,最后remove entry
NEVER_INLINE void
objc_object::clearDeallocating_slow()
{
ASSERT(isa.nonpointer && (isa.weakly_referenced || isa.has_sidetable_rc));
SideTable& table = SideTables()[this];
table.lock();
if (isa.weakly_referenced) {
weak_clear_no_lock(&table.weak_table, (id)this);
}
if (isa.has_sidetable_rc) {
table.refcnts.erase(this);
}
table.unlock();
}
总之,释放的时候就是找到散列表中的 weak_table 表,找到weak_table 中的 entry,将entry中的 引用对象referrer 置空,最后remove entry
最后补充一张存储结构图 来源
补充
1、strong
同样的方法,进入strong底层,可以看到,底层默认实现的是 retain 方法,所以在arc中,strong其实等同于 retrain2、weak与assign
assign一般只修饰值类型,虽然也可以修饰引用类型,但是修饰的对象释放后,指针不会自动被置空,此时向对象发消息会崩溃。
weak 不会产生野指针问题。因为weak修饰的对象释放后(引用计数器值为0),指针会自动被置nil,之后再向该对象发消息也不会崩溃。 weak是安全的。