iOS 底層解析weak的實現原理（包含weak對象的初始化，引用，釋放的分析）

原文

不多有人知道weak表實際上是一個hash（哈希）表，Key是所指對象的地址，Value是weak指針的地址數組。更多人的人只是知道weak是弱引用，所引用對象的計數器不會加一，並在引用對象被釋放的時候自動被設置爲nil。一般用於解決循環引用問題。但如今單知道這些已經不足以應對面試了，好多公司會問weak的原理。weak的原理是什麼呢？下面就分析一下weak的工做原理（只是本身對這個問題好奇，學習過程當中的筆記，但願對讀者也有所幫助）。

weak 實現原理的歸納

Runtime維護了一個weak表，用於存儲指向某個對象的全部weak指針。weak表實際上是一個hash（哈希）表，Key是所指對象的地址，Value是weak指針的地址（這個地址的值是所指對象的地址）數組。

weak 的實現原理能夠歸納一下三步：

一、初始化時：runtime會調用objc_initWeak函數，初始化一個新的weak指針指向對象的地址。

二、添加引用時：objc_initWeak函數會調用 objc_storeWeak() 函數， objc_storeWeak() 的做用是更新指針指向，建立對應的弱引用表。

三、釋放時，調用clearDeallocating函數。clearDeallocating函數首先根據對象地址獲取全部weak指針地址的數組，而後遍歷這個數組把其中的數據設爲nil，最後把這個entry從weak表中刪除，最後清理對象的記錄。

下面將開始詳細介紹每一步：

一、初始化時：runtime會調用objc_initWeak函數，objc_initWeak函數會初始化一個新的weak指針指向對象的地址。

示例代碼：

1 2 3 4

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

當咱們初始化一個weak變量時，runtime會調用 NSObject.mm 中的objc_initWeak函數。這個函數在Clang中的聲明以下：

1	id objc_initWeak(id *object, id value);

而對於 objc_initWeak() 方法的實現

1 2 3 4 5 6 7 8 9 10 11 12

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

能夠看出，這個函數僅僅是一個深層函數的調用入口，而通常的入口函數中，都會作一些簡單的判斷（例如 objc_msgSend 中的緩存判斷），這裏判斷了其指針指向的類對象是否有效，無效直接釋放，再也不往深層調用函數。不然，object將被註冊爲一個指向value的__weak對象。而這事應該是objc_storeWeak函數乾的。

注意：objc_initWeak函數有一個前提條件：就是object必須是一個沒有被註冊爲__weak對象的有效指針。而value則能夠是null，或者指向一個有效的對象。

二、添加引用時：objc_initWeak函數會調用 objc_storeWeak() 函數， objc_storeWeak() 的做用是更新指針指向，建立對應的弱引用表。

objc_storeWeak的函數聲明以下：

1	id objc_storeWeak(id *location, id value);

objc_storeWeak() 的具體實現以下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87

