只要學過 iOS 的人，都會對 strong、weak、copy等關鍵字應該都會很熟悉。weak 屬性關鍵字就是弱引用，它不會增加引用計數但卻能保證指針的安全訪問，在對象釋放后置為 nil，從而避免錯誤的內存訪問。主要為了解決循環引用的問題。

接下來，我們會從 objc 庫中的 NSObject.mm、 objc-weak.h 以及 objc-weak.mm 文件出發，去具體了解 weak 的實現過程。

weak 的內部結構

Runtime 維護了一個weak表，用于存儲指向某個對象的所有weak指針。weak 表是由單個自旋鎖管理的散列表。
weak表其實是一個hash表，key 是所指對象的指針，value是weak指針的地址（這個地址的值是所指向對象的地址）數組。

在下面涉及的源碼中，我們會看到以下幾個類型：
sideTable、weak_table_t、weak_entry_t 這幾個結構體。

struct SideTable {
    // 自旋鎖，用來保證線程安全
    spinlock_t slock;
    // 引用計數表
    RefcountMap refcnts;
    // weak 表
    weak_table_t weak_table;

    ...
};

SideTable，它用來管理引用計數表和 weak 表，并使用 spinlock_lock 自旋鎖來防止操作表結構時可能的競態條件。它用一個 64*128 大小的uint8_t 靜態數組作為 buffer 來保存所有的 SideTable 實例。這個結構體里面包含三個變量，第一個spinlock_t,它是一個自旋鎖，用來保證線程安全。第二個RefcountMap,是引用計數表，每個對象的引用計數保存在全局的引用計數表中，一個對象地址對應一個引用計數。第三個就是我們接下來要講的 weak 表，所有的 weak 變量會被加入到全局的weak表中，表的 key 是 weak 修飾的變量指向的對象， value 值就是 weak 修飾的變量。接下來，我們具體看看這個 weak 表

struct weak_table_t {
    // 保存了所有指向指定對象的 weak 指針
    weak_entry_t *weak_entries;
    // 存儲空間，即 entries 的數目
    size_t    num_entries;
    // 參與判斷引用計數輔助量
    uintptr_t mask;
    // hash key 最大偏移量
    uintptr_t max_hash_displacement;
};

這個是全局弱引用的 hash 表。它的作用就是在對象執行 dealloc 的時候將所有指向該對象的 weak 指針的值設為 nil, 避免懸空指針。它使用不定類型對象的地址的 hash 化后的數值作為 key，用 weak_entry_t 類型的結構體對象作為 value。其中 weak_entry_t 是存儲在弱引用表中的一個內部結構體，它負責維護和存儲指向一個對象的所有弱引用 hash 表。其定義如下：

// 存儲在弱引用表中的一個內部結構體
#define WEAK_INLINE_COUNT 4
struct weak_entry_t {
    DisguisedPtr<objc_object> referent;                 // 封裝 objc_object 指針，即 weak 修飾的變量指向的對象
    union {
        struct {
            weak_referrer_t *referrers;
            uintptr_t        out_of_line : 1;           // LSB 最低有效元 當標志位為0時，增加引用表指針緯度，
                                                        // 當其為0的時候， weak_referrer_t 成員將擴展為靜態數組型的 hash table
            uintptr_t        num_refs : PTR_MINUS_1;    // 引用數值，這里記錄弱引用表中引用有效數字，即里面元素的數量
            uintptr_t        mask;
            uintptr_t        max_hash_displacement;     // hash 元素上限閥值
        };
        struct {
            // out_of_line=0 is LSB of one of these (don't care which)
            weak_referrer_t  inline_referrers[WEAK_INLINE_COUNT];     
        };
    };
};

在 weak_entry_t 的結構中， DisguisedPtr<objc_object> 是對 objc_object * 指針及其一些操作進行的封裝，目的就是為了讓它給人看起來不會有內存泄露的樣子，其內容可以理解為對象的內存地址。out_of-line 成員為最低有效位，當其為 0 的時候，weak_referrer_t 成員將擴展為一個靜態數組型的 hash table。其實 weak_referrer 是objc_objcet 的別名，定義如下：typedef objc_object ** weak_referrer_t;

它通過一個二維指針地址偏移，用下標作為 hash 的 key,做成了一個弱引用散列。

下圖，就是weak表結構的總結：
[圖片上傳失敗...(image-149304-1524568324284)]

每個對象的 SideTable 中的 weak_table_t 都是全局 weak 表的入口，以引用計數對象為鍵找到其所記錄的 weak 修飾的對象。weak_entry_t 中的 referrers 有兩種形式，當 out_of_line 為 0 的時候，referrers 是一個靜態數組型的表，數組大小默認為 WEAK_INLINE_COUNT 大小，當 out_of_line 不為 0 的時候，referrers 是一個動態數組，內容隨之增加。

