问题：为何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 (location, (objc_object*)newObj);
}
1.1、内部做的操作是 存储weak—storeWeak
static id
storeWeak(id *location, objc_object *newObj)
{
......
SideTable::lockTwo(oldTable, newTable);
if (haveOld && *location != oldObj) {
SideTable::unlockTwo(oldTable, newTable);
goto retry;
}
//有新值，判断类有没有初始化，如果没有初始化，就进行初始化
if (haveNew && newObj) {
Class cls = newObj->getIsa();
if (cls != previouslyInitializedClass &&
!((objc_class *)cls)->isInitialized())
{
SideTable::unlockTwo(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(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是安全的。