我們看看上面步驟中的5步具體調(diào)用

static weak_entry_t *
weak_entry_for_referent(weak_table_t *weak_table, objc_object *referent)
{
    assert(referent);

    weak_entry_t *weak_entries = weak_table->weak_entries;

    if (!weak_entries) return nil;
    ///位置  散列表
    size_t index = hash_pointer(referent) & weak_table->mask;
    size_t hash_displacement = 0;
    ///判斷相等不相等查找過程
    while (weak_table->weak_entries[index].referent != referent) {
        index = (index+1) & weak_table->mask;
        hash_displacement++;
        if (hash_displacement > weak_table->max_hash_displacement) {
            return nil;
        }
    }
    
    return &weak_table->weak_entries[index];
}

1. 要是weak_table_t 中的weak_entries 變量是nil ，返回nil(沒有創(chuàng)建weak_entry_t 結(jié)構(gòu)體)
   2.根據(jù)真實(shí)對象指針referent 與weak_table_t 的mask 獲取一個(gè)位置index。
   3.查詢 從index 的位置開始循環(huán)查詢weak_entry_t 對象是否包含真實(shí)對象的指針，要是所有的的weak_entry_t 都不包含，返回nil（說明還沒有弱指針指向這個(gè)對象）。有就返回這個(gè)weak_entry_t 結(jié)構(gòu)體。

接著我們看看查詢到weak_entry_t 調(diào)用append_referrer 如何存入弱指針的

/** 
 * Add the given referrer to set of weak pointers in this entry.
 * Does not perform duplicate checking (b/c weak pointers are never
 * added to a set twice). 
 *
 * @param entry The entry holding the set of weak pointers. 
 * @param new_referrer The new weak pointer to be added.
 */

static void append_referrer(weak_entry_t *entry, objc_object **new_referrer)
{
    if (! entry->out_of_line) {
        // Try to insert inline.
        for (size_t i = 0; i < WEAK_INLINE_COUNT; i++) {
            if (entry->inline_referrers[i] == nil) {
                entry->inline_referrers[i] = new_referrer;
                return;
            }
        }

        // Couldn't insert inline. Allocate out of line.
        weak_referrer_t *new_referrers = (weak_referrer_t *)
            calloc(WEAK_INLINE_COUNT, sizeof(weak_referrer_t));
        // This constructed table is invalid, but grow_refs_and_insert
        // will fix it and rehash it.
        for (size_t i = 0; i < WEAK_INLINE_COUNT; i++) {
            new_referrers[i] = entry->inline_referrers[i];
        }
        entry->referrers = new_referrers;
        entry->num_refs = WEAK_INLINE_COUNT;
        entry->out_of_line = 1;
        entry->mask = WEAK_INLINE_COUNT-1;
        entry->max_hash_displacement = 0;
    }
///一定大于1
    assert(entry->out_of_line);
// 4  >=3
    if (entry->num_refs >= TABLE_SIZE(entry) * 3/4) {
        return grow_refs_and_insert(entry, new_referrer);
    }
    
    ///
    size_t index = w_hash_pointer(new_referrer) & (entry->mask);
    size_t hash_displacement = 0;
    while (entry->referrers[index] != NULL) {
        index = (index+1) & entry->mask;
        hash_displacement++;
    }
    if (hash_displacement > entry->max_hash_displacement) {
        entry->max_hash_displacement = hash_displacement;
    }
    weak_referrer_t &ref = entry->referrers[index];
    ref = new_referrer;
    entry->num_refs++;
}

看這個(gè)函數(shù)，我們要明白下weak_entry_t 結(jié)構(gòu)體每個(gè)成員變量的作用才行，這里分析源碼獲取的。

#define WEAK_INLINE_COUNT 4
struct weak_entry_t {
    DisguisedPtr<objc_object> referent;
    union {
        struct {
            weak_referrer_t *referrers;
            uintptr_t        out_of_line : 1;
            uintptr_t        num_refs : PTR_MINUS_1;
            uintptr_t        mask;
            uintptr_t        max_hash_displacement;
        };
        struct {
            // out_of_line=0 is LSB of one of these (don't care which)
            weak_referrer_t  inline_referrers[WEAK_INLINE_COUNT];
        };
    };
};