weak 實現原理的過程

當我們用 weak 修飾屬性的時候，它是怎么實現當所引用的對象被廢棄的時候，變量置為 nil，我們來探究一下。

{
    id obj1 = [[NSObject alloc] init];
    id __weak obj2 = obj1;
}

經過編譯期轉換之后,以上代碼會變成下面這樣

id obj2;
objc_initWeak(&obj2, obj1);
objc_destroyWeak(&obj2);

我們發現，weak 修飾符變量是通過 objc_initWeak 函數來初始化的，在變量作用域結束的時候通過 objc_destroyWeak 函數來釋放該變量的。接下來，我們看看這兩個函數的源碼。

id objc_initWeak(id *location, id newObj)
{
    // 查看對象實例是否有效
    // 無效對象直接導致指針釋放
    if (!newObj) {
        *location = nil;
        return nil;
    }
    // 這里傳遞了三個 bool 數值
    // 使用 template 進行常量參數傳遞是為了優化性能
    return storeWeak<false/*old*/, true/*new*/, true/*crash*/>
        (location, (objc_object*)newObj);
}

void objc_destroyWeak(id *location)
{
    (void)storeWeak<true/*old*/, false/*new*/, false/*crash*/>
        (location, nil);
}

對這兩個方法的分析后，我們發現它們都調用了storeWeak 這個函數，但是兩個方法傳入的參數卻稍有不同。
init 方法中，第一個參數為 weak 修飾的變量，第二個參數為引用計數對象。但在 destoryWeak 函數，第一參數依舊為 weak 修飾的變量，第二個參數為 nil。那這塊傳入不同的參數到底代表什么，我們繼續分析 storeWeak 這個函數。

// 更新一個弱引用變量
// 如果 HaveOld 是 true, 變量是個有效值，需要被及時清理。變量可以為 nil。
// 如果 HaveNew 是 true, 需要一個新的 value 來替換變量。變量可以為 nil
// 如果crashifdeallocation 是 ture ，那么如果 newObj 是 deallocating，或者 newObj 的類不支持弱引用，則該進程就會停止。
// 如果crashifdeallocation 是 false，那么 nil 會被存儲。

template <bool HaveOld, bool HaveNew, bool CrashIfDeallocating>
static id storeWeak(id *location, objc_object *newObj)
{
    assert(HaveOld  ||  HaveNew);
    if (!HaveNew) assert(newObj == nil);

    Class previouslyInitializedClass = nil;
    id oldObj;
    
    // 創建新舊散列表
    SideTable *oldTable;
    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:
    if (HaveOld) {
    // 如果 HaveOld 為 true ，更改指針，獲得以 oldObj 為索引所存儲的值地址
        oldObj = *location;
        oldTable = &SideTables()[oldObj];
    } else {
        oldTable = nil;
    }
    if (HaveNew) {
    // 獲得以 newObj 為索引所存儲的值對象
        newTable = &SideTables()[newObj];
    } else {
        newTable = nil;
    }
    
// 對兩個 table 進行加鎖操作，防止多線程中競爭沖突
    SideTable::lockTwo<HaveOld, HaveNew>(oldTable, newTable);

//  location 應該與 oldObj 保持一致，如果不同，說明當前的 location 已經處理過 oldObj 可是又被其他線程所修改, 保證線程安全，這個判斷用來避免線程沖突重處理問題
    if (HaveOld  &&  *location != oldObj) {
        SideTable::unlockTwo<HaveOld, HaveNew>(oldTable, newTable);
        goto retry;
    }

    // Prevent a deadlock between the weak reference machinery
    // and the +initialize machinery by ensuring that no 
    // weakly-referenced object has an un-+initialized isa.
    // 防止弱引用之間發生死鎖，并且通過 +initialize 初始化構造器保證所有弱引用的 isa 非空指向
    if (HaveNew  &&  newObj) {
        // 獲得新對象的 isa 指針
        Class cls = newObj->getIsa();
        // 判斷 isa 非空且已經初始化
        if (cls != previouslyInitializedClass  &&  
            !((objc_class *)cls)->isInitialized()) 
        {
            // 對兩個表解鎖
            SideTable::unlockTwo<HaveOld, HaveNew>(oldTable, newTable);
            _class_initialize(_class_getNonMetaClass(cls, (id)newObj));

            // If this class is finished with +initialize then we're good.
            // If this class is still running +initialize on this thread 
            // (i.e. +initialize called storeWeak on an instance of itself)
            // then we may proceed but it will appear initializing and 
            // not yet initialized to the check above.
            // Instead set previouslyInitializedClass to recognize it on retry.
            // 如果該類已經完成執行 +initialize 方法是最好的，如果該類 + initialize 在線程中，例如 +initialize 正在調用storeWeak 方法，那么則需要手動對其增加保護策略，并設置 previouslyInitializedClass 指針進行標記然后重新嘗試
            previouslyInitializedClass = cls;

            goto retry;
        }
    }

    // Clean up old value, if any. 清除舊值
    if (HaveOld) {
        weak_unregister_no_lock(&oldTable->weak_table, oldObj, location);
    }

    // Assign new value, if any. 分配新值
    if (HaveNew) {
        newObj = (objc_object *)weak_register_no_lock(&newTable->weak_table, 
                                                      (id)newObj, location, 
                                                      CrashIfDeallocating);
        // weak_register_no_lock returns nil if weak store should be rejected
        // 如果弱引用被釋放則該方法返回 nil
        // Set is-weakly-referenced bit in refcount table.
        // 在引用計數表中設置弱引用標記位
        if (newObj  &&  !newObj->isTaggedPointer()) {
            newObj->setWeaklyReferenced_nolock();
        }

        // Do not set *location anywhere else. That would introduce a race.
        *location = (id)newObj;
    }
    else {
        // No new value. The storage is not changed.
    }
    
    SideTable::unlockTwo<HaveOld, HaveNew>(oldTable, newTable);

    return (id)newObj;
}

