本文主要是解析Weak这种特性的底层实现。
weak 此特质表明该属性定义了一种“非拥有关系” (nonowning relationship)。为这种属性设置新值时，设置方法既不保留新值，也不释放旧值。此特质同 assign 类似， 然而在属性所指的对象遭到摧毁时，属性值也会清空(nil out)。
以下的源码来自于是Runtime最新版本objc4-723.tar.gz。
先上一个个人整理的整体结构图，好让大家心中有数。
Screen Shot 2018-10-14 at 5.13.23 PM.png
结构体
SideTables
SideTables用来管理所有对象的引用计数和weak指针，是一个全局的Hash表。它使用对象的内存地址当它的key，SideTable结构体为value。
static StripedMap& SideTables() {
return *reinterpret_cast*>(SideTableBuf);
}
这个有点难懂，以下是weak 弱引用的实现方式的解释：
在取出实例方法的实现中，使用了 C++ 标准转换运算符 reinterpret_cast ，其表达方式为：
reinterpret_cast (expression)
而 StripedMap 是一个模板类（Template Class），通过传入类（结构体）参数，会动态修改在该类中的一个 array 成员存储的元素类型，并且其中提供了一个针对于地址的 hash 算法，用作存储 key。可以说， StripedMap 提供了一套拥有将地址作为 key 的 hash table 解决方案，而该方案采用了模板类，是拥有泛型性的。
SideTable
Side table 本质就是用于保存额外信息的单独内存块，并且它还是可选的。也就是说，对于那些无需保存额外信息的对象来说并没有多余开销。它主要用于管理对象的引用计数和 weak 表。
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 forceReset() { slock.forceReset(); }
// Address-ordered lock discipline for a pair of side tables.
template
static void lockTwo(SideTable *lock1, SideTable *lock2);
template
static void unlockTwo(SideTable *lock1, SideTable *lock2);
};
- slock： 保证原子操作的自旋锁，避免计数错误。这里苹果为了性能考虑选择自旋锁。
自旋锁是一种非阻塞锁，也就是说，如果某线程需要获取自旋锁，但该锁已经被其他线程占用时，该线程不会被挂起，而是在不断的消耗CPU的时间，不停的试图获取自旋锁。
互斥量是阻塞锁，当某线程无法获取互斥量时，该线程会被直接挂起，该线程不再消耗CPU时间，当其他线程释放互斥量后，操作系统会激活那个被挂起的线程，让其投入运行。
自旋锁比较适用于锁使用者保持锁时间比较短的情况。正是由于自旋锁使用者一般保持锁时间非常短，因此选择自旋而不是睡眠是非常必要的，自旋锁的效率远高于互斥锁。信号量和读写信号量适合于保持时间较长的情况，它们会导致调用者睡眠，因此只能在进程上下文使用，而自旋锁适合于保持时间非常短的情况，它可以在任何上下文使用。如果被保护的共享资源只在进程上下文访问，使用信号量保护该共享资源非常合适，如果对共享资源的访问时间非常短，自旋锁也可以。但是如果被保护的共享资源需要在中断上下文访问（包括底半部即中断处理句柄和顶半部即软中断），就必须使用自旋锁。自旋锁保持期间是抢占失效的，而信号量和读写信号量保持期间是可以被抢占的。自旋锁只有在内核可抢占或SMP（多处理器）的情况下才真正需要，在单CPU且不可抢占的内核下，自旋锁的所有操作都是空操作。另外格外注意一点：自旋锁不能递归使用。
- refcnts：引用计数的 hash 表，通过散列表的结构存储了对象持有者的地址以及引用计数
- weak_table：weak 引用全局 hash 表
RefcountMap
有点复杂，想看详细结构的可以看这里llvm::DenseMapBase< DerivedT, KeyT, ValueT, KeyInfoT, BucketT > Class Template Reference
由于本篇文章主要不是讲解引用计数原理的，所以关于RefcountMap没有多做研究，关于引用计数原理和RefcountMap推荐看这篇文章Objective-C 引用计数原理
weak_table_t
苹果使用一个全局的 weak 表来保存所有的 weak 引用。使用对象地址为key，weak_entry_t结构为value，weak_entry_t 中保存了所有指向该对象的 weak 指针。
weak 表的作用是在对象执行 dealloc 的时候将所有指向该对象的 weak 指针的值设为 nil，避免悬空指针。
/**
* The global weak references table. Stores object ids as keys,
* and weak_entry_t structs as their values.
*/
struct weak_table_t {
weak_entry_t *weak_entries;
size_t num_entries;
uintptr_t mask;
uintptr_t max_hash_displacement;
};
- weak_entries：负责维护和存储指向一个对象的所有弱引用的 hash 表
- num_entries：负责记录weak_table_t目前保存的entry的数目
- mask：记录weak_table_t的总容量
- max_hash_displacement：记录weak_table_t所有项的最大偏移量，因为会有hash碰撞的情况，而weak_table_t采用了开放寻址来解决，所以某个entry实际存储的位置并不一定是hash函数计算出来的位置
weak_entry_t
weak_entry_t 是存储在弱引用表中的一个内部结构体，它负责维护和存储指向一个对象的所有弱引用hash表。
struct weak_entry_t {
DisguisedPtr referent;
union {
struct {
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]
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;
}
}
};
- referent：被指对象的地址。前面循环遍历查找的时候就是判断目标地址是否和他相等。
- referrers：可变数组,里面保存着所有指向这个对象的弱引用的地址。当这个对象被释放的时候，referrers里的所有指针都会被设置成nil。
- inline_referrers：只有4个元素的数组，默认情况下用它来存储弱引用的指针。当大于4个的时候使用referrers来存储指针
weak_entry_t有一个巧妙的设计，即如果一个对象对应的弱引用数目较少的话(<=WEAK_INLINE_COUNT，runtime把这个值设置为4)，则其弱引用会被依次保存到一个inline数组里。这个inline数组的内存会在weak_entry_t初始化的时候一并分配好，而不是需要用到的时候再去申请新的内存空间，从而达到提到运行效率的目的。此外，union中的两个struct是共享同一块内存的，如果不使用inline数组，而直接使用HashTable的方式来实现，那么num_refs，mask和max_hash_displacement这些变量都需要单独的存储空间，会使用更多的内存。综上，使用inline数组在节约一定内存空间的同时还相对提高了运行效率。
工作原理分析
objc_initWeak
在初始化一个weak对象时runtime会调用objc_initWeak方法，这个方法的具体实现是在NSObject.mm文件中
/**
* 初始化一个指向某个对象地址的新指针。
*/
id
objc_initWeak(id *location, id newObj)
{
if (!newObj) {
*location = nil;
return nil;
}
// 这里使用了Template（模板），有三个参数
// DontHaveOld--没有旧对象，
// DoHaveNew--有新对象，
// DoCrashIfDeallocating-- 如果newObj已经被释放了就Crash提示
return storeWeak
(location, (objc_object*)newObj);
}
// Template 参数
enum HaveOld { DontHaveOld = false, DoHaveOld = true };
enum HaveNew { DontHaveNew = false, DoHaveNew = true };
// 更新weak变量.
// 当设置HaveOld是true，即DoHaveOld，表示这个weak变量已经有值，需要被清理，这个值也有能是nil
// 当设置HaveNew是true， 即DoHaveNew，表示有一个新值被赋值给weak变量，这个值也有能是nil
//当设置参数CrashIfDeallocating是true，即DoCrashIfDeallocating，如果newObj已经被释放或者newObj是一个不支持弱引用的类，则暂停进程
// deallocating或newObj的类不支持弱引用
// 当设置参数CrashIfDeallocating是false，即DontCrashIfDeallocating，则存储nil
enum CrashIfDeallocating {
DontCrashIfDeallocating = false, DoCrashIfDeallocating = true
};
template
这个函数在Clang中的声明如下：
id objc_initWeak(id *object, id value);
前提条件：object是一个有效的指针，尚未注册为__weak对象。value为null或指向有效对象的指针。
如果value是空指针或它指向的对象已经释放，则object也就是weak的指针将初始化为0（nil）。 否则，将object注册为指向value的__weak对象。 相当于以下代码：
id objc_initWeak(id *object, id value) {
*object = nil;
return objc_storeWeak(object, value);
}
举个栗子：
NSObject *obj = [[NSObject alloc] init];
__weak NSObject *obj1 = obj;
就会编译成
objc_initWeak(&obj1, obj);
objc_storeWeak
接下来看看objc_storeWeak方法
static id
storeWeak(id *location, objc_object *newObj)
{
assert(haveOld || haveNew);
if (!haveNew) assert(newObj == nil);
// 初始化当前正在 +initialize 的类对象为nil
Class previouslyInitializedClass = nil;
id oldObj;
// 声明新旧SideTable，
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:
// 如果weak ptr之前弱引用过一个obj，则将这个obj所对应的SideTable取出，赋值给oldTable
if (haveOld) {
oldObj = *location;
oldTable = &SideTables()[oldObj];
} else {
oldTable = nil;
}
if (haveNew) {
newTable = &SideTables()[newObj];
} else {
newTable = nil;
}
SideTable::lockTwo(oldTable, newTable);
if (haveOld && *location != oldObj) {
SideTable::unlockTwo(oldTable, newTable);
goto retry;
}
//通过确保没有弱引用的对象具有未初始化的 isa，防止弱引用机制和 +initialize 机制之间的死锁。
if (haveNew && newObj) {
// 获得新对象的 isa 指针
Class cls = newObj->getIsa();
// 判断 isa 非空且已经初始化
if (cls != previouslyInitializedClass &&
!((objc_class *)cls)->isInitialized())
{
// 解锁新旧SideTable
SideTable::unlockTwo(oldTable, newTable);
_class_initialize(_class_getNonMetaClass(cls, (id)newObj));
// 如果 newObj 已经完成执行完 +initialize 是最理想情况
// 如果 newObj的 +initialize 仍然在线程中执行
// (也就是说newObj的 +initialize 正在调用 storeWeak 方法)
// 通过设置previousInitializedClass以在重试时识别它。
previouslyInitializedClass = cls;
goto retry;
}
}
// 清除旧值，实际上是清除旧对象weak_table中的location
if (haveOld) {
weak_unregister_no_lock(&oldTable->weak_table, oldObj, location);
}
// 分配新值，实际上是保存location到新对象的weak_table种
if (haveNew) {
newObj = (objc_object *)
weak_register_no_lock(&newTable->weak_table, (id)newObj, location,
crashIfDeallocating);
// 如果弱引用被释放 weak_register_no_lock 方法返回 nil
// 如果新对象存在，并且没有使用TaggedPointer技术，在引用计数表中设置若引用标记位
if (newObj && !newObj->isTaggedPointer()) {
// 标记新对象有weak引用，isa.weakly_referenced = true;
newObj->setWeaklyReferenced_nolock();
}
// 设置location指针指向newObj
// 不要在其他地方设置 *location。 那会引起竞争。
*location = (id)newObj;
}
else {
// No new value. The storage is not changed.
}
SideTable::unlockTwo(oldTable, newTable);
return (id)newObj;
}
其实这个方法看的不是很明白......
weak_unregister_no_lock
/**
* 解除已经注册的弱引用.
* This is used when referrer's storage is about to go away, but referent
* isn't dead yet. (Otherwise, zeroing referrer later would be a
* bad memory access.)
* Does nothing if referent/referrer is not a currently active weak reference.
* Does not zero referrer.
*
* FIXME currently requires old referent value to be passed in (lame)
* FIXME unregistration should be automatic if referrer is collected
*
* @param weak_table 弱引用表.
* @param referent 旧对象.
* @param referrer 旧对象弱引用地址.
*/
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;
// 如果其旧对象为 nil，无需注销
if (!referent) return;
// 获取对象对应的weak_entry_t
if ((entry = weak_entry_for_referent(weak_table, referent))) {
// 通过地址来解除引用关联
remove_referrer(entry, referrer);
// 判断referrers是否为空
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;
}
}
}
// 如果referrers为空，weak_table删除entry
if (empty) {
weak_entry_remove(weak_table, entry);
}
}
// Do not set *referrer = nil. objc_storeWeak() requires that the
// value not change.
}
weak_register_no_lock
/**
* Registers a new (object, weak pointer) pair. Creates a new weak
* object entry if it does not exist.
*
* @param weak_table The global weak table.
* @param referent 新对象
* @param referrer weak变量地址
*/
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;
// 如果新对象为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);
}
// 正在析构的对象，不能够被弱引用，如果crashIfDeallocating为true，crash ，并输出日志。否者返回nil
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_entry_t *entry;
// 在 weak_table中找到referent对应的weak_entry,并将referrer加入到weak_entry中
if ((entry = weak_entry_for_referent(weak_table, referent))) {
// 把weak变量地址，加入weak_entry_t
// 先用数组inline_referrers存储，满了用哈希表referrers
// 如果referrers到了3/4容量，就扩容2倍，重新存回去
// 没满，直接存入referrers，碰撞处理（哈希值++）
append_referrer(entry, referrer);
}
else {
// 新建一个weak_entry_t，保存weak地址
weak_entry_t new_entry(referent, referrer);
// 如果weak_table满容，进行自增长，到了3/4就扩容1倍
weak_grow_maybe(weak_table);
// new_entry插入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_clear_no_lock
当对象被释放，清除对象的weak_entry_t、设置referrers中所有的weak地址设置为nil
/**
* Called by dealloc; nils out all weak pointers that point to the
* provided object so that they can no longer be used.
*
* @param weak_table
* @param referent The object being deallocated.
*/
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);
如果entry为nil，直接return
if (entry == nil) {
/// XXX shouldn't happen, but does with mismatched CF/objc
//printf("XXX no entry for clear deallocating %p\n", referent);
return;
}
// 将引用归0
weak_referrer_t *referrers;
size_t count;
// 获取weak地址数组，分为：inline_referrers与referrers
// 前面讲过只有4个元素的数组，默认情况下用inline_referrers来存储弱引用的指针。当大于4个的时候使用referrers来存储指针
if (entry->out_of_line()) {
referrers = entry->referrers;
count = TABLE_SIZE(entry);
}
else {
referrers = entry->inline_referrers;
count = WEAK_INLINE_COUNT;
}
// 通过for循环取出每个weak ptr的地址
for (size_t i = 0; i < count; ++i) {
objc_object **referrer = referrers[i];
if (referrer) {
//// 如果weak ptr确实weak引用了referent，则将weak地址设置为nil
if (*referrer == referent) {
*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();
}
}
}
// 把referent的weak_entry_t也要移除出weak_table
weak_entry_remove(weak_table, entry);
}
参考文章：
Clang 8 documentation
weak 弱引用的实现方式
Objective-C 引用计数原理
iOS管理对象内存的数据结构以及操作算法--SideTables、RefcountMap、weak_table_t-一
细说weak
Runtime如何实现weak属性？
Objective-C 引用计数原理
OC Runtime之Weak(1)---weak_table_t
OC Runtime之Weak(2)---weak_entry_t
OC 看objc源码认识weak
Objective-C runtime机制(6)——weak引用的底层实现原理