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

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中情况:

  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新对象

它的作用就是解除旧对象关系,和新对象建立联系。

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是在存入数据的时候记录了最大的偏差值,有这个做把控,偏移超过了这个值肯定是没有了。
  • 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的切换

推荐阅读更多精彩内容