// HaveOld:     true - 變量有值 //             false - 須要被及時清理，當前值可能爲 nil // HaveNew:     true - 須要被分配的新值，當前值可能爲 nil //             false - 不須要分配新值 // CrashIfDeallocating: true - 說明 newObj 已經釋放或者 newObj 不支持弱引用，該過程須要暫停 //             false - 用 nil 替代存儲 template bool HaveOld, bool HaveNew, bool CrashIfDeallocating> static id storeWeak(id *location, objc_object *newObj) {      // 該過程用來更新弱引用指針的指向      // 初始化 previouslyInitializedClass 指針      Class previouslyInitializedClass = nil;      id oldObj;      // 聲明兩個 SideTable      // ① 新舊散列建立      SideTable *oldTable;      SideTable *newTable;      // 得到新值和舊值的鎖存位置（用地址做爲惟一標示）      // 經過地址來創建索引標誌，防止桶重複      // 下面指向的操做會改變舊值 retry:      if  (HaveOld) {          // 更改指針，得到以 oldObj 爲索引所存儲的值地址          oldObj = *location;          oldTable = &SideTables()[oldObj];      }  else  {          oldTable = nil;      }      if  (HaveNew) {          // 更改新值指針，得到以 newObj 爲索引所存儲的值地址          newTable = &SideTables()[newObj];      }  else  {          newTable = nil;      }      // 加鎖操做，防止多線程中競爭衝突      SideTable::lockTwoHaveOld, HaveNew>(oldTable, newTable);      // 避免線程衝突重處理      // location 應該與 oldObj 保持一致，若是不一樣，說明當前的 location 已經處理過 oldObj 但是又被其餘線程所修改      if  (HaveOld  &&  *location != oldObj) {          SideTable::unlockTwoHaveOld, HaveNew>(oldTable, newTable);          goto retry;      }      // 防止弱引用間死鎖      // 而且經過 +initialize 初始化構造器保證全部弱引用的 isa 非空指向      if  (HaveNew  &&  newObj) {          // 得到新對象的 isa 指針          Class cls = newObj->getIsa();          // 判斷 isa 非空且已經初始化          if  (cls != previouslyInitializedClass  &&              !((objc_class *)cls)->isInitialized()) {              // 解鎖              SideTable::unlockTwoHaveOld, HaveNew>(oldTable, newTable);              // 對其 isa 指針進行初始化              _class_initialize(_class_getNonMetaClass(cls, (id)newObj));              // 若是該類已經完成執行 +initialize 方法是最理想狀況              // 若是該類 +initialize 在線程中              // 例如 +initialize 正在調用 storeWeak 方法              // 須要手動對其增長保護策略，並設置 previouslyInitializedClass 指針進行標記              previouslyInitializedClass = cls;              // 從新嘗試              goto retry;          }      }      // ② 清除舊值      if  (HaveOld) {          weak_unregister_no_lock(&oldTable->weak_table, oldObj, location);      }      // ③ 分配新值      if  (HaveNew) {          newObj = (objc_object *)weak_register_no_lock(&newTable->weak_table,                                                        (id)newObj, location,                                                        CrashIfDeallocating);          // 若是弱引用被釋放 weak_register_no_lock 方法返回 nil          // 在引用計數表中設置若引用標記位          if  (newObj  &&  !newObj->isTaggedPointer()) {              // 弱引用位初始化操做              // 引用計數那張散列表的weak引用對象的引用計數中標識爲weak引用              newObj->setWeaklyReferenced_nolock();          }          // 以前不要設置 location 對象，這裏須要更改指針指向          *location = (id)newObj;      }      else  {          // 沒有新值，則無需更改      }      SideTable::unlockTwoHaveOld, HaveNew>(oldTable, newTable);      return  (id)newObj; }

撇開源碼中各類鎖操做，來看看這段代碼都作了些什麼。

1)、SideTable

SideTable 這個結構體，我給他起名引用計數和弱引用依賴表，由於它主要用於管理對象的引用計數和 weak 表。在 NSObject.mm 中聲明其數據結構：

1 2 3 4 5 6 7 8

struct SideTable { // 保證原子操做的自旋鎖      spinlock_t slock;      // 引用計數的 hash 表      RefcountMap refcnts;      // weak 引用全局 hash 表      weak_table_t weak_table; }

對於 slock 和 refcnts 兩個成員不用多說，第一個是爲了防止競爭選擇的自旋鎖，第二個是協助對象的 isa 指針的 extra_rc 共同引用計數的變量（對於對象結果，在從此的文中提到）。這裏主要看 weak 全局 hash 表的結構與做用。

2)、weak表

weak表是一個弱引用表，實現爲一個weak_table_t結構體，存儲了某個對象相關的的全部的弱引用信息。其定義以下(具體定義在objc-weak.h中)：

1 2 3 4 5 6 7 8 9 10

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

這是一個全局弱引用hash表。使用不定類型對象的地址做爲 key ，用 weak_entry_t 類型結構體對象做爲 value 。其中的 weak_entries 成員，從字面意思上看，即爲弱引用表入口。其實現也是這樣的。

其中weak_entry_t是存儲在弱引用表中的一個內部結構體，它負責維護和存儲指向一個對象的全部弱引用hash表。其定義以下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

typedef objc_object ** weak_referrer_t; struct weak_entry_t {      DisguisedPtrobjc_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];          };      } }

在 weak_entry_t 的結構中，DisguisedPtr referent 是對泛型對象的指針作了一個封裝，經過這個泛型類來解決內存泄漏的問題。從註釋中寫 out_of_line 成員爲最低有效位，當其爲0的時候， weak_referrer_t 成員將擴展爲多行靜態 hash table。其實其中的 weak_referrer_t 是二維 objc_object 的別名，經過一個二維指針地址偏移，用下標做爲 hash 的 key，作成了一個弱引用散列。

那麼在有效位未生效的時候，out_of_line 、 num_refs、 mask 、 max_hash_displacement 有什麼做用？如下是筆者自身的猜想：