• DisguisedPtr<objc_object> referent; 真實(shí)對象地址，相當(dāng)于key
• weak_referrer_t *referrers; 當(dāng)弱引用對象多余4個(gè)的時(shí)候，存入弱引用地址
• uintptr_t out_of_line : 1; 0 代表 我們使用weak_referrer_t inline_referrers[WEAK_INLINE_COUNT]; 存入若引用地址，1 代表我們是用weak_referrer_t *referrers; 指針存入地址。 當(dāng)弱引用的數(shù)量大于4 改指針變成1
• uintptr_t num_refs : PTR_MINUS_1; 記錄當(dāng)前集合存入了多少個(gè)弱引用指針
• uintptr_t mask; 代表最多可以存入多少個(gè)若引用指針。
• uintptr_t max_hash_displacement; 從index位置偏移的位置。
• weak_referrer_t inline_referrers[WEAK_INLINE_COUNT]; 當(dāng)若引用指針少于四個(gè)存入在該變量中

append_referrer 調(diào)用分析

1 首先判斷weak_entry_t 的out_of_line 變量是否是0，不是0 執(zhí)行4，是0 執(zhí)行2.
2 檢查 weak_entry_t 的inline_referrers 指針是否存入四個(gè)值，沒有則將對這個(gè)真實(shí)對象的weak指針new_referrer存入到inline_referrers 中。否則執(zhí)行3
3 要是weak_entry_t 結(jié)構(gòu)體的inline_referrers指針存滿了，那么我們重新分配空間new_referrers，類型是weak_referrer_t，將inline_referrers 數(shù)據(jù)存入到new_referrers 指針對應(yīng)的地址，然后將weak_entry_t 結(jié)構(gòu)體的referrers指向new_referrers ，同時(shí)，將weak_entry_t 結(jié)構(gòu)體的num_refs 賦值為WEAK_INLINE_COUNT（宏定義，數(shù)值4），將out_of_line 更新為1 （說明指針存在結(jié)構(gòu)體weak_entry_t的referrers中），weak_entry_t 的mask 是WEAK_INLINE_COUNT -1.（因?yàn)橄聵?biāo)是0開始的），這時(shí)候還沒有便宜，weak_entry_t的max_hash_displacement = 0；
4 到這里說明對該對象的weak指針已經(jīng)多于4個(gè)了。判斷要是已經(jīng)存入的指針是總體指針的75%。說明存儲(chǔ)weak指針的空間不足，需要重新分配內(nèi)存，這里調(diào)用grow_refs_and_insert方法實(shí)現(xiàn)。要是空間充足，那么調(diào)用 5
5 .獲取new_referrer 的在 weak_entry_t mask范圍內(nèi)的index,查找該位置是否已經(jīng)被存入值了。存入了值，就index +1 ，hash_displacement 累加1，繼續(xù)執(zhí)行5 。直到找到空的位置為止。
6 將hash_displacement 寫入到weak_entry_t 結(jié)構(gòu)體的max_hash_displacement
7 將數(shù)據(jù)存入想應(yīng)的index，讓num_refs 計(jì)數(shù)加1。

我們接著看看第四步調(diào)用的grow_refs_and_insert 方法，擴(kuò)展weak指針空間

__attribute__((noinline, used))
static void grow_refs_and_insert(weak_entry_t *entry, 
                                 objc_object **new_referrer)
{
    assert(entry->out_of_line);
///4
    size_t old_size = TABLE_SIZE(entry);
    ///8
    size_t new_size = old_size ? old_size * 2 : 8;
/// 4
    size_t num_refs = entry->num_refs;
    /// 4
    weak_referrer_t *old_refs = entry->referrers;
    ///7
    entry->mask = new_size - 1;
    /// 8
    entry->referrers = (weak_referrer_t *)
        calloc(TABLE_SIZE(entry), sizeof(weak_referrer_t));
    
    entry->num_refs = 0;
    entry->max_hash_displacement = 0;
    
    for (size_t i = 0; i < old_size && num_refs > 0; i++) {
        if (old_refs[i] != nil) {
            append_referrer(entry, old_refs[i]);
            num_refs--;
        }
    }
    // Insert
    append_referrer(entry, new_referrer);
    if (old_refs) free(old_refs);
}

調(diào)用邏輯分析

1.獲取weak_entry_t 結(jié)構(gòu)體的mask 數(shù)量，賦值給old_size
2.獲取new_size的大小，是old_size大小的兩倍。
3.獲取 weak_entry_t 結(jié)構(gòu)體的num_refs ，意思是當(dāng)前存入的指針數(shù)量，賦值給num_refs

