iOS開發者都知道，當一個對象被釋放時，所有對這個對象弱引用的指針都會釋放并置為nil，那么系統是如何存儲這些弱引用對象的呢？又是如何在一個對象釋放時，將這些指向即將釋放對象的弱引用的指針置為nil的呢？下面我們通過分析SideTable的結構來進一步了解內存管理的弱引用存儲細節。

結構

在runtime中，有四個數據結構非常重要，分別是SideTables，SideTable，weak_table_t和weak_entry_t。它們和對象的引用計數，以及weak引用相關。

SideTables

下面我們看下SideTables的結構：

static StripedMap<SideTable>& SideTables() {return *reinterpret_cast<StripedMap<SideTable>*>(SideTableBuf); }

reinterpret_cast，是C++里的強制類型轉換符,我們看下SideTableBuf的定義。上面代碼，我們看到StripedMap實際上返回的是一個SideTableBuf對象，那么我們來看下SideTableBuf對象：

//alignas 字節對齊 // SideTableBuf 靜態全局變量 // sizeof(StripedMap<SideTable>) = 4096 //alignas (StripedMap<SideTable>) 是字節對齊的意思，表示讓數組中每一個元素的起始位置對齊到4096的倍數 // 因此下面這句話可以翻譯為 static uint8_t SideTableBuf[4096] alignas(StripedMap<SideTable>) static uint8_t SideTableBuf[sizeof(StripedMap<SideTable>)];

SideTableBuf是一個外部不可見的靜態內存區塊，存儲StripedMap<SideTable>對象。它是內存管理的基礎。

我們接下來在看下StripedMap的結構

enum { CacheLineSize = 64 }; // StripedMap<T> 是一個模板類，根據傳遞的實際參數決定其中 array 成員存儲的元素類型 // 能通過對象的地址，運算出 Hash 值，通過該 hash 值找到對應的 value template<typename T> class StripedMap { #if TARGET_OS_IPHONE && !TARGET_OS_SIMULATORenum { StripeCount = 8 }; #elseenum { StripeCount = 64 }; #endif// PaddedT 為一個結構體struct PaddedT {T value alignas(CacheLineSize);};// array 中存放著8個sidetablePaddedT array[StripeCount];//取得p的哈希值，p就是實例對象的地址static unsigned int indexForPointer(const void *p) {uintptr_t addr = reinterpret_cast<uintptr_t>(p);// 這里根據對象的地址經過左移和異或操作 最終結果 模 8 得到一個0-7的值// 即對應該地址對應array中下標的sidetable中return ((addr >> 4) ^ (addr >> 9)) % StripeCount;}public:// 重寫了[]方法 即通過下標獲取數組中對應下標的值// array[index] = array[indexForPointer(p)].valueT& operator[] (const void *p) { return array[indexForPointer(p)].value; }const T& operator[] (const void *p) const { return const_cast<StripedMap<T>>(this)[p]; } };

StripedMap 是一個以void *為hash key， T為vaule的hash 表。StripedMap的所有T類型數據都被封裝到array中。

綜上我們得出SideTables的機構實際是下圖所示:

SideTable

下面來看下sideTable的結構

