@[TOC](iOS arc weak指針原理)
ARC 都幫我們做了什么？
是 LLVM 和 runTime 系統相互協作的一個結果，
LLVM 編繹器幫我們補個 [obj release] ，[obj retain]等引用增減方法。
下面將通過分析蘋果官方源碼：蘋果官方objc4_723源碼下載
weak是什么？
- weak表其實是一個hash（哈希）表，Key是所指對象的地址，Value是weak指針的地址數組。更多人的人只是知道weak是弱引用，所引用對象的計數器不會加一，并在引用對象被釋放的時候自動被設置為nil。通常用于解決循環引用問題。但現在單知道這些已經不足以應對面試了，好多公司會問weak的原理。
weak是怎么實現的？
1. weak原理簡介
Runtime維護了一個weak表，用于存儲指向某個對象的所有weak指針。weak表其實是一個hash（哈希）表，Key是所指對象的地址，Value是weak指針的地址（這個地址的值是所指對象的地址）數組。
weak 的實現原理可以概括一下三步：
1、初始化時：runtime會調用objc_initWeak函數，初始化一個新的weak指針指向對象的地址。
2、添加引用時：objc_initWeak函數會調用 objc_storeWeak() 函數， objc_storeWeak() 的作用是更新指針指向，創建對應的弱引用表。
3、釋放時，調用clearDeallocating函數。clearDeallocating函數首先根據對象地址獲取所有weak指針地址的數組，然后遍歷這個數組把其中的數據設為nil，最后把這個entry從weak表中刪除，最后清理對象的記錄。
2. weak簡單測試
關于對象的三個修飾詞__strong、__weak、__unsafe_unretained，測試結果分別用“01__strong指針引用對象.png”、“02__weak指針引用對象.png”、“03__unsafe_unretained指針引用對象.png”三張圖表示。
- 測試代碼
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
{
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-variable"
__strong ZYClass *strongZYClass;
__weak ZYClass *weakZYClass;
__unsafe_unretained ZYClass *unsafeZYClass;
#pragma clang diagnostic pop
NSLog(@"test begin");
{
ZYClass *zyClass = [[ZYClass alloc] init];
strongZYClass = zyClass;
// weakZYClass = zyClass;
// unsafeZYClass = zyClass;
}
NSLog(@"test over%@",strongZYClass);
}
測試結果：
-
01__strong指針引用對象
01__strong指針引用對象 -
02__weak指針引用對象
02__weak指針引用對象 -
03__unsafe_unretained指針引用對象
03__unsafe_unretained指針引用對象
"zyClass"定義的作用域如下：
{
ZYClass *zyClass = [[ZYClass alloc] init];
strongZYClass = zyClass;
// weakZYClass = zyClass;
// unsafeZYClass = zyClass;
}
鑒于__strong指針對對象有強引用關系，所以"zyClass"在出作用域后并沒有立即銷毀；
__weak指針對對象是弱引用關系，不持有引用對象。所以"zyClass"在出作用域后就銷毀了；
__unsafe_unretained指針對對象是弱引用關系，不持有引用對象。所以"zyClass"在出作用域后就銷毀了。（與__weak不同的是，__weak引用的對象銷毀后，系統會將對象置為nil，而__unsafe_unretained不這么做，導致EXC_BAD_ACCESS錯誤。）
3. weak原理分析
3.1 weak指針幫我們干了啥?
程序運行時將弱引用存到一個哈希表中，當對象obj要銷毀的時候，哈希函數根據obj地址獲取到索引，然后從哈希表中取出obj對應的弱引用集合weak_entries，遍歷weak_entries并一一清空
分析objc 源碼：
當一個對象釋放的時候，會執行"- (void)dealloc {}"方法，在objc源碼的“NSObject.mm”中找到了該函數以及相關調用流程
// Replaced by NSZombies
- (void)dealloc {
_objc_rootDealloc(self);
}
void _objc_rootDealloc(id obj)
{
assert(obj);
obj->rootDealloc();
}
inline void objc_object::rootDealloc()
{
if (isTaggedPointer()) return; // fixme necessary?
/* nonpointer 0 代表普通的指針 0，代表普通的指針，存儲著Class、Meta-Class對象的內存地址
1，代表優化過，使用位域存儲更多的信息
has_assoc 是否有關聯對象 如果沒有釋放會很快
has_cxx_dtor 是否有C++析構函數 如果沒有釋放會更快
weakly_referenced 釋放有被弱引用指向 如果沒有 釋放會更快
has_sidetable_rc 引用計數器是否過大無法存儲在isa中
如果為1，那么引用計數會存儲在一個叫SideTable的類的屬性中
*/
/// 快速釋放對象 滿足上邊的條件
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);
}
}
id object_dispose(id obj)
{
if (!obj) return nil;
/// 釋放對象前 要將對象的關聯屬性 weak 指針置空 修改引用計數 isa 指針的一些信息
objc_destructInstance(obj);
free(obj);
return nil;
}
/***********************************************************************
* objc_destructInstance
* Destroys an instance without freeing memory.
* Calls C++ destructors.
* Calls ARC ivar cleanup.
* Removes associative references.
* Returns `obj`. Does nothing if `obj` is nil.
**********************************************************************/
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();
// This order is important.
//清除對象的成員變量
if (cxx) object_cxxDestruct(obj);
//清除對象的關聯對象
if (assoc) _object_remove_assocations(obj);
///明確回收
obj->clearDeallocating();
}
return obj;
}
inline void objc_object::clearDeallocating()
{
if (slowpath(!isa.nonpointer)) {
// Slow path for raw pointer isa.
sidetable_clearDeallocating();
}
else if (slowpath(isa.weakly_referenced || isa.has_sidetable_rc)) {
// Slow path for non-pointer isa with weak refs and/or side table data.
clearDeallocating_slow();
}
assert(!sidetable_present());
}
// Slow path of clearDeallocating()
// for objects with nonpointer isa
// that were ever weakly referenced
// or whose retain count ever overflowed to the side table.
NEVER_INLINE void objc_object::clearDeallocating_slow()
{
assert(isa.nonpointer && (isa.weakly_referenced || isa.has_sidetable_rc));
SideTable& table = SideTables()[this];
table.lock();///加鎖
if (isa.weakly_referenced) {/// 有弱引用指向
weak_clear_no_lock(&table.weak_table, (id)this);
}
if (isa.has_sidetable_rc) {
table.refcnts.erase(this);
}
table.unlock();///解鎖
}
/**
* 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 結構體指針類型
objc_object *referent = (objc_object *)referent_id;
///獲weak散列表中跟當前對象對應的 weak_entry_t *結構體指針
weak_entry_t *entry = weak_entry_for_referent(weak_table, referent);
if (entry == nil) {///如果為 nil 代表 沒有查找到這個對象在 weak 表里存放 可能是這個對象轉成CF對象 并轉移了對象引用計數所有權
/// 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 指針數組
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];
///weak 指針數組中的元素 是 當前對象指向的指針地址 將指針置空 nil
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 表中移除跟當前對象weak_entry_t有關的內容
weak_entry_remove(weak_table, entry);
}
/**weak_entry_for_referent(weak_table_t *weak_table, objc_object *referent) 根據當前對象指針作為查找條件從
weak_table_t 中獲取 weak_entry_t * 指針類型結構體
這里邊是一個簡單的 hash 算法 用對象內存地址轉成一個 hash 值
然后 & weak_table->mask 獲得一個開始索引 然后根據這個索引在數組里查找元素 ,
如果生成的索引查找的元素不是我們想要的 ,
可以用 index + 1 & weak_table->mask 重新生成一個 index ,
直到算出一個合適的索引 ,然后從數組里 取出 一個 weak_entry_t * 結構體指針
*/
/**
* Return the weak reference table entry for the given referent.
* If there is no entry for referent, return NULL.
* Performs a lookup.
*
* @param weak_table
* @param referent The object. Must not be nil.
*
* @return The table of weak referrers to this object.
*/
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;
///用對象內存地址轉成一個 hash 值 然后 & weak_table->mask 獲得一個開始索引
size_t begin = hash_pointer(referent) & weak_table->mask;
size_t index = begin;
size_t hash_displacement = 0;
///直到 index 對應的 weak_entries[index].referent == referent 是我們要釋放掉的對象時 才會退出循環
while (weak_table->weak_entries[index].referent != referent) {
/// 用 index + 1 方式 生成一個新的 index 繼續在 weak_entries查找
index = (index+1) & weak_table->mask;
if (index == begin) bad_weak_table(weak_table->weak_entries);
hash_displacement++;
if (hash_displacement > weak_table->max_hash_displacement) {
return nil;
}
}
///根據計算出來的 index 取出一個weak_entry_t * 結構體指針
return &weak_table->weak_entries[index];
}
- 函數inline void objc_object::rootDealloc()中有一句判斷if (isTaggedPointer()) return; // fixme necessary?，這個地方條件成立就會return ,而不會釋放對象，為什么？
實際上蘋果在64位系統開始推出了“Tagged Pointer”技術來優化NSNumber、NSString、NSDate等小對象的存儲，在沒有引入“Tagged Pointer”技術之前，NSNumber等對象需要動態分配內存、維護引用技術，NSNumber指針存儲的是NSNumber對象的地址值。iOS引入“Tagged Pointer”技術之后，NSNumber指針里面存儲的數據變成了“Tag+Data”,也就是直接將數據存儲在指針中。僅當指針不夠存儲數據時，才會使用動態分配內存的方式來存儲數據。
“Tagged Pointer”的好處是：一方面節約計算機內存，另一方面因為可以直接從指針中讀取數據，可以節約之前objc_msgSend流程消耗的時間。
那對于下面三個“對象”（這里注意“”修飾，因為a、b本質上屬于Tagged Pointer類型，而不是OC對象）：
a. NSNumber *number1 = @4;
b. NSNumber number2 = @5;
c. NSNumber number3 = @(0xFFFFFFFFFFFFFFF)。
對于a、b，所對應的二級制編碼分別為0b0100、0b0101,僅僅占用3 bit，用一個字節(8bit)就足夠存儲了，而OC的指針number1、number2都占用8個字節，因此我們完全可以將a、b的值存放在指針中，那么a、b實際上就不是真正的對象了，也就不存在執行所謂的- (void) dealloc{}流程。如果按照64位之前的策略，那存儲a、b這樣的小對象，需要在堆空間alloc init出一個NSNumber對象，然后將@10放入對象中，這個過程至少占用16字節，然后在棧區用一個指針指向這個NSNumber對象，棧空間指針又占用8字節，所以至少需要24字節存儲a、b這樣的小對象，很浪費內存。
- 分析代碼得到，當一個對象被回收的時候調用流程：
- -(void)dealloc ->
- _objc_rootDealloc(id obj) ->
- objc_object::rootDealloc() ->
- object_dispose(id obj) ->
- objc_destructInstance(id obj) ->
- objc_object::clearDeallocating() ->
- objc_object::clearDeallocating_slow() ->
- weak_clear_no_lock(weak_table_t weak_table, id referent_id) ->
- weak_entry_for_referent(weak_table_t *weak_table, objc_object *referent)
再看一次"weak_entry_t * weak_entry_for_referent(weak_table_t *weak_table, objc_object *referent)"函數實現細節
///直到 index 對應的 weak_entries[index].referent == referent 是我們要釋放掉的對象時 才會退出循環
while (weak_table->weak_entries[index].referent != referent) {
/// 用 index + 1 方式 生成一個新的 index 繼續在 weak_entries查找
index = (index+1) & weak_table->mask;
if (index == begin) bad_weak_table(weak_table->weak_entries);
hash_displacement++;
if (hash_displacement > weak_table->max_hash_displacement) {
return nil;
}
}
函數內部利用正在被dealloc的對象地址referent 通過哈希函數hash_pointer()計算，再&weak_table->mask獲得begin索引，所以可推測weak_table是一個散列表結構，weak_table來自于SideTable對象中的“weak_table”成員，有了這個當前對象在散列表中的索引，就可以通過索引獲取當前對象的弱引用數組了（當然根據獲取到的begin索引得到的散列結果可能并不是這個“dealloc對象”的，因為存在散列沖突，所以這里面有while ()循環判斷當前index散列值的“ referent”與我們傳入的“ referent”是否匹配）。
通過這個while循環，可見這個散列表解決散列沖突采用的是“開放尋址法”。
程序運行時將弱引用存到一個哈希表中，當對象obj要銷毀的時候，哈希函數根據obj地址獲取到索引，然后從哈希表中取出obj對應的弱引用集合weak_entries，遍歷weak_entries并一一清空（也就對應源碼中函數void weak_clear_no_lock(weak_table_t weak_table, id referent_id)所做的referrer = nil;）。
3.2 weak實現的流程
3.2.1 初始化時：runtime會調用objc_initWeak函數，objc_initWeak函數會初始化一個新的weak指針指向對象的地址。
{
NSObject *obj = [[NSObject alloc] init];
id __weak obj1 = obj;
}
當我們初始化一個weak變量時，runtime會調用 NSObject.mm 中的objc_initWeak函數。這個函數在Clang中的聲明如下：
id objc_initWeak(id *object, id value);
而對于 objc_initWeak() 方法的實現
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，或者指向一個有效的對象。
3.2.2 添加引用時：objc_initWeak函數會調用 objc_storeWeak() 函數， objc_storeWeak() 的作用是更新指針指向，創建對應的弱引用表。
- objc_storeWeak的函數聲明如下：
id objc_storeWeak(id *location, id value);
- objc_storeWeak() 的具體實現如下：
// 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;
}
- 撇開源碼中各種鎖操作，來看看這段代碼都做了些什么。
- SideTable
SideTable 這個結構體，我給他起名引用計數和弱引用依賴表，因為它主要用于管理對象的引用計數和 weak 表。在 NSObject.mm 中聲明其數據結構：
struct SideTable {
// 保證原子操作的自旋鎖
spinlock_t slock;
// 引用計數的 hash 表
RefcountMap refcnts;
// weak 散列表 所有 weak 指針存放在這個表里，weak 引用全局 hash 表
weak_table_t weak_table;
}
對于 slock 和 refcnts 兩個成員不用多說，第一個是為了防止競爭選擇的自旋鎖，第二個是協助對象的 isa 指針的 extra_rc 共同引用計數的變量（對于對象結果，在今后的文中提到）。這里主要看 weak 全局 hash 表的結構與作用。
- weak表
weak表是一個弱引用表，實現為一個weak_table_t結構體，存儲了某個對象相關的的所有的弱引用信息。其定義如下(具體定義在objc-weak.h中)：
struct weak_table_t {
// 指針數組 存放 weak_entry_t 類型，保存了所有指向指定對象的 weak 指針
weak_entry_t *weak_entries;
// 存儲空間，散列表最大可存放內容容量
size_t num_entries;
// 參與判斷引用計數輔助量，&mask 可以獲取一個 key 從而在散列表快速查找某個元素
uintptr_t mask;
// hash key 最大偏移值
uintptr_t max_hash_displacement;
};
這是一個全局弱引用hash表。使用不定類型對象的地址作為 key ，用 weak_entry_t 類型結構體對象作為 value 。其中的 weak_entries 成員，從字面意思上看，即為弱引用表入口。其實現也是這樣的。
其中weak_entry_t是存儲在弱引用表中的一個內部結構體，它負責維護和存儲指向一個對象的所有弱引用hash表。其定義如下：
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 對象進行操作。
3.2.3 釋放時，調用clearDeallocating函數。clearDeallocating函數首先根據對象地址獲取所有weak指針地址的數組，然后遍歷這個數組把其中的數據設為nil，最后把這個entry從weak表中刪除，最后清理對象的記錄。
- 當weak引用指向的對象被釋放時，又是如何去處理weak指針的呢？當釋放對象時，其基本流程如下：
(1) 調用objc_release
(2) 因為對象的引用計數為0，所以執行dealloc
(3) 在dealloc中，調用了_objc_rootDealloc函數
(4) 在_objc_rootDealloc中，調用了object_dispose函數
(5) 調用objc_destructInstance
(6) 最后調用objc_clear_deallocating
- 調用objc_release
- 因為對象的引用計數為0，所以執行dealloc
- 在dealloc中，調用了_objc_rootDealloc函數
- 在_objc_rootDealloc中，調用了object_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();
}
也就是調用了clearDeallocating，繼續追蹤可以發現，它最終是使用了迭代器來取weak表的value，然后調用weak_clear_no_lock,然后查找對應的value，將該weak指針置空，weak_clear_no_lock函數的實現如下：
/**
* 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該函數的動作如下：
1、從weak表中獲取廢棄對象的地址為鍵值的記錄
2、將包含在記錄中的所有附有 weak修飾符變量的地址，賦值為nil
3、將weak表中該記錄刪除
4、從引用計數表中刪除廢棄對象的地址為鍵值的記錄
