iOS之深入解析weak关键字的底层原理
Posted Forever_wj
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了iOS之深入解析weak关键字的底层原理相关的知识，希望对你有一定的参考价值。
一、weak 关键字
- 在 ios 开发过程中，会经常使用到一个修饰词 weak，使用场景大家都比较清晰，避免出现对象之间的强强引用而造成对象不能被正常释放最终导致内存泄露的问题。
- weak 关键字的作用是弱引用，所引用对象的计数器不会加 1，并在引用对象被释放的时候自动被设置为 nil。
- weak 的常见场景是在 delegate，block，NSTimer 中使用，以避免循环引用所带来的内存泄漏。
- weak 的用处用一句话可归纳为：弱引用，在对象释放后置为 nil，避免错误的内存访问。用更通俗的话来表述是：weak 可以在不增加对象的引用计数的同时，又使得指针的访问是安全的。
二、weak 的底层分析
① weak 底层入口
- 当我们使用 weak 修饰属性的时候，它是怎么实现当所引用的对象被废弃的时候，变量置为 nil 的呢？在日常开发中，常见的 weak 的使用如下：
id object = [[NSObject alloc] init];
id __weak objc = object;
- 如果在此打断点跟踪汇编信息，可以发现底层库调了 objc_initWeak 函数：
② objc_initWeak
- 上面的代码，经过编译转换之后，会变成下面这样：
id objc;
objc_initWeak(&objc, object);
objc_destroyWeak(&objc);
- weak 修饰符变量通过 objc_initWeak 函数来初始化，在变量作用域结束的时候通过 objc_destroyWeak 函数来释放该变量的。
- objc_initWeak 方法实现如下：
id objc_initWeak(id *location, id newObj) {
// 查看对象实例是否有效
// 无效对象直接导致指针释放
if (!newObj) {
*location = nil;
return nil;
}
// 传递三个 bool 数值
// 使用 template 进行常量参数传递是为了优化性能
return storeWeak<false/*old*/, true/*new*/, true/*crash*/>
(location, (objc_object*)newObj);
}
- 该方法的两个参数 location 和 newObj：
- location ：__weak 指针的地址，存储指针的地址，可以在最后将其指向的对象置为 nil；
- newObj ：所引用的对象，即例子中的 objc 。
void objc_destroyWeak(id *location)
{
(void)storeWeak<true/*old*/, false/*new*/, false/*crash*/>
(location, nil);
}
- 对这两个方法，它们都调用了storeWeak 这个函数，但是两个方法传入的参数却稍有不同。 init 方法中，第一个参数为 weak 修饰的变量，第二个参数为引用计数对象，但在 destoryWeak 函数，第一参数依旧为 weak 修饰的变量，第二个参数为 nil。那这块传入不同的参数到底代表什么，继续分析 storeWeak 这个函数，如下：
// 更新一个弱引用变量
// 如果 HaveOld 是 true, 变量是个有效值，需要被及时清理。变量可以为 nil。
// 如果 HaveNew 是 true, 需要一个新的 value 来替换变量。变量可以为 nil
// 如果crashifdeallocation 是 ture ，那么如果 newObj 是 deallocating，或者 newObj 的类不支持弱引用，则该进程就会停止。
// 如果crashifdeallocation 是 false，那么 nil 会被存储。
template <bool HaveOld, bool HaveNew, bool 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) {
// 如果 HaveOld 为 true ，更改指针，获得以 oldObj 为索引所存储的值地址
oldObj = *location;
oldTable = &SideTables()[oldObj];
} else {
// 如果weak ptr之前没有弱引用过一个obj，则oldTable = nil
oldTable = nil;
}
if (HaveNew) {
// 获得以 newObj 为索引所存储的值对象，如果weak ptr要weak引用一个新的obj，则将该obj对应的SideTable取出，赋值给newTable
newTable = &SideTables()[newObj];
} else {
// 如果weak ptr不需要引用一个新obj，则newTable = nil
newTable = nil;
}
// 对两个 table 进行加锁操作，防止多线程中竞争冲突
SideTable::lockTwo<HaveOld, HaveNew>(oldTable, newTable);
// location 应该与 oldObj 保持一致，如果不同，说明当前的 location 已经处理过 oldObj 可是又被其他线程所修改, 保证线程安全，这个判断用来避免线程冲突重处理问题
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 初始化构造器保证所有弱引用的 isa 非空指向
if (HaveNew && newObj) {
// 获得新对象的 isa 指针
Class cls = newObj->getIsa();
// 判断 isa 非空且已经初始化
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.
// 如果该类已经完成执行 +initialize 方法是最好的，如果该类 + initialize 在线程中，例如 +initialize 正在调用storeWeak 方法，那么则需要手动对其增加保护策略，并设置 previouslyInitializedClass 指针进行标记然后重新尝试
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 *)weak_register_no_lock(&newTable->weak_table,
(id)newObj, location,
CrashIfDeallocating);
// weak_register_no_lock returns nil if weak store should be rejected
// 如果弱引用被释放则该方法返回 nil
// 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;
}
else {
// No new value. The storage is not changed.
}
SideTable::unlockTwo<HaveOld, HaveNew>(oldTable, newTable);
return (id)newObj;
}
- storeWeak 方法的实现代码虽然有些长，但是并不难以理解，该方法的实现分析如下：
-
- storeWeak 方法实际上是接收了5个参数，分别是 haveOld、haveNew和 crashIfDeallocating ，这三个参数都是以模板的方式传入的，是三个 bool 类型的参数，分别表示 weak 指针之前是否指向了一个弱引用，weak 指针是否需要指向一个新的引用，如果被弱引用的对象正在析构，此时再弱引用该对象是否应该 crash；
-
- 该方法维护了 oldTable 和 newTable，分别表示旧的引用弱表和新的弱引用表，它们都是 SideTable 的 hash 表；
-
- 如果 weak 指针之前指向了一个弱引用，则会调用 weak_unregister_no_lock 方法将旧的 weak 指针地址移除；
-
- 如果 weak 指针需要指向一个新的引用，则会调用 weak_register_no_lock 方法将新的 weak 指针地址添加到弱引用表中；
-
- 调用 setWeaklyReferenced_nolock 方法修改 weak 新引用的对象的 bit 标志位。
- store_weak 声明了新旧散列表指针，因为 weak 修饰的变量如果之前已经指向一个对象，然后其再次改变指向另一个对象，那么按理来说需要释放旧对象中该 weak 变量的记录，也就是要将旧记录删除，然后在新记录中添加，这里的新旧散列表就是这个作用。
-
- 根据新旧变量的地址获取相应的 SideTable；
-
- 对两个表进行加锁操作，防止多线程竞争冲突；
-
- 进行线程冲突重处理判断；
-
- 判断其 isa 是否为空，为空则需要进行初始化；
-
- 如果存在旧值，调用 weak_unregister_no_lock 函数清除旧值；
-
- 调用 weak_register_no_lock 函数分配新值；
-
- 解锁两个表，并返回第二参数。
- store_weak 中主要是 weak_unregister_no_lock 和 weak_register_no_lock 这两个方法，它们都是操作的 SideTable 结构的变量。
③ SideTable
- SideTable 的定义如下：
struct SideTable {
spinlock_t slock;
RefcountMap refcnts;
weak_table_t weak_table;
}
- SideTable 的定义有三个成员：
-
- spinlock_t slock : 自旋锁，用于上锁和解锁 SideTable，保证线程安全；
-
- RefcountMap refcnts ：引用计数表，用来存储 OC 对象的引用计数的 hash 表(仅在未开启 isa 优化或在 isa 优化情况下 isa_t 的引用计数溢出时才会用到)，每个对象的引用计数保存在全局的引用计数表中，一个对象地址对应一个引用计数；
-
- weak_table_t weak_table : 存储对象弱引用指针的 hash 表，是 OC 中 weak 功能实现的核心数据结构，所有的 weak 变量会被加入到全局的 weak 表中，表的 key 是 weak 修饰的变量指向的对象， value 值就是 weak 修饰的变量。
- weak_table_t 的定义如下：
struct weak_table_t {
// 保存了所有指向指定对象的 weak 指针
weak_entry_t *weak_entries;
// 存储空间，即 entries 的数目
size_t num_entries;
// 参与判断引用计数辅助量
uintptr_t mask;
// hash key 最大偏移量
uintptr_t max_hash_displacement;
};
- 分析说明：
-
- weak_entries： hash数组，用来存储弱引用对象的相关信息 weak_entry_t；
-
- num_entries： hash 数组中的元素个数；
-
- mask：hash 数组长度-1，会参与 hash 计算（注意，这里是 hash 数组的长度，而不是元素个数，比如，数组长度可能是64，而元素个数仅存了2个）；
-
- max_hash_displacement：可能会发生的 hash 冲突的最大次数，用于判断是否出现了逻辑错误（hash 表中的冲突次数绝不会超过改值）。
- weak_table_t 是一个典型的 hash 结构，weak_entries 是一个动态数组，用来存储 weak_entry_t 类型的元素，这些元素实际上就是 OC 对象的弱引用信息。
- weak_entry_t 的结构也是一个 hash 结构，其存储的元素是弱引用对象指针的指针，通过操作指针的指针，就可以使得 weak 引用的指针在对象析构后，指向 nil。
#define WEAK_INLINE_COUNT 4
#define REFERRERS_OUT_OF_LINE 2
struct weak_entry_t {
DisguisedPtr<objc_object> referent; // 被弱引用的对象
// 引用该对象的对象列表，联合。 引用个数小于4，用inline_referrers数组。 用个数大于4，用动态数组weak_referrer_t *referrers
union {
struct {
weak_referrer_t *referrers; // 弱引用该对象的对象指针地址的hash数组
uintptr_t out_of_line_ness : 2; // 是否使用动态hash数组标记位
uintptr_t num_refs : PTR_MINUS_2; // hash数组中的元素个数
uintptr_t mask; // hash数组长度-1，会参与hash计算。（注意，这里是hash数组的长度，而不是元素个数。比如，数组长度可能是64，而元素个数仅存了2个）素个数）。
uintptr_t max_hash_displacement; // 可能会发生的hash冲突的最大次数，用于判断是否出现了逻辑错误（hash表中的冲突次数绝不会超过改值）
};
struct {
// out_of_line_ness field is low bits of inline_referrers[1]
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_entry_t 的结构定义中有联合体，联合体的内部有定长数组 inline_referrers[WEAK_INLINE_COUNT] 和动态数组 weak_referrer_t *referrers 两种方式来存储弱引用对象的指针地址， 通过 out_of_line() 这样一个函数方法来判断采用哪种存储方式。
-
- 当弱引用该对象的指针数目小于等于 WEAK_INLINE_COUNT 时，使用定长数组；
-
- 当超过 WEAK_INLINE_COUNT 时，会将定长数组中的元素转移到动态数组中，并之后都是用动态数组存储。
- 因此，弱引用表的结构是一个 hash 结构的表，Key 是所指对象的地址，Value 是 weak 指针的地址（这个地址的值是所指对象的地址）数组。
- 每个对象的 SideTable 中的 weak_table_t 都是全局 weak 表的入口，以引用计数对象为键找到其所记录的 weak 修饰的对象。weak_entry_t 中的 referrers 有两种形式，当 out_of_line 为 0 的时候，referrers 是一个静态数组型的表，数组大小默认为 WEAK_INLINE_COUNT 大小，当 out_of_line 不为 0 的时候，referrers 是一个动态数组，内容随之增加。
④ weak_register_no_lock 添加弱引用
- weak_register_no_lock 方法实现如下：
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); // 将referrer插入到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;
}
- weak_register_no_lock 的四个参数解释：
-
- weak_table：weak_table_t 结构类型的全局的弱引用表；
-
- referent_id：weak指针；
-
- *referrer_id：weak指针地址；
-
- crashIfDeallocating ：若果被弱引用的对象正在析构，此时再弱引用该对象是否应该 crash。
- weak_register_no_lock 的实现功能：
-
- 如果 referent 为 nil 或 referent 采用了TaggedPointer计数方式，直接返回，不做任何操作；
-
- 如果对象正在析构，则抛出异常；
-
- 如果对象不能被 weak 引用，直接返回 nil；
-
- 如果对象没有再析构且可以被 weak 引用，则调用 weak_entry_for_referent 方法根据弱引用对象的地址从弱引用表中找到对应的 weak_entry，如果能够找到则调用 append_referrer 方法向其中插入 weak 指针地址。否则新建一个 weak_entry。
- weak_entry_for_referent 获取元素，如下：
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指针地址添加到数组即可，如果定长数组已经用尽，则需要将定长数组中的元素转存到动态数组中，实现如下：
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_unregister_no_lock 移除引用
- 如果 weak 指针之前指向了一个弱引用，则会调用 weak_unregister_no_lock 方法将旧的 weak 指针地址移除，如下：
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;以上是关于iOS之深入解析weak关键字的底层原理的主要内容，如果未能解决你的问题，请参考以下文章
iOS之深入解析类加载的底层原理：分类如何加载到类以及分类和类的配合使用