總的來說：

weak_table 是 SideTable 的一個(gè)成員變量，避免直接操作 weak_table。

根據(jù)當(dāng)前對(duì)象指針，做一定偏移，找到對(duì)應(yīng)的數(shù)組（SideTables）索引，再根據(jù)索引取>出這個(gè) SideTable 。
你可以理解為key是對(duì)象指針，value就是 SideTable。
也就是說，一個(gè)對(duì)象，對(duì)應(yīng)一個(gè) SideTable，一個(gè) SideTable 對(duì)應(yīng)一個(gè) weak_table，
一個(gè)weak_table 存儲(chǔ)一個(gè)哈希表，key：當(dāng)前對(duì)象，value：weak 引用

下面的代碼，都已經(jīng)去掉了無關(guān)緊要的，留下的都是重點(diǎn)部分：

首先看一下 SideTables , 實(shí)際上內(nèi)部維護(hù)了一個(gè)Map（key：指針 —— value：SideTable）

array ：存儲(chǔ)的就是SideTable 數(shù)組
indexForPointer 方法，這個(gè)方法根據(jù)實(shí)例的指針地址，返回它在 array 中的索引，從而>找到 SideTable
由此我們知道：每個(gè)實(shí)例，SideTables 都會(huì)幫這個(gè)實(shí)例存儲(chǔ)一個(gè)SideTable

static objc::ExplicitInit<StripedMap<SideTable>> SideTablesMap;

static StripedMap<SideTable>& SideTables() {
    return SideTablesMap.get();
}

StripedMap<T> is a map of [void* ： T]

class StripedMap {
    enum { StripeCount = 8 };

    PaddedT array[StripeCount];

    static unsigned int indexForPointer(const void *p) {
        uintptr_t addr = reinterpret_cast<uintptr_t>(p);
        return ((addr >> 4) ^ (addr >> 9)) % StripeCount;
    }

 public:
    T& operator[] (const void *p) { 
        return array[indexForPointer(p)].value; 
    }
    const T& operator[] (const void *p) const { 
        return const_cast<StripedMap<T>>(this)[p]; 
    }
    
#if DEBUG
    StripedMap() {
        // Verify alignment expectations.
        uintptr_t base = (uintptr_t)&array[0].value;
        uintptr_t delta = (uintptr_t)&array[1].value - base;
        ASSERT(delta % CacheLineSize == 0);
        ASSERT(base % CacheLineSize == 0);
    }
#else
    constexpr StripedMap() {}
#endif
};

每個(gè)SideTable 都存儲(chǔ)了一個(gè) weak_table 、引用計(jì)數(shù)的map、以及l(fā)ock

struct SideTable {
    spinlock_t slock;
    RefcountMap refcnts;
    weak_table_t weak_table;

    void lock() { slock.lock(); }
    void unlock() { slock.unlock(); }
    void forceReset() { slock.forceReset(); }
};

然后看weak_table：這是一個(gè)全局的weak 引用表。
weak_entries：存儲(chǔ) weak_entry_t 列表
num_entries ：weak 引用的個(gè)數(shù)
mask ：用來做哈希表的mask

struct weak_table_t {
    weak_entry_t *weak_entries;
    size_t    num_entries;
    uintptr_t mask;
    uintptr_t max_hash_displacement;
};

weak_entry_t: 存儲(chǔ)所有指向?qū)嵗膚eak引用

referent:當(dāng)前實(shí)例對(duì)象指針：object point
inline_referrers: weak 變量指針(weak reference ) 集合，引用低于4個(gè)的時(shí)候，用這個(gè)結(jié)構(gòu)存儲(chǔ)
referrers：weak 變量指針(weak reference ) 集合，大于4個(gè)引用時(shí)候用這個(gè)存儲(chǔ)

這里使用了 union 來共享內(nèi)存，可以節(jié)約內(nèi)存的使用
當(dāng) out_of_line_ness == REFERRERS_OUT_OF_LINE 時(shí)，使用 referrers 來存儲(chǔ)weak >變量引用
當(dāng) out_of_line_ness != REFERRERS_OUT_OF_LINE 時(shí)，使用 inline_referrers 來存>儲(chǔ)weak 變量引用

mask ：一般用指針的地址 & mask 來找到對(duì)應(yīng)的數(shù)組索引，而mask 一般為數(shù)組的長(zhǎng)度

