读读objc源码(二)：weak类型指针的实现

weak指针这部分代码写的很好啊，结构清晰，接口定义到关键位置，读取来很舒服。

总体结构

• SideTable包含了引用计数表和weak指针表，大概就是内存管理的总表，SideTable有多张，对象根据内存地址会关联上某一张
• weak_table_t 包含了全部具备weak指针的对象的weak指针信息
• weak_entry_t 对应某一个对象，一个对象可能有多个weak指针，它们做为一个总体存放在这里
• weak_entry_t包含两部分，一个是对象的内存地址，这个至关于key/id的做用，用来识别是对应哪一个对象的；另外一部分就是指向这个对象的全部weak指针。

总体的逻辑就是： 使用hash表把对象和全部指向它的weak指针关联起来，等这个对象dealloc的时候，把这些weak指针拿出来，所有设置成nil。

SideTable

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中状况：

1. weakA = weakB
2. weakA = strongB
3. 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新对象

它的做用就是解除旧对象关系，和新对象创建联系。

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是在存入数据的时候记录了最大的误差值，有这个作把控，偏移超过了这个值确定是没有了。

• 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的切换