以上就是 store_weak 這個函數的實現，它主要做了以下幾件事：

• 聲明了新舊散列表指針，因為 weak 修飾的變量如果之前已經指向一個對象，然后其再次改變指向另一個對象，那么按理來說我們需要釋放舊對象中該 weak 變量的記錄，也就是要將舊記錄刪除，然后在新記錄中添加。這里的新舊散列表就是這個作用。
• 根據新舊變量的地址獲取相應的 SideTable
• 對兩個表進行加鎖操作，防止多線程競爭沖突
• 進行線程沖突重處理判斷
• 判斷其 isa 是否為空，為空則需要進行初始化
• 如果存在舊值，調用 weak_unregister_no_lock 函數清除舊值
• 調用 weak_register_no_lock 函數分配新值
• 解鎖兩個表，并返回第二參數

初始化弱引用對象流程一覽

弱引用的初始化，從上文的分析可以看出，主要的操作部分就是在弱引用表的取鍵、查詢散列、創建弱引用等操作，可以總結出如下的流程圖：

image

舊對象解除注冊操作 weak_unregister_no_lock

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.
}

該方法主要作用是將舊對象在 weak_table 中接觸 weak 指針的對應綁定。根據函數名，稱之為解除注冊操作。
來看看這個函數的邏輯。首先參數是 weak_table_t 表，鍵和值。聲明 weak_entry_t 變量，如果key，也就是引用計數對象為空，直接返回。根據全局入口表和鍵獲取對應的 weak_entry_t 對象，也就是 weak 表記錄。獲取到記錄后，將記錄表以及 weak 對象作為參數傳入 remove_referrer 函數中，這個函數就是解除操作。然后判斷這個 weak 記錄是否為空，如果為空，從全局記錄表中清除相應的引用計數對象的 weak 記錄表。

接下來，我們了解一下，如何獲取這個 weak_entry_t 這個變量。

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];
}

這個函數的邏輯就是先獲取全局 weak 表入口，然后將引用計數對象的地址進行 hash 化后與 weak_table->mask 做與操作，作為下標，在全局 weak 表中查找，若找到，返回這個對象的 weak 記錄表，若沒有，返回nil。

再來了解一下解除對象的函數：

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--;
}

這個函數傳入的是 weak 對象，當 out_of_line 為0 時，遍歷數組，找到對應的對象，置nil，如果未找到，報錯并返回。當 out_of_line 不為0時，根據對象的地址 hash 化并和 mask 做與操作作為下標，查找相應的對象，若沒有，報錯并返回，若有，相應的置為 nil，并減少元素數量，即 num_refs 減 1。

