讀讀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的切換