struct weak_entry_t {
    DisguisedPtr<objc_object> referent;
    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];
        };
    };

    bool out_of_line() {
        return (out_of_line_ness == REFERRERS_OUT_OF_LINE);
    }

    weak_entry_t(objc_object *newReferent, objc_object **newReferrer)
        : referent(newReferent)
    {
        inline_referrers[0] = newReferrer;
        for (int i = 1; i < WEAK_INLINE_COUNT; i++) {
            inline_referrers[i] = nil;
        }
    }
};

storeWeak 這個(gè)方法用來存儲(chǔ)新的指向當(dāng)前實(shí)例的 weak 變量。
可以看到，先從 SideTables 拿到對(duì)應(yīng)的 SideTable，
然后調(diào)用 weak_register_no_lock 把 newObj 存到了weak_table 里

static id 
storeWeak(id *location, objc_object *newObj)
{
    SideTable *newTable;

    // Acquire locks for old and new values.
    // Order by lock address to prevent lock ordering problems. 
    // Retry if the old value changes underneath us.
 retry:
    
    newTable = &SideTables()[newObj];
    
    newObj = (objc_object *) weak_register_no_lock(&newTable->weak_table, (id)newObj, location,  crashIfDeallocating);

    // Do not set *location anywhere else. That would introduce a race.
    *location = (id)newObj;

    return (id)newObj;
}

weak_entry_for_referent 這個(gè)方法就不寫了：實(shí)際就是找當(dāng)前實(shí)例對(duì)象所屬的 weak_entry_t

這個(gè)方法是遍歷 weak_table->weak_entries ，然后檢查 weak_entries[index].referent >== referent
如果找到了，就返回 weak_table->weak_entries[index]

接下來我們看另外一個(gè)很重要的方法：append_referrer：

/** 
 * Registers a new (object, weak pointer) pair. Creates a new weak
 * object entry if it does not exist.
 * 
 * @param weak_table The global weak table.
 * @param referent The object pointed to by the weak reference.
 * @param referrer The weak pointer address.
 */
id 
weak_register_no_lock(weak_table_t *weak_table, id referent_id, 
                      id *referrer_id, bool crashIfDeallocating)
{
    objc_object *referent = (objc_object *)referent_id;// 當(dāng)前的實(shí)例對(duì)象指針
    objc_object **referrer = (objc_object **)referrer_id;//weak 變量的指針的指針

    // now remember it and where it is being stored
    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);
    }

    return referent_id;
}

把新的weak 變量引用，加到 entry里：

優(yōu)先使用 inline_referrers 存儲(chǔ) weak 引用
如果inline_referrers 存儲(chǔ)滿了，則把 inline_referrers 拷貝到 referrers 里，并且以后使用 referrers 來存儲(chǔ)，并標(biāo)記：out_of_line_ness = REFERRERS_OUT_OF_LINE; 這樣下次默認(rèn)就使用 referrers 來存儲(chǔ)。

如果存儲(chǔ)的引用數(shù)量超過了 3/4 ，則把 referrers 擴(kuò)容 二倍，再進(jìn)行存儲(chǔ)。

存儲(chǔ)referrers 的階段，先把指針做一定偏移，然后 & mask，找到要存儲(chǔ)在數(shù)組里的位置： index，
如果這個(gè)index 已經(jīng)存儲(chǔ)了值，那么再次偏移、然后 & mask ，遞歸來找，直到找到一個(gè)空的位置為止。
最后把 weak 引用存到這個(gè)數(shù)組的 index 位置里。

當(dāng)然，移除 weak 引用，和 append 引用是相似的道理，這里就不再贅述了。

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_ness = REFERRERS_OUT_OF_LINE;
        entry->mask = WEAK_INLINE_COUNT-1;
        entry->max_hash_displacement = 0;
    }


    if (entry->num_refs >= TABLE_SIZE(entry) * 3/4) {
        return grow_refs_and_insert(entry, new_referrer);
    }
    size_t begin = w_hash_pointer(new_referrer) & (entry->mask);
    size_t index = begin;
    size_t hash_displacement = 0;
    while (entry->referrers[index] != nil) {
        hash_displacement++;
        index = (index+1) & entry->mask;
        if (index == begin) bad_weak_table(entry);
    }
    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++;
}