文章目录
前言
在前面关于提到过【iOS】Block循环引用，在解决循环引用问题的时候，经常会使用到_ _weak，而 _ _weak其实还有个用途就是对象可能提前释放，使用 _ _weak来进行兜底(自动置nil),他有以下特点：
- 不增加引用计数：声明weak的指针不会增加他所指向对象的retainCount
- 自动置零(Zeroing)：当weak指针所指向的对象被释放(引用计数降为0，调用dealloc)时，所有指向该对象的weak指针被自动设置为nil，彻底避免了"野指针"访问崩溃的风险
- 可选性：因为可能为nil，所以访问weak变量时候要检查是否存在
weak的实现原理
我们先直接一句话总结weak的实现，即：weak 本质是一个 全局弱引用表（weak_table）
key 是对象，value 是所有指向它的 weak 指针地址集合
我们用weak修饰一个OC对象
objc
NSObject *obj = [[NSObject alloc] init];
__weak NSObject *weak = obj;断点调试发现,经过判空进入storeWeak函数里
我们再接着进入runtime处理_ _weak指针赋值的核心函数storeWeak（负责维护弱引用表）:
c++
template <HaveOld haveOld, HaveNew haveNew,
enum CrashIfDeallocating crashIfDeallocating>
static id
storeWeak(id *location, objc_object *newObj)
{
ASSERT(haveOld || haveNew);
if (!haveNew) ASSERT(newObj == nil);
Class previouslyInitializedClass = nil;
id oldObj;
SideTable *oldTable;
SideTable *newTable;
// Acquire locks for old and new values.
// Order by lock address to prevent lock ordering problems.
// Retry if the old value changes underneath us.
//获取新旧对象的锁，按照锁地址排序避免死锁
// 如果旧值在获取锁的过程中发生了变化则重试
retry:
if (haveOld) {
oldObj = *location;
oldTable = &SideTables()[oldObj];
} else {
oldTable = nil;
}
if (haveNew) {
newTable = &SideTables()[newObj];
} else {
newTable = nil;
}
/*weak为什么线程安全？？
1. weak操作加锁（SideTable锁）
2. 同时锁old/new，防止出现并发问题
3. 按照地址顺序加锁，防止出现死锁
weak 的读写通过 SideTable 加锁保证线程安全，并且采用地址排序加锁避免死锁
*/
SideTable::lockTwo<haveOld, haveNew>(oldTable, newTable);
//期间可能被别的线程修改，所以重新读取，保证数据一致性
if (haveOld && *location != oldObj) {
SideTable::unlockTwo<haveOld, haveNew>(oldTable, newTable);
goto retry;
}
// Prevent a deadlock between the weak reference machinery
// and the +initialize machinery by ensuring that no
// weakly-referenced object has an un-+initialized isa.
//防止弱引用机制和+initialize方法之间发生死锁（就是在+initialize之中使用weak修饰符）
// 确保弱引用对象的isa已经完成初始化,
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);
// 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;
}
}
// Clean up old value, if any.
if (haveOld) {
weak_unregister_no_lock(&oldTable->weak_table, oldObj, location);
}
// Assign new value, if any.
if (haveNew) {
newObj = (objc_object *)
//crashIfDeallocating ? CrashIfDeallocating : ReturnNilIfDeallocating说明如果对象正在释放，weak可能直接返回nil(或者崩溃)
//weak在对象正在释放的时候不会建立引用，避免野指针
weak_register_no_lock(&newTable->weak_table, (id)newObj, location,
crashIfDeallocating ? CrashIfDeallocating : ReturnNilIfDeallocating);
// weak_register_no_lock returns nil if weak store should be rejected
// Set is-weakly-referenced bit in refcount table.
//特判TaggedPointer 不参与 weak 表
if (!_objc_isTaggedPointerOrNil(newObj)) {
newObj->setWeaklyReferenced_nolock();
}
// Do not set *location anywhere else. That would introduce a race.
*location = (id)newObj;
}
else {
// No new value. The storage is not changed.
}
SideTable::unlockTwo<haveOld, haveNew>(oldTable, newTable);
// This must be called without the locks held, as it can invoke
// arbitrary code. In particular, even if _setWeaklyReferenced
// is not implemented, resolveInstanceMethod: may be, and may
// call back into the weak reference machinery.
callSetWeaklyReferenced((id)newObj);
return (id)newObj;
}weak的自动置nil是怎么做的：
- 注册weak，
weak_register_no_lock(...) - 对象释放时进行清理：
weak_clear_no_lock(...)
当对象 dealloc 时，会遍历 weak_table，把所有 weak 指针置为 nil
通过storeWeak实际上是接收了5个参数，分别是haveOld、haveNew、crashIfDeallocating、location 、newobj。主要的流程是，对旧值的释放和让指针指向新的引用
- 如果对旧指针的移除，就进入
weak_unregister_no_lock方法 - 如果是指向新的引用，就会进入
weak_register_no_lock，把这个新的weak对象添加到引用表之中 - 通过 SideTable 加锁保证线程安全
- 对象释放时遍历 weak_table，将所有 weak 指针置 nil
weak 不增加引用计数，并且在对象释放过程中不会建立引用，避免野指针。
SideTable
SideTable是Runtime管理对象附加信息的数据结构，Runtime不是只有一个SideTable，而是维护了一组SideTable，对象通过地址哈希映射到其中一个
每个 SideTable 内部包含：
RefcountMap：存储超出 nonpointer isa 能容纳的引用计数（extra_rc 溢出部分）。weak_table：维护对象与所有 weak 指针地址的映射，实现 weak 自动置 nil。spinlock_t（新版本已演进为其他锁实现）：保证对引用计数和 weak 表操作的线程安全。
其内部的结构体如下：
c++
struct SideTable {
spinlock_t slock; //自旋锁，保证线程安全
RefcountMap refcnts; //引用计数哈希表
weak_table_t weak_table; //弱引用表
SideTable() {
memset(&weak_table, 0, sizeof(weak_table));
}
~SideTable() {
_objc_fatal("Do not delete SideTable.");
}
void lock() { slock.lock(); }
void unlock() { slock.unlock(); }
void reset() { slock.reset(); }
// Address-ordered lock discipline for a pair of side tables.
template<HaveOld, HaveNew>
static void lockTwo(SideTable *lock1, SideTable *lock2);
template<HaveOld, HaveNew>
static void unlockTwo(SideTable *lock1, SideTable *lock2);
};SideTable的操作
- 如果不是
Nonpointer_isa，则直接操作SideTables散列表，此时散列表不是只有一张，而是有很多张 - Runtime会判断是否正在处于dealloc状态，如果已经开始释放，则拒绝新的retain或weak注册，避免访问正在销毁的对象
- 执行
extra_rc+1，即引用计数+1操作，并给一个引用计数的状态carry，用于表示extra_rc是否满了 - 如果
carry的状态表示extra_rc的引用计数满了，此时需要操作散列表，即 将满状态的一半拿出来存到extra_rc，另一半存在 散列表的rc_half。这么做的原因是因为如果都存储在散列表，每次对散列表操作都需要开解锁，操作耗时，消耗性能大，这么对半分操作的目的在于提高性能
Runtime 使用多个 SideTable，而不是一个全局 SideTable。对象通过地址哈希到不同的 SideTable，从而减少锁竞争，提高并发性能。
weak_table_t
弱引用表(Weak Reference Table)，核心的一个数据结构，用于管理对象的弱引用关系
weak_table 本质就是一个哈希表，里面存放很多 weak_entry。
c++
struct weak_table_t {
weak_entry_t *weak_entries; //指向弱引用条目数组的数组指针，即表示弱引用表真正存数据的地方
size_t num_entries; //当前表中的有效条目数量，当前有多少个 weak_entry
//下面两个都是哈希表的优化，上面的表示哈希表容量掩码 = 容量减一，用于索引计算；下面的表示的是最大哈希冲突偏移量
uintptr_t mask;
uintptr_t max_hash_displacement;
};
//Runtime 在注册weak时会检查对象是不是正在释放，如果正在释放，则不会建立 weak 引用，从而避免产生野指针。
enum WeakRegisterDeallocatingOptions {
ReturnNilIfDeallocating, //直接返回nil
CrashIfDeallocating, //直接crash
DontCheckDeallocating //内部使用
};
/// Adds an (object, weak pointer) pair to the weak table.
//建立weak，注册对象和weak指针地址之间的映射关系
id weak_register_no_lock(weak_table_t *weak_table, id referent,
id *referrer, WeakRegisterDeallocatingOptions deallocatingOptions);
/// Removes an (object, weak pointer) pair from the weak table.
//移除对象和weak指针地址之间的映射关系，典型场景是weak指针重新赋值
void weak_unregister_no_lock(weak_table_t *weak_table, id referent, id *referrer);
#if DEBUG
/// Returns true if an object is weakly referenced somewhere.
bool weak_is_registered_no_lock(weak_table_t *weak_table, id referent);
#endif
/// Called on object destruction. Sets all remaining weak pointers to nil.
//weak自动置nil的核心，对象：dealloc；
//Runtime:找到 weak_entry -> 遍历所有 weak -> 全部=nil -> 删除 weak_entry
void weak_clear_no_lock(weak_table_t *weak_table, id referent);
__END_DECLS
#endif /* _OBJC_WEAK_H_ */weak_entry_t
一个 weak_entry_t 对应一个被 weak 引用的对象。
"一个对象 + 所有指向它的 weak 指针地址"
c++
struct weak_entry_t {
//referent指向的就是被弱引用的对象p，DisguisedPtr本质也是一个对象指针，只是地址和其他的不太一样
DisguisedPtr<objc_object> referent;
union {
struct {
//referrers存的不是对象，是所有weak指针变量的地址(不是对象地址)，对象释放时，Runtime遍历这些地址，把对应的weak指针置为nil
weak_referrer_t *referrers;
uintptr_t out_of_line_ness : 2;
uintptr_t num_refs : PTR_MINUS_2;
uintptr_t mask;
uintptr_t max_hash_displacement;
};
struct {
// out_of_line_ness field is low bits of inline_referrers[1]
//Runtime 对少量 weak 引用采用内联数组存储，避免频繁堆内存分配；当 weak 指针数量较多时，再切换为动态数组（out-of-line）存储，以兼顾性能和空间。
weak_referrer_t inline_referrers[WEAK_INLINE_COUNT];
};
};
//判断当前是不是使用动态数组的存储方式
bool out_of_line() {
return (out_of_line_ness == REFERRERS_OUT_OF_LINE);
}
weak_entry_t& operator=(const weak_entry_t& other) {
memcpy(this, &other, sizeof(other));
return *this;
}
weak_entry_t(objc_object *newReferent, objc_object **newReferrer)
: referent(newReferent)
{
inline_referrers[0] = newReferrer;
for (int i = 1; i < WEAK_INLINE_COUNT; i++) {
inline_referrers[i] = nil;
}
}
};weak_unregister_no_lock
作用：解除对象和weak指针地址之间的映射关系
c++
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_entry_t）
if ((entry = weak_entry_for_referent(weak_table, referent))) {
// 从该条目中移除指定的弱引用指针（referrer）
remove_referrer(entry, referrer);
// 检查移除后该条目是否为空（即是否已经没有指向该对象的弱引用）
bool empty = true;
if (entry->out_of_line() && entry->num_refs != 0) {
// 如果当前是动态哈希表模式，并且num_refs（弱引用数量）不为0，则不空
empty = false;
}
else {
// 检查内联数组模式下的引用
for (size_t i = 0; i < WEAK_INLINE_COUNT; i++) {
if (entry->inline_referrers[i]) {
// 如果发现任何一个非空引用，说明不为空
empty = false;
break;
}
}
}
// 如果该条目为空（没有弱引用指向该对象），则从弱引用表中移除整个条目
if (empty) {
weak_entry_remove(weak_table, entry);
}
}
// 注意：这里并没有设置 *referrer = nil。
// 这是因为 objc_storeWeak() 要求：在解除注册期间，弱引用变量的值不能改变。
}unregister 只是删除 weak_table 中的映射关系；真正修改 weak 变量的是
storeWeak()（重新赋值）或weak_clear_no_lock()`（对象销毁）。
weak_register_no_lock
整个流程：检查对象是否可以建立weak -> 找到(或创建)weak_entry -> 把weak指针地址加入referrers
c++
id
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_object **referrer = (objc_object **)referrer_id;
// 如果referent为nil 或 referent 采用了TaggedPointer计数方式，直接返回，不做任何操作
if (!referent || referent->isTaggedPointer()) return referent_id;
// 确保被引用的对象可用（没有在析构，同时应该支持weak引用）
bool deallocating;
if (!referent->ISA()->hasCustomRR()) {
deallocating = referent->rootIsDeallocating();
}
else {
BOOL (*allowsWeakReference)(objc_object *, SEL) =
(BOOL(*)(objc_object *, SEL))
object_getMethodImplementation((id)referent,
SEL_allowsWeakReference);
if ((IMP)allowsWeakReference == _objc_msgForward) {
return nil;
}
deallocating =
! (*allowsWeakReference)(referent, SEL_allowsWeakReference);
}
// 正在析构的对象，不能够被弱引用
if (deallocating) {
if (crashIfDeallocating) {
_objc_fatal("Cannot form weak reference to instance (%p) of "
"class %s. It is possible that this object was "
"over-released, or is in the process of deallocation.",
(void*)referent, object_getClassName((id)referent));
} else {
return nil;
}
}
// now remember it and where it is being stored
// 在 weak_table中找到referent对应的weak_entry,并将referrer加入到weak_entry中
weak_entry_t *entry;
if ((entry = weak_entry_for_referent(weak_table, referent))) { // 如果能找到weak_entry,则讲referrer插入到weak_entry中
append_referrer(entry, referrer);
// 往这个对象对应的weak_entry中，再加入一个weak指针地址
}
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;
}- 注册前检查：Runtime 会检查对象是否正在 dealloc，如果对象已经进入释放流程，则拒绝建立 weak 引用（返回 nil 或 Crash）。
- 已存在weak_entry：调用 append_referrer，将新的 weak 指针地址加入该对象对应的 referrers 中
- 不存在weak_entry：创建新的 weak_entry，并插入 weak_table
- 不负责赋值：weak_register_no_lock 只负责维护 weak_table，不修改 weak 变量本身；真正的赋值由
storeWeak()完成。
weak_entry_for_referent
作用：weak_entry_for_referent用来根据被引用的对象从weak表中查询弱引用条目（weak_entry）。
c++
static weak_entry_t *
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; // 这里通过 & weak_table->mask的位操作，来确保index不会越界
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); // 触发bad weak table crash
hash_displacement++;
if (hash_displacement > weak_table->max_hash_displacement) { // 当hash冲突超过了可能的max hash 冲突时，说明元素没有在hash表中，返回nil
return nil;
}
}
return &weak_table->weak_entries[index];
}append_referrer
添加新的被引用对象的弱引用指针的地址到weak_entry_t的指针集合(referrers)中
c++
static void append_referrer(weak_entry_t *entry, objc_object **new_referrer)
{
if (! entry->out_of_line()) { // 如果weak_entry 尚未使用动态数组，走这里
// Try to insert inline.
for (size_t i = 0; i < WEAK_INLINE_COUNT; i++) {
if (entry->inline_referrers[i] == nil) {
entry->inline_referrers[i] = new_referrer;
return;
}
}
// 如果inline_referrers的位置已经存满了，则要转型为referrers，做动态数组。
// Couldn't insert inline. Allocate out of line.
weak_referrer_t *new_referrers = (weak_referrer_t *)
calloc(WEAK_INLINE_COUNT, sizeof(weak_referrer_t));
// This constructed table is invalid, but grow_refs_and_insert
// will fix it and rehash it.
for (size_t i = 0; i < WEAK_INLINE_COUNT; i++) {
new_referrers[i] = entry->inline_referrers[i];
}
entry->referrers = new_referrers;
entry->num_refs = WEAK_INLINE_COUNT;
entry->out_of_line_ness = REFERRERS_OUT_OF_LINE;
entry->mask = WEAK_INLINE_COUNT-1;
entry->max_hash_displacement = 0;
}
// 对于动态数组的附加处理：
assert(entry->out_of_line()); // 断言： 此时一定使用的动态数组
if (entry->num_refs >= TABLE_SIZE(entry) * 3/4) { // 如果动态数组中元素个数大于或等于数组位置总空间的3/4，则扩展数组空间为当前长度的一倍
return grow_refs_and_insert(entry, new_referrer); // 扩容，并插入
}
// 如果不需要扩容，直接插入到weak_entry中
// 注意，weak_entry是一个哈希表，key：w_hash_pointer(new_referrer) value: new_referrer
// 细心的人可能注意到了，这里weak_entry_t 的hash算法和 weak_table_t的hash算法是一样的，同时扩容/减容的算法也是一样的
size_t begin = w_hash_pointer(new_referrer) & (entry->mask); // '& (entry->mask)' 确保了 begin的位置只能大于或等于 数组的长度
size_t index = begin; // 初始的hash index
size_t hash_displacement = 0; // 用于记录hash冲突的次数，也就是hash再位移的次数
while (entry->referrers[index] != nil) {
hash_displacement++;
index = (index+1) & entry->mask; // index + 1, 移到下一个位置，再试一次能否插入。（这里要考虑到entry->mask取值，一定是：0x111, 0x1111, 0x11111, ... ，因为数组每次都是*2增长，即8， 16， 32，对应动态数组空间长度-1的mask，也就是前面的取值。）
if (index == begin) bad_weak_table(entry); // index == begin 意味着数组绕了一圈都没有找到合适位置，这时候一定是出了什么问题。
}
if (hash_displacement > entry->max_hash_displacement) { // 记录最大的hash冲突次数, max_hash_displacement意味着: 我们尝试至多max_hash_displacement次，肯定能够找到object对应的hash位置
entry->max_hash_displacement = hash_displacement;
}
// 将ref存入hash数组，同时，更新元素个数num_refs
weak_referrer_t &ref = entry->referrers[index];
ref = new_referrer;
entry->num_refs++;
}- 首先确定是使用定长数组还是动态数组
- 如果是使用定长数组，则直接将weak指针地址添加到数组即可
- 如果定长数组已经满了，则需要将定长数组中的元素转存到动态数组中。
- 如果动态数组的元素个数达到动态数组大小的3/4则扩容再进插入到weak_entry，如果不需要扩容则直接插入到weak_entry中
- 最后将ref存入hash数组，同时，更新元素个数num_refs
读取weak变量
objc_loadWeak（读 weak 变量）
当我们读取一个 __weak 变量时：
objc
__weak NSObject *weakObj = obj;
NSLog(@"%@", weakObj); // 这一行发生了什么？
编译器会将 weakObj 的读取转换为调用 objc_loadWeak(&weakObj)。
objc_loadWeak 的核心逻辑：
- 从 weak_entry 中找到对象地址，先 retain 一次 ------ 防止读取过程中对象被其他线程释放
- 将对象加入 autoreleasepool ------ 保证对象在当前 RunLoop 迭代内不会被释放
- 返回对象
c++
id objc_loadWeak(id *location) {
if (!*location) return nil;
return objc_autorelease(objc_loadWeakRetained(location));
}释放
当对象的引用计数为0时，此时就需要释放该对象，底层会调用_objc_rootDealloc方法对对象进行释放，而在_objc_rootDealloc方法里面会调用rootDealloc方法。
c++
inline void
objc_object::rootDealloc()
{
if (isTaggedPointer()) return; // fixme necessary?
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);
}
}-
首先判断对象是否是Tagged Pointer，如果是则直接返回。
-
如果对象是采用了优化的isa计数方式，且同时满足对象没有被weak引用!isa.weakly_referenced、有关联对象!isa.has_assoc 、没有自定义的C++析构方法!isa.has_cxx_dtor、没有用到SideTable来引用计数!isa.has_sidetable_rc则直接快速释放。
-
如果不能满足2中的条件，则会调用下面的object_dispose 方法。
object_dispose
object_dispose 方法内部调用了clearDeallocating方法。
c++
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;
}clearDeallocating
c++
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)) {
// Slow path for non-pointer isa with weak refs and/or side table data.
clearDeallocating_slow();
}
assert(!sidetable_present());
}clearDeallocating中有两个分支:
- 先判断对象是否采用了优化isa引用计数，如果没有的话则需要清理对象存储在SideTable中的引用计数数据。
- 如果对象采用了优化isa引用计数，则判断是否有使用SideTable的辅助引用计数(isa.has_sidetable_rc)或者有weak引用(isa.weakly_referenced)，符合这两种情况中一种的，调用clearDeallocating_slow 方法。
clearDeallocating_slow
c++
NEVER_INLINE void
objc_object::clearDeallocating_slow()
{
assert(isa.nonpointer && (isa.weakly_referenced || isa.has_sidetable_rc));
SideTable& table = SideTables()[this]; // 在全局的SideTables中，以this指针为key，找到对应的SideTable
table.lock();
if (isa.weakly_referenced) { // 如果obj被弱引用
weak_clear_no_lock(&table.weak_table, (id)this); // 在SideTable的weak_table中对this进行清理工作
}
if (isa.has_sidetable_rc) { // 如果采用了SideTable做引用计数
table.refcnts.erase(this); // 在SideTable的引用计数中移除this
}
table.unlock();
}在该方法中调用了weak_clear_no_lock来做weak_table的清理工作
weak_clear_no_lock
c++
void
weak_clear_no_lock(weak_table_t *weak_table, id referent_id)
{
objc_object *referent = (objc_object *)referent_id;
weak_entry_t *entry = weak_entry_for_referent(weak_table, referent); // 找到referent在weak_table中对应的weak_entry_t
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;
// 找出weak引用referent的weak 指针地址数组以及数组长度
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]; // 取出每个weak ptr的地址
if (referrer) {
if (*referrer == referent) { // 如果weak ptr确实weak引用了referent，则将weak ptr设置为nil，这也就是为什么weak 指针会自动设置为nil的原因
*referrer = nil;
}
else if (*referrer) { // 如果所存储的weak ptr没有weak 引用referent，这可能是由于runtime代码的逻辑错误引起的，报错
_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); // 由于referent要被释放了，因此referent的weak_entry_t也要移除出weak_table
}- 首先，通过调用weak_entry_for_referent函数来查找referent在弱引用表（weak_table）中的weak 指针地址数组以及数组长度
- 接着判断该数组是定长数组还是动态数组
- 如果是定长数组所有的弱引用信息都存储在weak_entry_t结构内的inline_referrers数组中；
- 如果是动态数组，信息则存储在一个独立的动态数组referrers中。
- 接着遍历所有存储的弱引用地址，如果weak指针确实weak引用了referent，则将weak ptr设置为nil
- 如果weak指针没有weak引用了referent，但是却不是nil，这可能表明有一些逻辑错误，抛出异常
- 由于referent要被释放了，因此referent的weak_entry_t也要移除出weak_table
weak的部分结构图
总结
-
weak底层实现：
weak的底层由Runtime的weak_table(弱引用表)实现，weak_table本质是一个哈希表，以对象地址(referent)为key，以weak_entry为Value。每个weak_entry保存一个被弱引用的对象，以及所有指向该对象的weak指针地址
-
整个生命周期：
初始化/赋值
objc_initWeak()、objc_storeWeak()最终都会调用storeWeak()。storeWeak()会先调用weak_unregister_no_lock()解除旧对象与 weak 指针地址的映射，再调用weak_register_no_lock()建立新对象与 weak 指针地址的映射，最后更新 weak 指针的值。
注册弱引用
weak_register_no_lock()会先检查对象是否正在 dealloc。- 如果对象正在释放，则拒绝建立 weak 引用（返回
nil或 Crash）。 - 如果对象正常，则将 weak 指针地址加入对象对应的
weak_entry中；若不存在对应weak_entry，则创建新的条目并插入weak_table。
对象释放
- 对象进入 dealloc 后，Runtime 最终调用
weak_clear_no_lock()。 weak_clear_no_lock()根据对象找到对应的weak_entry，遍历其中保存的所有 weak 指针地址，将这些 weak 指针全部置为nil，最后删除该对象对应的weak_entry，完成弱引用清理。
-
特点
- weak 不增加对象引用计数。
- weak 自动置
nil，不会产生野指针。 - Runtime 通过
SideTable加锁，保证 weak 操作的线程安全。
整个 weak 的底层可以归纳为四个核心函数：
storeWeak()：weak 赋值总入口，负责整个流程控制。weak_register_no_lock()：注册对象与 weak 指针地址的映射。weak_unregister_no_lock()：解除旧的映射关系。weak_clear_no_lock()：对象释放时遍历所有 weak 指针并置为nil。