out_of_line：最低有效位，也是標誌位。當標誌位 0 時，增長引用表指針緯度。

num_refs：引用數值。這裏記錄弱引用表中引用有效數字，由於弱引用表使用的是靜態 hash 結構，因此須要使用變量來記錄數目。

mask：計數輔助量。

max_hash_displacement：hash 元素上限閥值。

其實 out_of_line 的值一般狀況下是等於零的，因此弱引用表老是一個 objc_objective 指針二維數組。一維 objc_objective 指針可構成一張弱引用散列表，經過第三緯度實現了多張散列表，而且表數量爲 WEAK_INLINE_COUNT 。

總結一下 StripedMap[] ： StripedMap 是一個模板類，在這個類中有一個 array 成員，用來存儲 PaddedT 對象，而且其中對於 [] 符的重載定義中，會返回這個 PaddedT 的 value 成員，這個 value 就是咱們傳入的 T 泛型成員，也就是 SideTable 對象。在 array 的下標中，這裏使用了 indexForPointer 方法經過位運算計算下標，實現了靜態的 Hash Table。而在 weak_table 中，其成員 weak_entry 會將傳入對象的地址加以封裝起來，而且其中也有訪問全局弱引用表的入口。

舊對象解除註冊操做 weak_unregister_no_lock

該方法主要做用是將舊對象在 weak_table 中接觸 weak 指針的對應綁定。根據函數名，稱之爲解除註冊操做。從源碼中，能夠知道其功能就是從 weak_table 中接觸 weak 指針的綁定。而其中的遍歷查詢，就是針對於 weak_entry 中的多張弱引用散列表。

新對象添加註冊操做 weak_register_no_lock

這一步與上一步相反，經過 weak_register_no_lock 函數把心的對象進行註冊操做，完成與對應的弱引用表進行綁定操做。

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

弱引用的初始化，從上文的分析中能夠看出，主要的操做部分就在弱引用表的取鍵、查詢散列、建立弱引用表等操做，能夠總結出以下的流程圖：

這個圖中省略了不少狀況的判斷，可是當聲明一個 weak 會調用上圖中的這些方法。固然， storeWeak 方法不只僅用在 weak 的聲明中，在 class 內部的操做中也會經常經過該方法來對 weak 對象進行操做。

三、釋放時，調用clearDeallocating函數。clearDeallocating函數首先根據對象地址獲取全部weak指針地址的數組，而後遍歷這個數組把其中的數據設爲nil，最後把這個entry從weak表中刪除，最後清理對象的記錄。

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

一、調用objc_release

二、由於對象的引用計數爲0，因此執行dealloc

三、在dealloc中，調用了_objc_rootDealloc函數

四、在_objc_rootDealloc中，調用了object_dispose函數

五、調用objc_destructInstance

六、最後調用objc_clear_deallocating

重點看對象被釋放時調用的objc_clear_deallocating函數。該函數實現以下：

1 2 3 4 5 6 7

void  objc_clear_deallocating(id obj)  {      assert(obj);      assert(!UseGC);      if  (obj->isTaggedPointer())  return ;     obj->clearDeallocating(); }

也就是調用了clearDeallocating，繼續追蹤能夠發現，它最終是使用了迭代器來取weak表的value，而後調用weak_clear_no_lock,而後查找對應的value，將該weak指針置空，weak_clear_no_lock函數的實現以下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

/**   * Called by dealloc; nils out all weak pointers that point to the   * provided object so that they can no longer be used.   *   * @param weak_table   * @param referent The object being deallocated.   */ 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); }

objc_clear_deallocating該函數的動做以下：

一、從weak表中獲取廢棄對象的地址爲鍵值的記錄

二、將包含在記錄中的全部附有 weak修飾符變量的地址，賦值爲nil

三、將weak表中該記錄刪除

四、從引用計數表中刪除廢棄對象的地址爲鍵值的記錄

看了objc-weak.mm的源碼就明白了：其實Weak表是一個hash（哈希）表，而後裏面的key是指向對象的地址，Value是Weak指針的地址的數組。

補充：.m和.mm的區別

.m：源代碼文件，這個典型的源代碼文件擴展名，能夠包含OC和C代碼。

.mm：源代碼文件，帶有這種擴展名的源代碼文件，除了能夠包含OC和C代碼以外，還能夠包含C++代碼。僅在你的OC代碼中確實須要使用C++類或者特性的時候才用這種擴展名。

參考資料：

• weak 弱引用的實現方式

• weak的生命週期：具體實現方法