weak关键字的作用是弱引证，所引证方针的计数器不会加一，引证方针被开释时主动置nil。
一、weak实现结构
SideTables 共有64个节点，每个节点是一个散列表（SideTable），结构如下图
SideTable
SideTable里边包含了一个自旋锁、一个引证计数表、一张weak引证表
struct SideTable {
// 保证原子操作的自旋锁
spinlock_t slock;
// 引证计数的 hash 表
RefcountMap refcnts;
// weak 引证大局 hash 表
weak_table_t weak_table;
……
……
};
-
pinlock_t slock：uint32_t类型的非公正的自旋锁。非公正便是说取得锁的次序和申请锁的次序无关，第一个申请锁的线程可能最终才取得到该锁，或者是刚取得锁的线程会再次立刻取得到该锁，造成饥饿等待。在OC中，_os_unfair_lock_opaque也记载了获取它的线程信息，只有取得该锁的线程才能够解开这把锁。 -
RefcountMap refcnts：用来存储方针的引证计数。它实质上是一个以objc_object为key的hash表，其vaule便是方针的引证计数。一起，当方针的引证计数变为0时，会主动将相关的信息从hash表中除掉。 -
weak_table_t weak_table： 用来存储OC方针弱引证的相关信息，详见下文
weak_table_t
-
weak_table是典型hash结构。 -
weak_entry_t *weak_entries是一个动态数组，存储的是weak_entry_t弱引证信息 - 每个
weak_entry_t弱引证信息对应一个OC方针
struct weak_table_t {
// 弱引证信息动态数组
weak_entry_t *weak_entries;
// 数组重的元素个数
size_t num_entries;
// hash数组长度-1，会参与hash核算。
uintptr_t mask;
// 可能会产生的hash抵触的最大次数，用于判别是否呈现了逻辑过错（hash表中的抵触次数不会超越此值）
uintptr_t max_hash_displacement;
};
weak_entry_t
每个weak_entry_t实例对应了一个OC方针，内部有一个数组 objc_object **new_referrer 存储 weak_referrer_t（指向弱引证该方针的指针），经过操作其指向能够使得weak引证的指针在方针析构后，指向nil。
详见注解
#define WEAK_INLINE_COUNT 4
#define REFERRERS_OUT_OF_LINE 2
#if __LP64__
#define PTR_MINUS_2 62
#else
#define PTR_MINUS_2 30
#endif
struct weak_entry_t {
// 弱引证方针指针地址取反
DisguisedPtr<objc_object> referent;
// 引证该方针的方针列表，联合。
// 弱引证该方针的指针数目小于等于 WEAK_INLINE_COUNT，运用定长数组 weak_referrer_t inline_referrers[WEAK_INLINE_COUNT]。
// 弱引证该方针的指针数目超越 WEAK_INLINE_COUNT，将定长数组中的元素转移到动态数组 weak_referrer_t *referrers且之后都是用动态数组存储
// 为什么做定长/动态数组的切换？考虑到弱引证的指针个数一般不会超越`WEAK_INLINE_COUNT`个。这时候运用定长数组，不需求动态的申请内存空间，而是一次分配一块接连的内存空间。这会得到运转功率上的提高。
union {
struct {
// 弱引证该方针的方针指针地址的hash数组
weak_referrer_t *referrers;
// 是否运用动态hash数组符号位
uintptr_t out_of_line_ness : 2;
// hash数组中的元素个数
uintptr_t num_refs : PTR_MINUS_2;
// hash数组长度-1，会参与hash核算。
// ps：这儿是hash数组的长度，而不是元素个数。数组长度可能是64而元素仅存了2个。
uintptr_t mask;
// 可能会产生的hash抵触的最大次数，用于判别是否呈现了逻辑过错（hash表中的抵触次数不会超越此值）
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];
};
};
// 用来判别当时的是运用的定长数组还是动态数组
// 依据REFERRERS_OUT_OF_LINE注解：inline_referrers[1] 中存储的是 pointer-aligned DisguisedPtr，其最低位一定是 0b00 或 0b11 ，因而能够用 0b10 表示运用了动态数组
// 回来true，此刻运用的动态数组
// 回来false，运用静态数组
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的初始化
如下代码，创立一个NSObject方针obj1，生成另一个weak标识的NSObject方针obj2指向obj1
objc_initWeak
断点进入汇编能够看到调用了objc_initWeak办法
objc_initWeak里边调用的是storeWeak
storeWeak
storeWeak会先判别类是否初始化，假如没有则将其初始化然后retry。接下来判别是否存在旧值需求删去，最终增加上新值。
storeWeak太长就不贴图了，附上storeWeak的代码和注解
// HaveOld: true - 变量有值
// false - 需求被及时整理，当时值可能为 nil
// HaveNew: true - 需求被分配的新值，当时值可能为 nil
// false - 不需求分配新值
// CrashIfDeallocating: true - 阐明 newObj 现已开释或者 newObj 不支持弱引证，该进程需求暂停
// false - 用 nil 替代存储
template <HaveOld haveOld, HaveNew haveNew,
enum CrashIfDeallocating crashIfDeallocating>
static id
storeWeak(id *location, objc_object *newObj)
{
// 该进程用来更新弱引证指针的指向
ASSERT(haveOld || haveNew);
if (!haveNew) ASSERT(newObj == nil);
// 初始化 previouslyInitializedClass 指针
Class previouslyInitializedClass = nil;
id oldObj;
// 声明两个 SideTable 新旧散列创立
SideTable *oldTable;
SideTable *newTable;
// 取得新值和旧值的锁存方位（用地址作为唯一标明）
// 经过地址来树立索引标志，避免桶重复
// 下面指向的操作会改变旧值
retry:
if (haveOld) { // 更改指针，取得以 oldObj 为索引所存储的值地址
oldObj = *location;
oldTable = &SideTables()[oldObj];
} else {
oldTable = nil;
}
if (haveNew) { // 更改新值指针，取得以 newObj 为索引所存储的值地址
newTable = &SideTables()[newObj];
} else {
newTable = nil;
}
// 加锁操作，避免多线程中竞赛抵触
SideTable::lockTwo<haveOld, haveNew>(oldTable, newTable);
// 避免线程抵触重处理
// location 应该与 oldObj 保持一致，假如不同，阐明当时的 location 现已处理过 oldObj 但是又被其他线程所修改
if (haveOld && *location != oldObj) {
SideTable::unlockTwo<haveOld, haveNew>(oldTable, newTable);
goto retry;
}
// 避免弱引证间死锁
// 而且经过 +initialize 初始化结构器保证一切弱引证的isa不是空
if (haveNew && newObj) {
// 取得新方针的 isa 指针
Class cls = newObj->getIsa();
// 判别 isa 非空且现已初始化
if (cls != previouslyInitializedClass &&
!((objc_class *)cls)->isInitialized())
{
// 解锁
SideTable::unlockTwo<haveOld, haveNew>(oldTable, newTable);
// 对其 isa 指针进行初始化
class_initialize(cls, (id)newObj);
// 假如该类现已完成履行 +initialize 办法是最理想状况
// 假如该类 +initialize 在线程中
// 例如 +initialize 正在调用 storeWeak 办法
// 需求手动对其增加维护策略，并设置 previouslyInitializedClass 指针进行符号
previouslyInitializedClass = cls;
goto retry;
}
}
// ② 清除旧值
if (haveOld) {
weak_unregister_no_lock(&oldTable->weak_table, oldObj, location);
}
// ③ 分配新值
if (haveNew) {
newObj = (objc_object *)
weak_register_no_lock(&newTable->weak_table, (id)newObj, location,
crashIfDeallocating ? CrashIfDeallocating : ReturnNilIfDeallocating);
// 假如弱引证被开释 weak_register_no_lock 办法回来 nil
// 在引证计数表中设置若引证符号位
if (!newObj->isTaggedPointerOrNil()) {
// 弱引证位初始化操作
// 引证计数那张散列表的weak引证方针的引证计数中标识为weak引证
newObj->setWeaklyReferenced_nolock();
}
// 之前不要设置 location 方针，这儿需求更改指针指向
*location = (id)newObj;
}
else {
// 没有新值，则无需更改
}
SideTable::unlockTwo<haveOld, haveNew>(oldTable, newTable);
//必须在没有锁的状况下调用，由于它能够调用任意代码
//ps：即使_setWeaklyReferenced没有实现，resolveInstanceMethod:也可能被调用而且回调到弱引证机制中
callSetWeaklyReferenced((id)newObj);
return (id)newObj;
}
weak_register_no_lock
storeWeak需求的是分配新值的操作weak_register_no_lock。
该办法先记载下若引证的方针及其指针，保证弱引证方针有值而且不处于析构进程后，测验获取weak_table中存储的旧实例weak_entry_t。
- 假如存在旧实例就经过
append_referrer办法将引证方针增加到旧实例 - 假如不存在就新建
weak_entry_t并经过weak_entry_insert刺进weak_table中
weak_register_no_lock 源码解析
id
weak_register_no_lock(weak_table_t *weak_table, id referent_id,
id *referrer_id, WeakRegisterDeallocatingOptions deallocatingOptions)
{
// referent_id是新的被弱引证方针
objc_object *referent = (objc_object *)referent_id;
// referrer_id是__weak指针的地址
objc_object **referrer = (objc_object **)referrer_id;
// 假如referent为nil 或 referent 采用了TaggedPointer计数方法，直接回来，不做任何操作
if (referent->isTaggedPointerOrNil()) return referent_id;
// 保证被引证的方针可用（没有在析构，一起应该支持weak引证）
if (deallocatingOptions == ReturnNilIfDeallocating ||
deallocatingOptions == CrashIfDeallocating) {
bool deallocating;
if (!referent->ISA()->hasCustomRR()) {
deallocating = referent->rootIsDeallocating();
}
else {
// Use lookUpImpOrForward so we can avoid the assert in
// class_getInstanceMethod, since we intentionally make this
// callout with the lock held.
auto allowsWeakReference = (BOOL(*)(objc_object *, SEL))
lookUpImpOrForwardTryCache((id)referent, @selector(allowsWeakReference),
referent->getIsa());
if ((IMP)allowsWeakReference == _objc_msgForward) {
return nil;
}
deallocating =
! (*allowsWeakReference)(referent, @selector(allowsWeakReference));
}
// 正在析构的方针，不能够被弱引证
if (deallocating) {
if (deallocatingOptions == 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))) {
append_referrer(entry, referrer);
}
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_entry_for_referent
那么怎么从weak_table中定位到所需的 weak_entry_t？
在weak_register_no_lock里其实有调用到这个函数，便是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;
// 保证index不会越界，这和取余操作是相同的，用位操作替代能够提高功率。
size_t begin = hash_pointer(referent) & weak_table->mask;
size_t index = begin;
size_t hash_displacement = 0;
// 开端比照hash表中的数据是否与方针数据相等
while (weak_table->weak_entries[index].referent != referent) {
// 假如不相等，则index +1，
index = (index+1) & weak_table->mask;
// index == begin 绕了一圈，抛出过错
if (index == begin) bad_weak_table(weak_table->weak_entries);
hash_displacement++;
// 超越了hash抵触最大值 return nil
if (hash_displacement > weak_table->max_hash_displacement) {
return nil;
}
}
return &weak_table->weak_entries[index];
}
接下来看看 weak_entry是怎么刺进引证方针的
三、增加弱引证方针
在弱引证实例weak_entry被创立以后，会判别弱引证表是否存在该实例。
- 假如存在就会走
append_referrer - 不存在则创立后走
weak_entry_insert
两个函数处理类似，下面以append_referrer为例做解析
append_referrer
static void append_referrer(weak_entry_t *entry, objc_object **new_referrer)
{
if (! entry->out_of_line()) {
// 假如weak_entry 没有运用动态数组
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，做动态数组。
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());
// 假如动态数组中元素个数大于或等于数组方位总空间的3/4，则扩展数组空间为当时长度的一倍
if (entry->num_refs >= TABLE_SIZE(entry) * 3/4) {
// 扩容并刺进
return grow_refs_and_insert(entry, new_referrer);
}
// 开端刺进到weak_entry中
// 保证begin的方位只能大于或等于 数组的长度
size_t begin = w_hash_pointer(new_referrer) & (entry->mask);
// 初始的hash index
size_t index = begin;
// 用于记载hash抵触的次数，也便是hash再位移的次数
size_t hash_displacement = 0;
// 这儿 weak_entry_t 的hash算法和 weak_table_t 的hash算法是相同的，
while (entry->referrers[index] != nil) {
hash_displacement++;
// 移到下一个方位，再试一次能否刺进。
// 这儿entry->mask取值，一定是：0x111, 0x1111, 0x11111, ...
// 由于数组每次都是*2增长，即8， 16， 32，对应动态数组空间长度-1的mask，也便是前面的取值
index = (index+1) & entry->mask;
// 意味着走完都没有合适方位，抛出反常
if (index == begin) bad_weak_table(entry);
}
if (hash_displacement > entry->max_hash_displacement) {
// 记载最大的hash抵触次数
// max_hash_displacement是允许抵触的次数，假如超越都没方位便是出问题了
entry->max_hash_displacement = hash_displacement;
}
// 将ref存入hash数组
weak_referrer_t &ref = entry->referrers[index];
// 更新元素个数num_refs
ref = new_referrer;
entry->num_refs++;
}
至此，弱引证方针现已成功增加。
四、移除弱引证方针
接下来看看当方针被开释时，弱引证机制是怎么运转的。
rootDealloc
rootDealloc逻辑如下：
首要判别 object 是否采用了 Tagged Pointer计数，假如是则不进行任何析构操作。
接下来判别是否满足下列条件
- 方针采用了优化的
isa计数方法（isa.nonpointer） - 方针没有被
weak引证（!isa.weakly_referenced） - 没有相关方针（
!isa.has_assoc) - 没有自定义的
C++析构办法(!isa.has_cxx_dtor) - 没有用到
sideTable来做引证计数 (!isa.has_sidetable_rc) 假如都满足则能用函数free(this)快速开释内存。
其余的，则进入object_dispose((id)this) 慢开释分支。
object_dispose 调用 objc_destructInstance
objc_destructInstance 调用 clearDeallocating
clearDeallocating调用clearDeallocating_slow
weak_clear_no_lock
clearDeallocating_slow调用weak_clear_no_lock整理weak_table，一起将一切weak引证置为nil
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);
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;
// 获取弱使用方针的数组及其长度
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];
if (referrer) {
//假如的确是要被开释的方针，置空
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();
}
}
}
// 移除弱引证实例
weak_entry_remove(weak_table, entry);
}
至此，移除流程结束～
五、总结
最终，画了几张简图作为总结
底层结构
增加流程
移除流程