4. 獲取weak_entry_t 結(jié)構(gòu)體 referrers ，保存在old_refs 中，
5. 重新寫入weak_entry_t 的mask大小，值是new_size-1.(比原來擴(kuò)大兩倍了)
   6.給weak_entry_t 的referrers 重新分配空間，數(shù)量是new_size 大小個(gè)weak_referrer_t空間
   7 因?yàn)樾路峙淇臻g，設(shè)置weak_entry_t結(jié)構(gòu)體的num_refs 是0,weak_entry_t結(jié)構(gòu)體的max_hash_displacement 是0
   8.調(diào)用append_referrer 將老的指針寫入到weak_entry_t結(jié)構(gòu)體的referrers 中
   9 將新的new_referrer 寫入到weak_entry_t結(jié)構(gòu)體的referrers 中

回到函數(shù)weak_register_no_lock中，我們分析下當(dāng)如果在weak_table_t 表中沒有找到weak_entry_t結(jié)構(gòu)體的時(shí)候，我們調(diào)用的函數(shù)

static void weak_grow_maybe(weak_table_t *weak_table)
{
    size_t old_size = TABLE_SIZE(weak_table);

    // Grow if at least 3/4 full.
    if (weak_table->num_entries >= old_size * 3 / 4) {
        weak_resize(weak_table, old_size ? old_size*2 : 64);
    }
}

1 獲取weak_table_t 的mask
2 查看weak_table_t 的空間大小如果不足75%.那么擴(kuò)展空間兩倍。實(shí)現(xiàn)和weak_entry_t 擴(kuò)展對象空間一樣。不做詳細(xì)講解了。

看到這里我想大概weak指針如何存入的應(yīng)該明白了。我們繪制下weak指針的存入結(jié)構(gòu)。
見圖

image.png

存入順序是
1.根據(jù)對象obj獲取stripedMap 中的 所對應(yīng)的SideTable 結(jié)構(gòu)體
2.根據(jù)對象obj 獲取SideTable 中weak_table_t 結(jié)構(gòu)體下 對應(yīng)的weak_entry_t結(jié)構(gòu)體，所有關(guān)于obj對象的弱指針都存放在該weak_entry_t結(jié)構(gòu)體里面。
3.將weak指針存入到weak_entry_t 下的weak_referrer_t 中

接下來我們看看如何獲取weak指針

void
weak_unregister_no_lock(weak_table_t *weak_table, id referent_id, 
                        id *referrer_id)
{
    
    objc_object *referent = (objc_object *)referent_id;
    objc_object **referrer = (objc_object **)referrer_id;

    weak_entry_t *entry;

    if (!referent) return;

    if ((entry = weak_entry_for_referent(weak_table, referent))) {
        remove_referrer(entry, referrer);
        bool empty = true;
        if (entry->out_of_line  &&  entry->num_refs != 0) {
            empty = false;
        }
        else {
            for (size_t i = 0; i < WEAK_INLINE_COUNT; i++) {
                if (entry->inline_referrers[i]) {
                    empty = false; 
                    break;
                }
            }
        }

        if (empty) {
            weak_entry_remove(weak_table, entry);
        }
    }

    // Do not set *referrer = nil. objc_storeWeak() requires that the 
    // value not change.
}

調(diào)用順序如下

1. referent指向真是對象
   2.referrer 指向weak指針對象
   3 如果referent 是nil 就返回
   4 從weak_table_t 表中根據(jù)真實(shí)對象（referent）獲取到對應(yīng)的weak_entry_t 結(jié)構(gòu)體，沒有就直接結(jié)束了。
2. 找到了真是對象對應(yīng)的weak_entry_t結(jié)構(gòu)體，那么調(diào)用remove_referrer， 刪除 weak指針。（具體怎么刪除下面分析）。
   6這里判斷weak_entry_t 的out_of_line =1 并且weak_entry_t的num_refs不是0，說明還有weak指針。不要?jiǎng)h除這個(gè)真實(shí)對象對應(yīng)的weak_entry_t結(jié)構(gòu)體
   7要是weak_entry_t 的out_of_line=0 ，我們知道對象存入在weak_entry_t 的inline_referrers中，檢查weak_entry_t 的inline_referrers 的是否是nil，如果是空那么就刪除掉真實(shí)對象（referent）對應(yīng)的weak_entry_t結(jié)構(gòu)體

