读读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