struct SideTable {// 保證原子操作的自旋鎖spinlock_t slock;// 引用計數的 hash 表RefcountMap refcnts;// weak 引用全局 hash 表weak_table_t weak_table;SideTable() {memset(&weak_table, 0, sizeof(weak_table));}~SideTable() {_objc_fatal("Do not delete SideTable.");} };

上面是我們簡化后的SideTable結構體，包含了:

• 保證原子屬性的自旋鎖spinlock_t
• 記錄引用計數值的RefcountMap
• 用于存儲對象弱引用的哈希表 weak_table_t

自旋鎖(slock)我們這里就不做過多介紹了,我們先來看下RefcountMap，看下RefcountMap結構

// RefcountMap 是一個模板類 // key,DisguisedPtr<objc_object>類型 // value，size_t類型 // 是否清除為vlaue==0的數據，true typedef objc::DenseMap<DisguisedPtr<objc_object>,size_t,true> RefcountMap;

DenseMap是llvm庫中的類，是一個簡單的二次探測哈希表，擅長支持小的鍵和值。RefcountMap是一個hash map，其key是obj的DisguisedPtr<objc_object>，而value，則是obj對象的引用計數,同時，這個map還有個加強版功能，當引用計數為0時，會自動將對象數據清除。

上面我們知道了，refcnts是用來存放引用計數的，那么我們如何獲取一個對象的引用計數呢？

// 獲取一個對象的retainCount inline uintptr_t objc_object::rootRetainCount() {//優化指針 直接返回if (isTaggedPointer()) return (uintptr_t)this;//沒優化則 到SideTable 讀取sidetable_lock();//isa指針isa_t bits = LoadExclusive(&isa.bits);ClearExclusive(&isa.bits);//啥都沒做if (bits.nonpointer) {//優化過 isa 指針uintptr_t rc = 1 + bits.extra_rc;//計數數量if (bits.has_sidetable_rc) {//bits.has_sidetable_rc標志位為1 表明有存放在sidetable中的引用計數//讀取table的值 相加rc += sidetable_getExtraRC_nolock();}//解鎖sidetable_unlock();return rc;}sidetable_unlock();//：如果沒采用優化的isa指針，則直接返回sidetable中的值return sidetable_retainCount(); }

從上面的代碼我們可以得出:retainCount = isa.extra_rc + sidetable_getExtraRC_nolock,即引用計數=isa指針中存儲的引用計數+sidetable中存儲的引用計數

那么sidetable_getExtraRC_nolock是如何從sideTable中獲取retainCount的呢？ 下面我們來看下這個方法的實現。

size_t objc_object::sidetable_getExtraRC_nolock() {//assert(isa.nonpointer);//key是 this，存儲了每個對象的tableSideTable& table = SideTables()[this];//找到 it 否則返回0RefcountMap::iterator it = table.refcnts.find(this);// 這里返回的it是RefcountMap類型 it == table.refcnts.end() // 表示在sidetable中沒有找到this對應的引用計數則直接返回0if (it == table.refcnts.end()) return 0;// RefcountMap 結構的second值為引用計數值 // DenseMap<DisguisedPtr<objc_object>,size_t,true> RefcountMap;else return it->second >> SIDE_TABLE_RC_SHIFT; }

了解了SideTable的RefcountMap，下面我們接著看另外一個屬性weak_table

weak_table

我們都知道weak_table是對象弱引用map，它記錄了所有弱引用對象的集合。

我們先來看下weak_table_t的定義：

// 全局的弱引用表 struct weak_table_t {// hash數組，用來存儲弱引用對象的相關信息weak_entry_tweak_entry_t *weak_entries;// hash數組中的元素個數size_t num_entries;// hash數組長度-1，會參與hash計算。//（注意，這里是hash數組的長度，而不是元素個數。比如，數組長度可能是64，而元素個數僅存了2個）uintptr_t mask;// 最大哈希偏移值uintptr_t max_hash_displacement; };

weak_entries實質上是一個hash數組，數組中存儲weak_entry_t類型的元素。weak_entry_t的定義如下

/*** The internal structure stored in the weak references table. * It maintains and stores* a hash set of weak references pointing to an object.* If out_of_line_ness != REFERRERS_OUT_OF_LINE then the set* is instead a small inline array.*///inline_referrers數組中可以存放元素的最大個數 如果超過了這個個數就會使用referrers 存放 #define WEAK_INLINE_COUNT 4 // 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. // DisguisedPtr方法返回的hash值得最低2個字節應該是0b00或0b11，因此可以用out_of_line_ness // == 0b10來表明當前是否在使用數組或動態數組來保存引用該對象的列表。 #define REFERRERS_OUT_OF_LINE 2 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;// 用于hash確定動態數組index，值實際上是動態數組空間長度-1（它和num_refs不一樣，// 這里是記錄的是數組中位置的個數，而不是數組中實際存儲的元素個數）。uintptr_t mask;// 最大哈希偏移值uintptr_t max_hash_displacement;};struct {// inline_referrers 數組 當不使用動態數組時使用 最大個數為4weak_referrer_t inline_referrers[WEAK_INLINE_COUNT];};}; }

從上面的介紹我們可以總結SideTables和SideTable以及weak_table_t在層級上的關系圖如下：

上圖是從數據結構的角度來看弱引用的保存,下面我們來看下從垂直方向來看

從上面的總結中我們可以看到，弱引用的存儲實際上一個三級的哈希表，通過一層層的索引找到或者存儲對應的弱引用。那當向weak_table_t中插入或查找某個元素時是如何操作的呢？算法是什么樣的呢？

weak_entry_for_referent

/ 在weak_table中查找所有弱引用referent的對象 static weak_entry_t * weak_entry_for_referent(weak_table_t *weak_table, objc_object *referent) {assert(referent);//獲取這個weak_table_t中所有的弱引用對象weak_entry_t *weak_entries = weak_table->weak_entries;if (!weak_entries) return nil;//hash_pointer 哈希函數 傳入的是 objc_object *key// weak_table->mask = weaktable的容量-1size_t begin = hash_pointer(referent) & weak_table->mask;size_t index = begin;// 哈希沖突次數size_t hash_displacement = 0;// 判斷根據index獲取到的弱引用對象數組中對應的weak_entry_t的弱引用對象是否為// 外部傳入的對象while (weak_table->weak_entries[index].referent != referent) {// 開放地址法解決哈希沖突// & weak_table->mask 是為了在下一個地址仍然沒有找到外部傳入對象時回到第一個對比的位置index = (index+1) & weak_table->mask;if (index == begin)// 對比了所有數據 仍沒有找到 直接報錯bad_weak_table(weak_table->weak_entries);// 哈希沖突次數++hash_displacement++;// 最大哈希偏移值 表示已經遍歷了數組中所有的元素// 沒有找到那么直接返回nilif (hash_displacement > weak_table->max_hash_displacement) {return nil;}}// 直接返回被弱引用的對象return &weak_table->weak_entries[index]; }

上面就是根據對象地址獲取所有弱引用該對象的的數組，基本邏輯都比較清晰，我們在遍歷weak_table->weak_entries中的時候發現判斷是否遍歷完一遍的時候使用的方法

index = (index+1) & weak_table->mask;

假設當前數組長度8，下標分別是0-7，上面weak_table->mask= 7 = 0111。

| 下標 | 計算后結果 | | --- | --- | | index = 0 | index & mask = 0000 & 0111 = 0000 = 0 | | index = 1 | index & mask = 0001 & 0111 = 0001 = 1 | | index = 2 | index & mask = 0010 & 0111 = 0010 = 2 | | index = 3 | index & mask = 0011 & 0111 = 0011 = 3 | | index = 4 | index & mask = 0100 & 0111 = 0100 = 4 | | index = 5 | index & mask = 0101 & 0111 = 0101 = 5 | | index = 6 | index & mask = 0110 & 0111 = 0110 = 6 | | index = 7 | index & mask = 0111 & 0111 = 0111 = 7 | | index = 8 | index & mask = 1000 & 0111 = 0000 = 0 |

看完上面的計算相信大家都明白了這么做的真是意圖了：

if (index == begin)

可以理解為：數組遍歷完成，已經和數組中所有的元素做了對比。

隨著某個對象被越來越多的對象弱引用，那么這個存放弱引用該對象的所有對象的數組也會越來越大。

hash表自動擴容

//weak_table_t擴容 // 參數 weak_table 要擴容的table new_size 目標大小 static void weak_resize(weak_table_t *weak_table, size_t new_size) {//weak_table的容量size_t old_size = TABLE_SIZE(weak_table);// 取出weak_table中存放的所有實體weak_entry_t *old_entries = weak_table->weak_entries;// 新創建一個weak_entry_t類型的數組// 數組的大小是new_size * sizeof(weak_entry_t)weak_entry_t *new_entries = (weak_entry_t *)calloc(new_size, sizeof(weak_entry_t));// 重置weak_table的mask的值weak_table->mask = new_size - 1;// 將weak_table->weak_entries指向新創建的內存區域 注意 此時weak_table中沒有任何數據weak_table->weak_entries = new_entries;// 最大哈希偏移值重置為0weak_table->max_hash_displacement = 0;//weak_table 中存儲實體個數為0weak_table->num_entries = 0; // restored by weak_entry_insert below// 舊數據的搬遷if (old_entries) {weak_entry_t *entry;//old_entries看做數組中第一個元素的地址 由于數組是連續的存儲空間 那么old_entries + old_size = 數組最后一個元素的地址weak_entry_t *end = old_entries + old_size;// 遍歷這些舊數據for (entry = old_entries; entry < end; entry++) {//weak_entry_t的referent(referent是指被弱引用的對象)if (entry->referent) {// 將舊數據搬移到新的結構中weak_entry_insert(weak_table, entry);}}// 釋放所有的舊數據free(old_entries);} }

從上面的代碼中我們可以看到，哈希表的擴容主要分為下面幾個步驟:

• 創建一個局部變量保存當前哈希表中保存的所有弱引用實體
• 新建一個容量是舊哈希表大小2倍的哈希表，同時重置num_entries、max_hash_displacement、weak_entries、mask
• 遍歷之前保存的舊的數據 將數據按照順序依次重新插入的新建的哈希表中
• 釋放舊數據

我們看到將舊數據插入新數據的主要方法是weak_entry_insert，下面我們來仔細介紹下它：

weak_entry_insert

// 向指定的weak_table_t中插入某個對象 // weak_table_t 目標 table // new_entry 被弱引用的對象 static void weak_entry_insert(weak_table_t *weak_table, weak_entry_t *new_entry) {// 取出weak_table中所有弱引用的對象weak_entry_t *weak_entries = weak_table->weak_entries;assert(weak_entries != nil);// 根據new_entry中被弱引用對象地址通過哈希算法 算出 弱引用new_entry->referent的對象存放的indexsize_t begin = hash_pointer(new_entry->referent) & (weak_table->mask);size_t index = begin;size_t hash_displacement = 0;// weak_entries[index].referent 如果不為空 表示已經有while (weak_entries[index].referent != nil) {// 計算下一個要遍歷的indexindex = (index+1) & weak_table->mask;// 遍歷了所有元素發現weak_entries[index].referent 都不為nilif (index == begin)// 直接報錯bad_weak_table(weak_entries);// 哈希沖突次數++hash_displacement++;}// 如果走到這里 表明index位置的元素referent=nil// 直接插入weak_entries[index] = *new_entry;// 實體個數++weak_table->num_entries++;// 最大哈希偏移值大于之前的記錄if (hash_displacement > weak_table->max_hash_displacement) {// 更新最大哈希偏移值weak_table->max_hash_displacement = hash_displacement;} }

插入操作也很簡單，主要分為下面幾個步驟:

• 取出哈希表中所有弱引用對象的數據
• 遍歷第一步取出的所有數據，找到第一個空位置
• 將要插入的實體插入到這個位置，同時更新當前weak_table中弱引用實體個數
• 重置weak_table中最大哈希沖突次數的值

插入的主要邏輯實際上并不復雜，但是我們發現最后一步

// 如果本次哈希偏移值大于之前記錄的最大偏移值 則更新 if (hash_displacement > weak_table->max_hash_displacement) {// 修改最大哈希偏移值weak_table->max_hash_displacement = hash_displacement; }

通過上面的代碼我們發現，假設weak_table的weak_entries最大容量為8,當前存放了3個被弱引用的對象且分別存放在下標為[0,1,2]中，同時要插入的對象new_entry不再weak_entries中，那么經過while循環，hash_displacement = 3。實際上如果在沒有哈希沖突的情況下我們通過hash_pointer得到的index就應該是用來存放new_entry的，但是因為存在哈希沖突，所以后移了3位后才找到合適的位置來存放new_entry，因此hash_displacement也被理解為，本應存放的位置距離實際存放位置的差值。

綜上，我們分析了哈希表中獲取所有弱引用某個對象的對象數組，哈希表擴容方法，以及如何在哈希表中插入一個弱引用對象。

下面我們來看下新增和釋放弱引用對象的方法

objc_initWeak

// 初始化一個weak 弱引用 // 參數location weak指針的地址 newObj weak指針指向的對象 id objc_initWeak(id *location, id newObj) {// 如果弱引用對象為空if (!newObj) {*location = nil;return nil;}// 調用storeWeakreturn storeWeak<DontHaveOld, DoHaveNew, DoCrashIfDeallocating>(location, (objc_object*)newObj); }

• id *location ：weak指針的地址，即weak指針取地址： &weakObj 。它是一個指針的地址。之所以要存儲指針的地址，是因為最后我們要講weak指針指向的內容置為nil，如果僅存儲指針的話，是不能夠完成這個功能的。
• id newObj ：所引用的對象。即例子中的obj 。

從上面我們看出objc_initWeak實際上是調用了storeWeak方法，且方法調用我們可以翻譯為

storeWeak<false, true, true>(location, (objc_object*)newObj)

storeWeak

enum CrashIfDeallocating {DontCrashIfDeallocating = false, DoCrashIfDeallocating = true }; template <HaveOld haveOld, HaveNew haveNew,CrashIfDeallocating crashIfDeallocating> // HaveOld= true weak ptr之前是否已經指向了一個弱引用 // haveNew = true weak ptr是否需要指向一個新引用 // crashIfDeallocating = true 如果被弱引用的對象正在析構，此時再弱引用該對象，是否應該crash // crashIfDeallocating = false 將存儲的數據置為nil // *location 代表weak 指針的地址 // newObj 被weak引用的對象。 static id storeWeak(id *location, objc_object *newObj) {assert(haveOld || haveNew);// 如果沒有新值賦值 判斷newObj 是否為空 否則斷言if (!haveNew)assert(newObj == nil);Class previouslyInitializedClass = nil;id oldObj;SideTable *oldTable;SideTable *newTable;retry:// 如果weak ptr之前弱引用過一個obj，則將這個obj所對應的SideTable取出，賦值給oldTableif (haveOld) {// 根據傳入的地址獲取到舊的值oldObj = *location;// 根據舊值的地址獲取到舊值所存在的SideTableoldTable = &SideTables()[oldObj];} else {// 如果weak ptr之前沒有弱引用過一個obj，則oldTable = niloldTable = nil;}// 是否有新值 如果有if (haveNew) {// 如果weak ptr要weak引用一個新的obj，則將該obj對應的SideTable取出，賦值給newTablenewTable = &SideTables()[newObj];} else {// 如果weak ptr不需要引用一個新obj，則newTable = nilnewTable = nil;}// 加鎖管理一對 side tables，防止多線程中競爭沖突SideTable::lockTwo<haveOld, haveNew>(oldTable, newTable);// location 應該與 oldObj 保持一致，如果不同，說明當前的 location 已經處理過 oldObj 可是又被其他線程所修改if (haveOld && *location != oldObj) {// 解鎖后重試SideTable::unlockTwo<haveOld, haveNew>(oldTable, newTable);goto retry;}// 保證弱引用對象的 isa 都被初始化，防止弱引用和 +initialize 之間發生死鎖，// 也就是避免 +initialize 中調用了 storeWeak 方法，而在 storeWeak 方法中 weak_register_no_lock// 方法中用到對象的 isa 還沒有初始化完成的情況if (haveNew && newObj) {Class cls = newObj->getIsa();// 如果cls還沒有初始化，先初始化，再嘗試設置weakif (cls != previouslyInitializedClass && !((objc_class *)cls)->isInitialized()) {SideTable::unlockTwo<haveOld, haveNew>(oldTable, newTable);// 發送 +initialize 消息到未初始化的類_class_initialize(_class_getNonMetaClass(cls, (id)newObj));// 如果該類還沒有初始化完成，例如在 +initialize 中調用了 storeWeak 方法，// 也就是會進入這里面，進而設置 previouslyInitializedClass 以在重試時識別它// 這里記錄一下previouslyInitializedClass， 防止改if分支再次進入previouslyInitializedClass = cls;// 重新獲取一遍newObj，這時的newObj應該已經初始化過了goto retry;}}// 如果weak_ptr之前弱引用過別的對象oldObj，則調用weak_unregister_no_lock，在oldObj的weak_entry_t中移除該weak_ptr地址if (haveOld) {weak_unregister_no_lock(&oldTable->weak_table, oldObj, location);}// 如果weak_ptr需要弱引用新的對象newObjif (haveNew) {// (1) 調用weak_register_no_lock方法，將weak ptr的地址記錄到newObj對應的weak_entry_t中newObj = (objc_object *)weak_register_no_lock(&newTable->weak_table, (id)newObj, location, crashIfDeallocating);// (2) 更新newObj的isa的weakly_referenced bit標志位if (newObj && !newObj->isTaggedPointer()) {newObj->setWeaklyReferenced_nolock();}// （3）*location 賦值，也就是將weak ptr直接指向了newObj。可以看到，這里并沒有將newObj的引用計數+1// 將weak ptr指向object*location = (id)newObj;}else {// No new value. The storage is not changed.}// 解鎖，其他線程可以訪問oldTable, newTable了SideTable::unlockTwo<haveOld, haveNew>(oldTable, newTable);// 返回newObj，此時的newObj與剛傳入時相比，weakly-referenced bit位置1return (id)newObj; }

storeWeak方法有點長，這也是weak引用的核心實現部分。其實核心也就實現了兩個功能：

將weak指針的地址location存入到obj對應的weak_entry_t的數組（鏈表）中，用于在obj析構時，通過該數組（鏈表）找到所有其weak指針引用，并將指針指向的地址（location）置為nil。

如果啟用了isa優化，則將obj的isa_t的weakly_referenced位置1。置位1的作用主要是為了標記obj被weak引用了，當dealloc時，runtime會根據weakly_referenced標志位來判斷是否需要查找obj對應的weak_entry_t，并將引用置為nil。

上面的方法中，我們看到插入新值的方法為weak_register_no_lock,清除舊值的方法為weak_unregister_no_lock,下面我們來看下這兩個方法：

weak_register_no_lock

/ 添加對某個對象的新的弱引用指針 // weak_table 目標被弱引用對象所存儲的表 // referent_id 被所引用的對象 // referrer_id 要被添加的弱引用指針 // crashIfDeallocating 如果對象正在被釋放時是否崩潰 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;// 如果referent為nil 或 referent 采用了TaggedPointer計數方式，直接返回，不做任何操作if (!referent || referent->isTaggedPointer()) return referent_id;// 確保被引用的對象可用（沒有在析構，同時應該支持weak引用）bool deallocating;// referent 是否有自定義的釋放方法if (!referent->ISA()->hasCustomRR()) {deallocating = referent->rootIsDeallocating();}else {// referent是否支持weak引用BOOL (*allowsWeakReference)(objc_object *, SEL) = (BOOL(*)(objc_object *, SEL))object_getMethodImplementation((id)referent, SEL_allowsWeakReference);// 如果referent不能夠被weak引用，則直接返回nilif ((IMP)allowsWeakReference == _objc_msgForward) {return nil;}// 調用referent的SEL_allowsWeakReference方法來判斷是否正在被釋放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;}}// 對象沒有被正在釋放weak_entry_t *entry;// 在 weak_table中找到referent對應的weak_entry,并將referrer加入到weak_entry中// 如果能找到weak_entry,則講referrer插入到weak_entry中if ((entry = weak_entry_for_referent(weak_table, referent))) {// 將referrer插入到weak_entry_t的引用數組中append_referrer(entry, referrer);} else {// 創建一個新的weak_entry_t ，并將referrer插入到weak_entry_t的引用數組中weak_entry_t new_entry(referent, referrer);// weak_table的weak_entry_t 數組是否需要動態增長，若需要，則會擴容一倍weak_grow_maybe(weak_table);// 將weak_entry_t插入到weak_table中weak_entry_insert(weak_table, &new_entry);}// Do not set *referrer. objc_storeWeak() requires that the // value not change.return referent_id; }

上面方法主要功能是：添加對某個對象的新的弱引用指針

• 過濾掉isTaggedPointer和弱引用對象正在被釋放這兩種情況后(這里需要判斷是否有自定義的釋放方法)，然后根據crashIfDeallocating參數確定是崩潰還是返回nil
• 如果對象沒有正在被釋放，那么從weak_table中取出指向referent的弱引用指針實體，如果weak_table中存在指向referent的指針數組那么在這個數組中添加要新增的指針
• 如果weak_table沒有找到指向referent的弱指針數組，那么新建一個weak_entry_t對象，將這個對象拆入到weak_table中(需要判斷weak_table是否需要擴容)

下面我們來看下具體的插入方法：

append_referrer追加

// 在entry對象的弱引用數組中追加一個新的弱引用指針new_referrer // entry 被弱引用的對象 // new_referrer 弱引用entry的指針 static void append_referrer(weak_entry_t *entry, objc_object **new_referrer) {// 如果entry中弱引用指針沒有超過了4個 表示弱引用指針存放在inline_referrers中// weak_entry 尚未使用動態數組if (! entry->out_of_line()) {// 遍歷inline_referrers數組找到第一個為空的位置 將目標指針插入 尾部追加for (size_t i = 0; i < WEAK_INLINE_COUNT; i++) {if (entry->inline_referrers[i] == nil) {entry->inline_referrers[i] = new_referrer;return;}}// 如果entry中弱引用指針==4個// 新創建一個weak_referrer_t數組 大小為4(WEAK_INLINE_COUNT)// 如果inline_referrers的位置已經存滿了，則要轉型為referrers，做動態數組。weak_referrer_t *new_referrers = (weak_referrer_t *)calloc(WEAK_INLINE_COUNT, sizeof(weak_referrer_t));// 遍歷inline_referrers 將數據放在新創建的臨時數組中for (size_t i = 0; i < WEAK_INLINE_COUNT; i++) {new_referrers[i] = entry->inline_referrers[i];}// 弱引用指針的存儲改為存放到entry->referrers(entry->inline_referrers -> entry->referrers)entry->referrers = new_referrers;// 更新弱引用個數entry->num_refs = WEAK_INLINE_COUNT;//更新是否使用動態數組標記位entry->out_of_line_ness = REFERRERS_OUT_OF_LINE;// 更新mask和最大哈希偏移值entry->mask = WEAK_INLINE_COUNT-1;entry->max_hash_displacement = 0;}assert(entry->out_of_line());// 如果只想entry的弱引用個數大于4// 弱引用個數是否已超過數組容量的3/4if (entry->num_refs >= TABLE_SIZE(entry) * 3/4) {// 如果已超過 那么先擴容在插入return grow_refs_and_insert(entry, new_referrer);}// 如果不需要擴容，直接插入到weak_entry中// 注意，weak_entry是一個哈希表，key：w_hash_pointer(new_referrer) value: new_referrersize_t begin = w_hash_pointer(new_referrer) & (entry->mask);size_t index = begin;size_t hash_displacement = 0;// 由低到高遍歷entry->referrers 找到第一個空位置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;}// 將new_referrer插入到數組的第index個位置weak_referrer_t &ref = entry->referrers[index];ref = new_referrer;// 弱引用計個數+1entry->num_refs++; }

插入的過程主要分下面三種情況:

• 如果inline_referrers沒有存儲滿，直接存儲到inline_referrers中
• 如果inline_referrers個數是4個了，在插入，就需要將inline_referrers拷貝到referrers，然后進入第三步。
• 如果inline_referrers存儲滿了，判斷是否需要擴容，然后將數據存儲到referrers中。

下面我們來看下擴容的方法:

grow_refs_and_insert

// entry 中存放弱引用指針數組 擴容 // weak_entry_t 要擴容的對象 // new_referrer 要插入的指向entry->referent弱引用指針 __attribute__((noinline, used)) static void grow_refs_and_insert(weak_entry_t *entry, objc_object **new_referrer) {assert(entry->out_of_line());// 獲取entry當前的大小size_t old_size = TABLE_SIZE(entry);// 新的大小為舊的大小的2倍size_t new_size = old_size ? old_size * 2 : 8;// 獲取weak_entry_t中存儲的弱引用指針個數size_t num_refs = entry->num_refs;//獲取entry中舊的引用數組weak_referrer_t *old_refs = entry->referrers;// 更新entry->mask 這里是為了后續申請內存空間使用entry->mask = new_size - 1;// 創建一個新的entry->referrers數組// #define TABLE_SIZE(entry) (entry->mask ? entry->mask + 1 : 0)// TABLE_SIZE 獲取的數組大小是 mask+1 = new_sizeentry->referrers = (weak_referrer_t *)calloc(TABLE_SIZE(entry), sizeof(weak_referrer_t));// 重置num_refs和max_hash_displacemententry->num_refs = 0;entry->max_hash_displacement = 0;// 將old_refs中的數據重新插入到新創建entry->referrers中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--;}}// 將new_referrer插入到擴容后的entry中append_referrer(entry, new_referrer);if (old_refs) free(old_refs); }

看完了新增弱引用指針的操作，接下來我們看下如何刪除弱引用指針即weak_unregister_no_lock

weak_unregister_no_lock

// 將 weak ptr地址 從obj的weak_entry_t中移除 // 參數weak_table 全局弱引用表 // referent_id 弱引用所指向的對象 // referrer_id 弱引用指針地址 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;// 找到weak_table中指向被弱引用對象的所有指針 類型為 weak_entry_tif ((entry = weak_entry_for_referent(weak_table, referent))) {// 從數組中刪除當前這個弱引用指針remove_referrer(entry, referrer);bool empty = true;// 弱引用referent對象的弱引用指針是否為空if (entry->out_of_line() && entry->num_refs != 0) {empty = false;}else {// 如果referrer數組中為空 那么判斷inline_referrers中是否為空 如果為空empty=truefor (size_t i = 0; i < WEAK_INLINE_COUNT; i++) {if (entry->inline_referrers[i]) {empty = false; break;}}}// 如果為空 則證明沒有其他指針指向這個被所引用的對象if (empty) {// 將這個實體從weak_table中移除weak_entry_remove(weak_table, entry);}}// Do not set *referrer = nil. objc_storeWeak() requires that the // value not change. }

weak_unregister_no_lock的實現邏輯比較簡單,其實主要的操作為:

• 首先，它會在weak_table中找出referent對應的weak_entry_t
• 在weak_entry_t中移除referrer
• 移除元素后，判斷此時weak_entry_t中是否還有元素 （empty==true？）
• 如果此時weak_entry_t已經沒有元素了，則需要將weak_entry_t從weak_table中移除

而對于remove_referrer方法，我們來簡單的看下他的實現:

remove_referrer

// 刪除old_referrer集合中的referrers // 參數 entry 被弱引用對象 // 參數 old_referrer 要刪除的弱引用指針 static void remove_referrer(weak_entry_t *entry, objc_object **old_referrer) {// 指向entry的弱引用指針不超過4個if (! entry->out_of_line()) {for (size_t i = 0; i < WEAK_INLINE_COUNT; i++) {// 遍歷inline_referrers數組如果找到直接置空if (entry->inline_referrers[i] == old_referrer) {entry->inline_referrers[i] = nil;return;}}// 如果沒有找到 則報錯 弱引用指針小于4個且在inline_referrers中沒有找到_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 begin = w_hash_pointer(old_referrer) & (entry->mask);size_t index = begin;size_t hash_displacement = 0;// 遍歷entry->referrers數組查找old_referrerwhile (entry->referrers[index] != old_referrer) {// 如果沒有在指定index找到 那么取下一個位置的值比較index = (index+1) & entry->mask;// 如果找了一圈仍然沒有找到 那么報錯if (index == begin)bad_weak_table(entry);// 更新最大哈希偏移值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位置找到了值為old_referrer的引用// 將數組的這個位置置空entry->referrers[index] = nil;// 弱引用個數-1entry->num_refs--; }

上面的描述也很簡單，大概的流程為：

• 在entry->inline_referrers中一次查找值為old_referrer的指針 如果找到就清空如果沒找到報錯
• 在entry->referrers中查找值為old_referrer的指針，如果找到則置空同時entry->num_refs做-1操作(使用inline_referrers存儲時不會更新num_refs值因此移除也不用-1)

我們在刪除指向某個對象的某個弱引用指針之后，還會對存儲指向該對象的弱引用指針數組做判空操作，如果發現數組為空，那表示目前沒有弱引用指針指向這個對象，那我們需要將這個對象從weak_table中移除。下面我們來看下移除方法weak_entry_remove。

weak_entry_remove

//從weak_table中移除entry (指向entry的弱引用指針數為0) static void weak_entry_remove(weak_table_t *weak_table, weak_entry_t *entry) {// 如果弱引用指針超過4個(弱引用指針存放在entry->referrers中)if (entry->out_of_line())// 釋放entry->referrers中所有數據free(entry->referrers);bzero(entry, sizeof(*entry));//num_entries-1weak_table->num_entries--;//weak_table是否需要鎖絨weak_compact_maybe(weak_table); }

上面方法的主要操作為:

• 將沒有弱引用的對象從全局的weak_table中移除
• 減少weak_table中存儲的弱引用對象個數
• 判斷weak_table是否需要縮小容量

上面的所有就是當我們將一個obj作weak引用時，所發生的事情。那么，當obj釋放時，所有weak引用它的指針又是如何自動設置為nil的呢？接下來我們來看一下obj釋放時，所發生的事情。

Dealloc

當對象引用計數為0時，runtime會調用_objc_rootDealloc方法來析構對象，實現如下：

- (void)dealloc {_objc_rootDealloc(self); }void _objc_rootDealloc(id obj) {assert(obj);obj->rootDealloc(); }

_objc_rootDealloc又會調用objc_object的rootDealloc方法

rootDealloc

inline void objc_object::rootDealloc() { // 判斷object是否采用了Tagged Pointer計數，如果是，則不進行任何析構操作。if (isTaggedPointer()) return; // fixme necessary?//接下來判斷對象是否采用了優化的isa計數方式（isa.nonpointer）// 對象沒有被weak引用!isa.weakly_referenced// 沒有關聯對象!isa.has_assoc// 沒有自定義的C++析構方法!isa.has_cxx_dtor// 沒有用到sideTable來做引用計數 !isa.has_sidetable_rc// 如果滿足條件 則可以快速釋放if (fastpath(isa.nonpointer && !isa.weakly_referenced && !isa.has_assoc && !isa.has_cxx_dtor && !isa.has_sidetable_rc)){assert(!sidetable_present());free(this);} else {// 慢速釋放object_dispose((id)this);} }

因此根據上面代碼判斷，如果obj被weak引用了，應該進入object_dispose((id)this)分支，下面我們來看下object_dispose方法：

object_dispose

id object_dispose(id obj) {if (!obj) return nil;// 析構objobjc_destructInstance(obj);// 釋放內存free(obj);return nil; }

析構obj主要是看objc_destructInstance方法，下面我們來看下這個方法的實現

objc_destructInstance

void *objc_destructInstance(id obj) {if (obj) {// Read all of the flags at once for performance.//c++析構函數bool cxx = obj->hasCxxDtor();//關聯函數bool assoc = obj->hasAssociatedObjects();// 如果有c++析構函數 則調用c++析構函數.if (cxx)object_cxxDestruct(obj);// 如果有關聯對象則移除關聯對象if (assoc)_object_remove_assocations(obj);// 清理相關的引用obj->clearDeallocating();}return obj; }

清理相關引用方法主要是在clearDeallocating中實現的，下面我們再來看下這個方法：

clearDeallocating

//正在清除side table 和weakly referenced inline void objc_object::clearDeallocating() {// obj是否采用了優化isa引用計數if (slowpath(!isa.nonpointer)) {//沒有采用優化isa引用計數 清理obj存儲在sideTable中的引用計數等信息sidetable_clearDeallocating();}// 啟用了isa優化，則判斷是否使用了sideTable// 使用的原因是因為做了weak引用（isa.weakly_referenced ） 或 使用了sideTable的輔助引用計數（isa.has_sidetable_rc）else if (slowpath(isa.weakly_referenced || isa.has_sidetable_rc)) {// Slow path for non-pointer isa with weak refs and/or side table data.//釋放weak 和引用計數clearDeallocating_slow();}assert(!sidetable_present()); }

這里的清理方法有兩個分別為sidetable_clearDeallocating和clearDeallocating_slow,

我們先來看下clearDeallocating_slow：

clearDeallocating_slow

NEVER_INLINE void objc_object::clearDeallocating_slow() {assert(isa.nonpointer && (isa.weakly_referenced || isa.has_sidetable_rc));// 在全局的SideTables中，以this指針為key，找到對應的SideTableSideTable& table = SideTables()[this];table.lock();如果obj被弱引用if (isa.weakly_referenced) {在SideTable的weak_table中對this進行清理工作weak_clear_no_lock(&table.weak_table, (id)this);}// 如果采用了SideTable做引用計數if (isa.has_sidetable_rc) {//在SideTable的引用計數中移除thistable.refcnts.erase(this);}table.unlock(); }

這里調用了weak_clear_no_lock來做weak_table的清理工作，同時將所有weak引用該對象的ptr置為nil。

weak_clear_no_lock

//清理weak_table，同時將所有weak引用該對象的ptr置為nil void weak_clear_no_lock(weak_table_t *weak_table, id referent_id) {objc_object *referent = (objc_object *)referent_id;// 找到referent在weak_table中對應的weak_entry_tweak_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 %pn", referent);return;}// 找出weak引用referent的weak 指針地址數組以及數組長度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;}// 遍歷所有的所引用weak指針for (size_t i = 0; i < count; ++i) {// 取出每個weak ptr的地址objc_object **referrer = referrers[i];if (referrer) {// 如果weak ptr確實weak引用了referent，則將weak ptr設置為nil，這也就是為什么weak 指針會自動設置為nil的原因if (*referrer == referent) {*referrer = nil;}else if (*referrer) {// 如果所存儲的weak ptr沒有weak 引用referent，這可能是由于runtime代碼的邏輯錯誤引起的，報錯_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();}}}// 由于referent要被釋放了，因此referent的weak_entry_t也要移除出weak_tableweak_entry_remove(weak_table, entry); }

上面就是為什么當對象析構時，所有弱引用該對象的指針都會被設置為nil的原因。

總結

綜上我們講述了SideTable的結構，以及如何使用SideTable存儲和清除對象和指向這些對象的指針地址。從而在側面驗證了弱引用的存儲方式以及在對象釋放時如何將弱引用的指針置空。讀完這篇文章相信你對于SideTable結構和弱引用已經有了一個比較全面的認識。

總結

以上是生活随笔為你收集整理的memset 结构体内指针_SideTable结构的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。