weak指针这部分代码写的很好啊，结构清晰，接口定义到关键位置，读取来很舒服。
整体结构
weak指针管理结构.png
- SideTable包含了引用计数表和weak指针表，大概就是内存管理的总表，SideTable有多张，对象根据内存地址会关联上某一张
- weak_table_t 包含了所有具有weak指针的对象的weak指针信息
- weak_entry_t 对应某一个对象，一个对象可能有多个weak指针，它们作为一个整体存放在这里
- weak_entry_t包含两部分，一个是对象的内存地址，这个相当于key/id的作用，用来识别是对应哪个对象的；另一部分就是指向这个对象的所有weak指针。
整体的逻辑就是：
使用hash表把对象和所有指向它的weak指针关联起来，等这个对象dealloc的时候，把这些weak指针拿出来，全部设置成nil。
SideTable
weak指针原理-sideTable.png
We cannot use a C++ static initializer to initialize SideTables because
libc calls us before our C++ initializers run.
代码注释里有句话，所以这就是为什么用静态内存+指针强转来构建SideTable的原因吧，要足够早。
SideTable是用StripedMap包装了的，StripedMap的作用，看它的读取方法：
T& operator[] (const void *p) {
return array[indexForPointer(p)].value;
}
它重载了中括号[]，从array里把值取出来，关键就是indexForPointer这个函数，它完成从指针到索引的转换：
static unsigned int indexForPointer(const void *p) {
uintptr_t addr = reinterpret_cast<uintptr_t>(p);
return ((addr >> 4) ^ (addr >> 9)) % StripeCount;
}
所以它其实是一个hash函数，根据指针的值，也就是指向内存的地址，转化成落在[0, StripeCount]范围内的一个unsigned int值。
整体来看，对一个对象，获取它的SideTable，就是把这个对象的地址转化成了一个[0, StripeCount]范围内的索引，在拿到这个索引的SideTable。
weak_table_t和weak_entry_t单看结构没什么特别的，在使用的时候再看。
weak指针的使用
3中情况：
- weakA = weakB
- weakA = strongB
- strongA = weakB
情况1和2都是调用了id objc_storeWeak(id *location, id newObj),情况3走的是id objc_loadWeakRetained(id *location)，而objc_loadWeakRetained实际就是把weak对象retain了一下，属于另外的问题了。
还有一种情况，定义一个weak指针的时候：__weak TFBook *weakBook = nil;,这个也是走了id objc_storeWeak(id *location, id newObj)。
所以objc_storeWeak是核心的核心。
怎么看调用什么方法？猥琐一点，搞个while循环,在里面写想查看的方法，然后用instrument工具里的Time Profiler看占掉cpu 100%的那个就是了！
objc_storeWeak
template <bool HaveOld, bool HaveNew, bool CrashIfDeallocating>
static id
storeWeak(id *location, objc_object *newObj)
- HaveOld 是否有就对象，weakA = weakB，如果weakA之前是nil,那HaveOld就是false.
- HaveNew 是否新对象
- 这个操作处在deallocing调用过程中是否奔溃
- location是指向weak指针的指针，因为要修改weak指针
- newObj新对象
它的作用就是解除旧对象关系，和新对象建立联系。
storeWeak函数.png
weak_unregister_no_lock：
.....
if ((entry = weak_entry_for_referent(weak_table, referent))) {
remove_referrer(entry, referrer);
.....
if (empty) {
weak_entry_remove(weak_table, entry);
}
.....
取出entry，移除referrer，referrer是weak指针的引用，这里的weak_table是旧表，旧表里移除weak指针，就是解除了久对象和weak指针的关系。
如果这个empty空了，就从table里去掉。
-
weak_entry_for_referent
size_t begin = hash_pointer(referent) & weak_table->mask; ... while (weak_table->weak_entries[index].referent != referent) { index = (index+1) & weak_table->mask; if (index == begin) bad_weak_table(weak_table->weak_entries); hash_displacement++; if (hash_displacement > weak_table->max_hash_displacement) { return nil; } }从weak_table_t里面取出entry，用了hash表的逻辑:
- hash_pointer也是使用指针地址，映射到一个索引。
&weak_table->mask这个操作是？这个mask实际值是表的size-1,而size是2的n次方方式扩张的，所以mask的形式就1111 1111 1111这种，索引和mask位与之后的值必定就落在了[0, size]范围内。简洁高效，牛逼！ - index都取到了，为什么还要while循环？因为hash函数也会重合的，如果index1的位置已经有人占了，又来一个人要占index1怎么办？往后挪，直到找到一个空位置。所以hash函数得到的index和实际位置有那么一点的偏差。
- hash_displacement是在存入数据的时候记录了最大的偏差值，有这个做把控，偏移超过了这个值肯定是没有了。
- hash_pointer也是使用指针地址，映射到一个索引。
-
remove_referrer
if (! entry->out_of_line()) {
for (size_t i = 0; i < WEAK_INLINE_COUNT; i++) {
if (entry->inline_referrers[i] == old_referrer) {
entry->inline_referrers[i] = nil;
return;
}
}
.....
size_t begin = w_hash_pointer(old_referrer) & (entry->mask);
....
while (entry->referrers[index] != old_referrer) {
index = (index+1) & entry->mask;
if (index == begin) bad_weak_table(entry);
hash_displacement++;
if (hash_displacement > entry->max_hash_displacement) {
.....
objc_weak_error();
return;
}
}
weak_entry_t有个奇怪的地方就是里面有个union:
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];
};
};
这两个东西都是用来存储指向这个对象的所有weak指针的，但是是不同时期使用的，到weak指针在4（WEAK_INLINE_COUNT）个以内的时候，用数组inline_referrers,超过用weak_referrer_t，这个还是hash表。
我的理解是这是为了性能考虑。一般情况，就一两个weak指针会指向同一个对象，用数组管理，存取快。但是也得允许N多weak指针指向同一个对象，WEAK_INLINE_COUNT不可能无限大。感受到了一点空时间、分阶段处理的思想。
weak_referrer_t的存取跟上面weak_table_t一样。
out_of_line是用来判断是否超过数组个数的，就是它用来做两种方案的切换：
bool out_of_line() {
return (out_of_line_ness == REFERRERS_OUT_OF_LINE);
}
out_of_line_ness是否被设置了REFERRERS_OUT_OF_LINE这个标识。这个标识的值实际是2。注释里有一段话：
// out_of_line_ness field overlaps with the low two bits of inline_referrers[1].
// inline_referrers[1] is a DisguisedPtr of a pointer-aligned address.
// The low two bits of a pointer-aligned DisguisedPtr will always be 0b00
// (disguised nil or 0x80..00) or 0b11 (any other address).
// Therefore out_of_line_ness == 0b10 is used to mark the out-of-line state.
因为union的关系，out_of_line_ness的内存位置对应的就是数组inline_referrers里第二个（weak_referrer_t和weak_referrer_t *都是8个字节）。根据这段注释，weak_referrer_t的数据的二进制结尾要么是00要么是11，不会是10，所以用10来做标识。
如果只使用inline_referrers，那么out_of_line_ness读取出来就要么是00要么是11，所以如果读出来是10，也就是十进制2，就是使用hash表的referrers。
我没搞懂的是为什么weak_referrer_t的结尾不会是10。
weak_register_no_lock
这个函数和weak_unregister_no_lock几乎就是反操作了：
weak_entry_t *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);
}
- weak_grow_maybe+weak_entry_insert对应weak_entry_remove
- append_referrer对应remove_referrer
总结
- 使用hash表把对象和所有指向它的weak指针关联起来，等这个对象dealloc的时候，把这些weak指针拿出来，全部设置成nil。
- 3层表：side table+weak table--->weak entry---> referrers + inline_referrers
- hash表的使用逻辑
- referrers和inline_referrers的切换
网友评论