新對象添加注冊操作 weak_register_no_lock

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;
    objc_object **referrer = (objc_object **)referrer_id;

    if (!referent  ||  referent->isTaggedPointer()) return referent_id;

    // ensure that the referenced object is viable
    bool deallocating;
    if (!referent->ISA()->hasCustomRR()) {
        deallocating = referent->rootIsDeallocating();
    }
    else {
        BOOL (*allowsWeakReference)(objc_object *, SEL) = 
            (BOOL(*)(objc_object *, SEL))
            object_getMethodImplementation((id)referent, 
                                           SEL_allowsWeakReference);
        if ((IMP)allowsWeakReference == _objc_msgForward) {
            return nil;
        }
        deallocating =
            ! (*allowsWeakReference)(referent, SEL_allowsWeakReference);
    }

    if (deallocating) {
        if (crashIfDeallocating) {
            _objc_fatal("Cannot form weak reference to instance (%p) of "
                        "class %s. It is possible that this object was "
                        "over-released, or is in the process of deallocation.",
                        (void*)referent, object_getClassName((id)referent));
        } else {
            return nil;
        }
    }

    // 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;
        new_entry.referent = referent;
        new_entry.out_of_line = 0;
        new_entry.inline_referrers[0] = referrer;
        for (size_t i = 1; i < WEAK_INLINE_COUNT; i++) {
            new_entry.inline_referrers[i] = nil;
        }

        weak_grow_maybe(weak_table);
        weak_entry_insert(weak_table, &new_entry);
    }

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

    return referent_id;
}

一大堆 if-else, 主要是為了判斷該對象是不是 taggedPoint 以及是否正在調用 dealloca 等。下面操作開始，同樣是先獲取 weak 表記錄，如果獲取到，則調用 append_referrer 插入對象，若沒有，則新建一個 weak 表記錄，默認為 out_of_line，然后將新對象放到 0 下標位置，其他位置置為 nil 。下面兩個函數 weak_grow_maybe 是用來判斷是否需要重申請內存重 hash，weak_entry_insert 函數是用來將新建的 weak 表記錄插入到全局 weak 表中。插入時同樣是以對象地址的 hash 化和 mask 值相與作為下標來記錄的。

接下來看看 append_referrer 函數，源代碼如下：

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;
    }

    assert(entry->out_of_line);

    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++;
}

當 out_of_line 為 0，并且靜態數組里面還有位置存放，那么直接存放并返回。如果沒有位置存放，則升級為動態數組，并加入。如果 out_of_line 不為 0，先判斷是否需要擴容，然后同樣的，使用對象地址的 hash 化和 mask 做與操作作為下標，找到相應的位置并插入。

對象的銷毀以及 weak 的置 nil 實現

釋放時，調用clearDeallocating函數。clearDeallocating 函數首先根據對象地址獲取所有weak指針地址的數組，然后遍歷這個數組把其中的數據設為nil，最后把這個entry從weak表中刪除，最后清理對象的記錄。

當weak引用指向的對象被釋放時，又是如何去處理weak指針的呢？當釋放對象時，其基本流程如下：

• 調用 objc_release
• 因為對象的引用計數為0，所以執行dealloc
• 在dealloc 中，調用了_objc_rootDealloc 函數
• 在 _objc_rootDealloc 中，調用了 objec_dispose 函數
• 調用objc_destructInstance
• 最后調用 objc_clear_deallocating

objc_clear_deallocating的具體實現如下：

void objc_clear_deallocating(id obj) 
{
    assert(obj);
    assert(!UseGC);

    if (obj->isTaggedPointer()) return;
    obj->clearDeallocating();
}

這個函數只是做一些判斷以及更深層次的函數調用，

void objc_object::sidetable_clearDeallocating()
{
    SideTable& table = SideTables()[this];

    // clear any weak table items
    // clear extra retain count and deallocating bit
    // (fixme warn or abort if extra retain count == 0 ?)
    table.lock();
    // 迭代器
    RefcountMap::iterator it = table.refcnts.find(this);
    if (it != table.refcnts.end()) {
        if (it->second & SIDE_TABLE_WEAKLY_REFERENCED) {
            weak_clear_no_lock(&table.weak_table, (id)this);
        }
        table.refcnts.erase(it);
    }
    table.unlock();
}

我們可以看到，在這個函數中，首先取出對象對應的SideTable實例，如果這個對象有關聯的弱引用，則調用weak_clear_no_lock來清除對象的弱引用信息,我們在來深入一下，

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);
}

這個函數根據 out_of_line 的值，取得對應的記錄表，然后根據引用計數對象，將相應的 weak 對象置 nil。最后清除相應的記錄表。

通過上面的描述，我們基本能了解一個weak引用從生到死的過程。從這個流程可以看出，一個weak引用的處理涉及各種查表、添加與刪除操作，還是有一定消耗的。所以如果大量使用__weak變量的話，會對性能造成一定的影響。那么，我們應該在什么時候去使用weak呢？《Objective-C高級編程》給我們的建議是只在避免循環引用的時候使用__weak修飾符。