看到這里其實(shí)就是我們存入的逆順序刪除而已。
上面的函數(shù)只是真正的刪除了weak_entry_t 結(jié)構(gòu)體而沒有對weak指針刪除，這里我們再看看真正weak指針的刪除。

static void remove_referrer(weak_entry_t *entry, objc_object **old_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;
            }
        }
        _objc_inform("Attempted to unregister unknown __weak variable "
                     "at %p. This is probably incorrect use of "
                     "objc_storeWeak() and objc_loadWeak(). "
                     "Break on objc_weak_error to debug.\n", 
                     old_referrer);
        objc_weak_error();
        return;
    }

    size_t index = w_hash_pointer(old_referrer) & (entry->mask);
    size_t hash_displacement = 0;
    while (entry->referrers[index] != old_referrer) {
        index = (index+1) & entry->mask;
        hash_displacement++;
        if (hash_displacement > entry->max_hash_displacement) {
            _objc_inform("Attempted to unregister unknown __weak variable "
                         "at %p. This is probably incorrect use of "
                         "objc_storeWeak() and objc_loadWeak(). "
                         "Break on objc_weak_error to debug.\n", 
                         old_referrer);
            objc_weak_error();
            return;
        }
    }
    entry->referrers[index] = nil;
    entry->num_refs--;
}

1. 判斷weak_entry_t結(jié)構(gòu)體 的out_of_line = 0 ,那么我們就判斷weak_entry_t 結(jié)構(gòu)體的inline_referrers中是否存在weak指針，存入將該區(qū)域設(shè)置為nil
2. 要是weak_entry_t結(jié)構(gòu)體 的out_of_line = 1 ，那么我們獲取下weak指針對應(yīng)的在 weak_referrer_t *referrers 的index位置。
   3.查詢index 處的weak指針是否和刪除的指針相等，不相等index累加，hash_displacement累加，檢查hash_displacement 是否已經(jīng)超過weak_entry_t 結(jié)構(gòu)體的max_hash_displacement的值，超過就結(jié)束，沒有那么繼續(xù)執(zhí)行3.
   4.查詢到 需要?jiǎng)h除對象的位置，將該位置設(shè)置nil
   5 將weak_entry_t 結(jié)構(gòu)體的num_refs 減去1.（刪除掉一個(gè)指針了）

我們這里已經(jīng)把weak指針的存入和刪除都分析完畢了。

這里還有一點(diǎn)沒說明，就是當(dāng)真實(shí)對象釋放掉了。如何清理對象所在的weak指針。
當(dāng)對象釋放掉的時(shí)候，會(huì)調(diào)用到對象的dealloc方法。dealloc方法中會(huì)調(diào)用到這個(gè)方法.void
weak_clear_no_lock(weak_table_t *weak_table, id referent_id) 將對象所對應(yīng)的weak表清除掉

void 
weak_clear_no_lock(weak_table_t *weak_table, id referent_id) 
{
    objc_object *referent = (objc_object *)referent_id;

    weak_entry_t *entry = weak_entry_for_referent(weak_table, referent);
    if (entry == nil) {
        /// XXX shouldn't happen, but does with mismatched CF/objc
        //printf("XXX no entry for clear deallocating %p\n", referent);
        return;
    }

    // zero out references
    weak_referrer_t *referrers;
    size_t count;
    
    if (entry->out_of_line) {
        referrers = entry->referrers;
        count = TABLE_SIZE(entry);
    } 
    else {
        referrers = entry->inline_referrers;
        count = WEAK_INLINE_COUNT;
    }
    
    for (size_t i = 0; i < count; ++i) {
        objc_object **referrer = referrers[i];
        if (referrer) {
            if (*referrer == referent) {
                *referrer = nil;
            }
            else if (*referrer) {
                _objc_inform("__weak variable at %p holds %p instead of %p. "
                             "This is probably incorrect use of "
                             "objc_storeWeak() and objc_loadWeak(). "
                             "Break on objc_weak_error to debug.\n", 
                             referrer, (void*)*referrer, (void*)referent);
                objc_weak_error();
            }
        }
    }
    
    weak_entry_remove(weak_table, entry);
}

這個(gè)函數(shù)實(shí)現(xiàn)很簡單，不做介紹了。

純手工自己摸索寫的，哪里不對請給個(gè)指正。