iOS底層原理：weak的實現原理
在iOS開發過程當中，會常用到一個修飾詞
weak，使用場景你們都比較清晰，避免出現對象之間的強強引用而形成對象不能被正常釋放最終致使內存泄露的問題。weak 關鍵字的做用是弱引用，所引用對象的計數器不會加1，並在引用對象被釋放的時候自動被設置爲 nil。算法
一、weak 初探
下面的一段代碼是咱們在開發中常見的weak的使用數組
Person *object = [Person alloc];
id __weak objc = object;
複製代碼
若是在此打斷點跟蹤彙編信息，能夠發現底層庫調了objc_initWeak函數 bash
那麼咱們來看一下objc_initWeak方法的實現代碼是怎麼樣的呢？數據結構
一、objc_initWeak方法
以下是objc_initWeak方法的底層源碼多線程
id objc_initWeak(id *location, id newObj) {
if (!newObj) {
*location = nil;
return nil;
}
return storeWeak<DontHaveOld, DoHaveNew, DoCrashIfDeallocating>
(location, (objc_object*)newObj);
}
複製代碼
該方法的兩個參數location和newObj。app
- location ：
__weak指針的地址，存儲指針的地址，這樣即可以在最後將其指向的對象置爲nil。- newObj ：所引用的對象。即例子中的obj 。
從上面的代碼能夠看出objc_initWeak方法只是一個深層次函數調用的入口，在該方法內部調用了storeWeak方法。下面咱們來看下storeWeak方法的實現代碼。ide
二、storeWeak方法
以下是storeWeak方法的實現代碼。函數
// Template parameters.
enum HaveOld { DontHaveOld = false, DoHaveOld = true };
enum HaveNew { DontHaveNew = false, DoHaveNew = true };
enum CrashIfDeallocating {
DontCrashIfDeallocating = false, DoCrashIfDeallocating = true
};
template <HaveOld haveOld, HaveNew haveNew,
CrashIfDeallocating 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) { // 若是weak ptr以前弱引用過一個obj，則將這個obj所對應的SideTable取出，賦值給oldTable
oldObj = *location;
oldTable = &SideTables()[oldObj];
} else {
oldTable = nil; // 若是weak ptr以前沒有弱引用過一個obj，則oldTable = nil
}
if (haveNew) { // 若是weak ptr要weak引用一個新的obj，則將該obj對應的SideTable取出，賦值給newTable
newTable = &SideTables()[newObj];
} else {
newTable = nil; // 若是weak ptr不須要引用一個新obj，則newTable = nil
}
// 加鎖操做，防止多線程中競爭衝突
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.
if (haveNew && newObj) {
Class cls = newObj->getIsa();
if (cls != previouslyInitializedClass &&
!((objc_class *)cls)->isInitialized()) // 若是cls尚未初始化，先初始化，再嘗試設置weak
{
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.
previouslyInitializedClass = cls; // 這裏記錄一下previouslyInitializedClass， 防止改if分支再次進入
goto retry; // 從新獲取一遍newObj，這時的newObj應該已經初始化過了
}
}
// Clean up old value, if any.
if (haveOld) {
weak_unregister_no_lock(&oldTable->weak_table, oldObj, location); // 若是weak_ptr以前弱引用過別的對象oldObj，則調用weak_unregister_no_lock，在oldObj的weak_entry_t中移除該weak_ptr地址
}
// Assign new value, if any.
if (haveNew) { // 若是weak_ptr須要弱引用新的對象newObj
// (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);
// weak_register_no_lock returns nil if weak store should be rejected
// (2) 更新newObj的isa的weakly_referenced bit標誌位
// 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.
// （3）*location 賦值，也就是將weak ptr直接指向了newObj。能夠看到，這裏並無將newObj的引用計數+1
*location = (id)newObj; // 將weak ptr指向object
}
else {
// No new value. The storage is not changed.
}
// 解鎖，其餘線程能夠訪問oldTable, newTable了
SideTable::unlockTwo<haveOld, haveNew>(oldTable, newTable);
return (id)newObj; // 返回newObj，此時的newObj與剛傳入時相比，weakly-referenced bit位置1
}
複製代碼
storeWeak方法的實現代碼雖然有些長，可是並不難以理解。下面咱們來分析下該方法的實現。優化
storeWeak方法其實是接收了5個參數，分別是haveOld、haveNew和crashIfDeallocating，這三個參數都是以模板的方式傳入的，是三個bool類型的參數。 分別表示weak指針以前是否指向了一個弱引用，weak指針是否須要指向一個新的引用，若果被弱引用的對象正在析構，此時再弱引用該對象是否應該crash。- 該方法維護了
oldTable和newTable分別表示舊的引用弱表和新的弱引用表，它們都是SideTable的hash表。- 若是weak指針以前指向了一個弱引用，則會調用
weak_unregister_no_lock方法將舊的weak指針地址移除。- 若是weak指針須要指向一個新的引用，則會調用
weak_register_no_lock方法將新的weak指針地址添加到弱引用表中。- 調用
setWeaklyReferenced_nolock方法修改weak新引用的對象的bit標誌位
那麼這個方法中的重點也就是weak_unregister_no_lock和weak_register_no_lock這兩個方法。而這兩個方法都是操做的SideTable這樣一個結構的變量，那麼咱們須要先來了解下SideTable。ui
三、SideTable
先來看下SideTable的定義。
struct SideTable {
spinlock_t slock;
RefcountMap refcnts;
weak_table_t weak_table;
}
複製代碼
SideTable的定義很清晰，有三個成員:
- spinlock_t slock : 自旋鎖，用於上鎖/解鎖 SideTable。
- RefcountMap refcnts ：用來存儲OC對象的引用計數的
hash表(僅在未開啓isa優化或在isa優化狀況下isa_t的引用計數溢出時纔會用到)。- weak_table_t weak_table : 存儲對象弱引用指針的
hash表。是OC中weak功能實現的核心數據結構。
3.一、weak_table_t
先來看下weak_table_t的底層代碼。
struct weak_table_t {
weak_entry_t *weak_entries;
size_t num_entries;
uintptr_t mask;
uintptr_t max_hash_displacement;
};
複製代碼
- weak_entries： hash數組，用來存儲弱引用對象的相關信息weak_entry_t
- num_entries： hash數組中的元素個數
- mask：hash數組長度-1，會參與hash計算。（注意，這裏是hash數組的長度，而不是元素個數。好比，數組長度多是64，而元素個數僅存了2個）
- max_hash_displacement：可能會發生的hash衝突的最大次數，用於判斷是否出現了邏輯錯誤（hash表中的衝突次數毫不會超過改值）
weak_table_t是一個典型的hash結構。weak_entries是一個動態數組，用來存儲weak_entry_t類型的元素，這些元素實際上就是OC對象的弱引用信息。
3.二、weak_entry_t
weak_entry_t的結構也是一個hash結構，其存儲的元素是弱引用對象指針的指針， 經過操做指針的指針，就可使得weak 引用的指針在對象析構後，指向nil。
#define WEAK_INLINE_COUNT 4
#define REFERRERS_OUT_OF_LINE 2
struct weak_entry_t {
DisguisedPtr<objc_object> referent; // 被弱引用的對象
// 引用該對象的對象列表，聯合。 引用個數小於4，用inline_referrers數組。 用個數大於4，用動態數組weak_referrer_t *referrers
union {
struct {
weak_referrer_t *referrers; // 弱引用該對象的對象指針地址的hash數組
uintptr_t out_of_line_ness : 2; // 是否使用動態hash數組標記位
uintptr_t num_refs : PTR_MINUS_2; // hash數組中的元素個數
uintptr_t mask; // hash數組長度-1，會參與hash計算。（注意，這裏是hash數組的長度，而不是元素個數。好比，數組長度多是64，而元素個數僅存了2個）素個數）。
uintptr_t max_hash_displacement; // 可能會發生的hash衝突的最大次數，用於判斷是否出現了邏輯錯誤（hash表中的衝突次數毫不會超過改值）
};
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& operator=(const weak_entry_t& other) {
memcpy(this, &other, sizeof(other));
return *this;
}
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;
}
}
};
複製代碼
能夠看到在weak_entry_t的結構定義中有聯合體，在聯合體的內部有定長數組inline_referrers[WEAK_INLINE_COUNT]和動態數組weak_referrer_t *referrers兩種方式來存儲弱引用對象的指針地址。經過out_of_line()這樣一個函數方法來判斷採用哪一種存儲方式。當弱引用該對象的指針數目小於等於WEAK_INLINE_COUNT時，使用定長數組。當超過WEAK_INLINE_COUNT時，會將定長數組中的元素轉移到動態數組中，並以後都是用動態數組存儲。
到這裏咱們已經清楚了弱引用表的結構是一個hash結構的表，Key是所指對象的地址，Value是weak指針的地址（這個地址的值是所指對象的地址）數組。那麼接下來看看這個弱引用表是怎麼維護這些數據的。
四、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;
// 若是referent爲nil 或 referent 採用了TaggedPointer計數方式，直接返回，不作任何操做
if (!referent || referent->isTaggedPointer()) return referent_id;
// 確保被引用的對象可用（沒有在析構，同時應該支持weak引用）
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_table中找到referent對應的weak_entry,並將referrer加入到weak_entry中
weak_entry_t *entry;
if ((entry = weak_entry_for_referent(weak_table, referent))) { // 若是能找到weak_entry,則講referrer插入到weak_entry中
append_referrer(entry, referrer); // 將referrer插入到weak_entry_t的引用數組中
}
else { // 若是找不到，就新建一個
weak_entry_t new_entry(referent, referrer);
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;
}
複製代碼
這個方法須要傳入四個參數，它們表明的意義以下：
- weak_table：
weak_table_t結構類型的全局的弱引用表。- referent_id：weak指針。
- *referrer_id：weak指針地址。
- crashIfDeallocating ：若果被弱引用的對象正在析構，此時再弱引用該對象是否應該crash。
從上面的代碼我麼能夠知道該方法主要的作了以下幾個方便的工做。
- 若是referent爲nil 或 referent 採用了
TaggedPointer計數方式，直接返回，不作任何操做。- 若是對象正在析構，則拋出異常。
- 若是對象不能被weak引用，直接返回nil。
- 若是對象沒有再析構且能夠被weak引用，則調用
weak_entry_for_referent方法根據弱引用對象的地址從弱引用表中找到對應的weak_entry，若是可以找到則調用append_referrer方法向其中插入weak指針地址。不然新建一個weak_entry。
4.一、weak_entry_for_referent取元素
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 begin = hash_pointer(referent) & weak_table->mask; // 這裏經過 & weak_table->mask的位操做，來確保index不會越界
size_t index = begin;
size_t hash_displacement = 0;
while (weak_table->weak_entries[index].referent != referent) {
index = (index+1) & weak_table->mask;
if (index == begin) bad_weak_table(weak_table->weak_entries); // 觸發bad weak table crash
hash_displacement++;
if (hash_displacement > weak_table->max_hash_displacement) { // 當hash衝突超過了可能的max hash 衝突時，說明元素沒有在hash表中，返回nil
return nil;
}
}
return &weak_table->weak_entries[index];
}
複製代碼
4.二、append_referrer添加元素
static void append_referrer(weak_entry_t *entry, objc_object **new_referrer) {
if (! entry->out_of_line()) { // 若是weak_entry 還沒有使用動態數組，走這裏
// 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;
}
}
// 若是inline_referrers的位置已經存滿了，則要轉型爲referrers，作動態數組。
// 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;
}
// 對於動態數組的附加處理：
assert(entry->out_of_line()); // 斷言： 此時必定使用的動態數組
if (entry->num_refs >= TABLE_SIZE(entry) * 3/4) { // 若是動態數組中元素個數大於或等於數組位置總空間的3/4，則擴展數組空間爲當前長度的一倍
return grow_refs_and_insert(entry, new_referrer); // 擴容，並插入
}
// 若是不須要擴容，直接插入到weak_entry中
// 注意，weak_entry是一個哈希表，key：w_hash_pointer(new_referrer) value: new_referrer
// 細心的人可能注意到了，這裏weak_entry_t 的hash算法和 weak_table_t的hash算法是同樣的，同時擴容/減容的算法也是同樣的
size_t begin = w_hash_pointer(new_referrer) & (entry->mask); // '& (entry->mask)' 確保了 begin的位置只能大於或等於 數組的長度
size_t index = begin; // 初始的hash index
size_t hash_displacement = 0; // 用於記錄hash衝突的次數，也就是hash再位移的次數
while (entry->referrers[index] != nil) {
hash_displacement++;
index = (index+1) & entry->mask; // index + 1, 移到下一個位置，再試一次可否插入。（這裏要考慮到entry->mask取值，必定是：0x111, 0x1111, 0x11111, ... ，由於數組每次都是*2增加，即8， 16， 32，對應動態數組空間長度-1的mask，也就是前面的取值。）
if (index == begin) bad_weak_table(entry); // index == begin 意味着數組繞了一圈都沒有找到合適位置，這時候必定是出了什麼問題。
}
if (hash_displacement > entry->max_hash_displacement) { // 記錄最大的hash衝突次數, max_hash_displacement意味着: 咱們嘗試至多max_hash_displacement次，確定可以找到object對應的hash位置
entry->max_hash_displacement = hash_displacement;
}
// 將ref存入hash數組，同時，更新元素個數num_refs
weak_referrer_t &ref = entry->referrers[index];
ref = new_referrer;
entry->num_refs++;
}
複製代碼
這段代碼首先是使用定長數組仍是動態數組，若是是使用定長數組，則直接weak指針地址直接添加到數組便可，若是定長數組已經用盡，則須要將定長數組中的元素轉存到動態數組中。
五、weak_unregister_no_lock移除引用
若是weak指針以前指向了一個弱引用，則會調用weak_unregister_no_lock方法將舊的weak指針地址移除。
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))) { // 查找到referent所對應的weak_entry_t
remove_referrer(entry, referrer); // 在referent所對應的weak_entry_t的hash數組中，移除referrer
// 移除元素以後， 要檢查一下weak_entry_t的hash數組是否已經空了
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_t的hash數組已經空了，則須要將weak_entry_t從weak_table中移除
weak_entry_remove(weak_table, entry);
}
}
複製代碼
- 首先，它會在weak_table中找出referent對應的weak_entry_t
- 在weak_entry_t中移除referrer
- 移除元素後，判斷此時weak_entry_t中是否還有元素 （empty==true？）
- 若是此時weak_entry_t已經沒有元素了，則須要將weak_entry_t從weak_table中移除
到這裏爲止就是對於一個對象作weak引用時底層作的事情，用weak引用對象後引用計數並不會加1，當對象釋放時，全部weak引用它的指針又是如何自動設置爲nil的呢？
六、dealloc
當對象的引用計數爲0時，底層會調用_objc_rootDealloc方法對對象進行釋放，而在_objc_rootDealloc方法裏面會調用rootDealloc方法。以下是rootDealloc方法的代碼實現。
inline void
objc_object::rootDealloc()
{
if (isTaggedPointer()) return; // fixme necessary?
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);
}
}
複製代碼
- 首先判斷對象是不是
Tagged Pointer，若是是則直接返回。- 若是對象是採用了優化的isa計數方式，且同時知足對象沒有被weak引用
!isa.weakly_referenced、沒有關聯對象!isa.has_assoc、沒有自定義的C++析構方法!isa.has_cxx_dtor、沒有用到SideTable來引用計數!isa.has_sidetable_rc則直接快速釋放。- 若是不能知足2中的條件，則會調用
object_dispose方法。
6.一、object_dispose
object_dispose方法很簡單，主要是內部調用了objc_destructInstance方法。
void *objc_destructInstance(id obj) {
if (obj) {
// Read all of the flags at once for performance.
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;
}
複製代碼
上面這一段代碼很清晰，若是有自定義的C++析構方法，則調用C++析構函數。若是有關聯對象，則移除關聯對象並將其自身從Association Manager的map中移除。調用clearDeallocating方法清除對象的相關引用。
6.二、clearDeallocating
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());
}
複製代碼
clearDeallocating中有兩個分支，現實判斷對象是否採用了優化isa引用計數，若是沒有的話則須要清理對象存儲在SideTable中的引用計數數據。若是對象採用了優化isa引用計數，則判斷是都有使用SideTable的輔助引用計數(isa.has_sidetable_rc)或者有weak引用(isa.weakly_referenced)，符合這兩種狀況中一種的，調用clearDeallocating_slow方法。
6.三、clearDeallocating_slow
NEVER_INLINE void
objc_object::clearDeallocating_slow()
{
assert(isa.nonpointer && (isa.weakly_referenced || isa.has_sidetable_rc));
SideTable& table = SideTables()[this]; // 在全局的SideTables中，以this指針爲key，找到對應的SideTable
table.lock();
if (isa.weakly_referenced) { // 若是obj被弱引用
weak_clear_no_lock(&table.weak_table, (id)this); // 在SideTable的weak_table中對this進行清理工做
}
if (isa.has_sidetable_rc) { // 若是採用了SideTable作引用計數
table.refcnts.erase(this); // 在SideTable的引用計數中移除this
}
table.unlock();
}
複製代碼
在這裏咱們關心的是weak_clear_no_lock方法。這裏調用了weak_clear_no_lock來作weak_table的清理工做。
6.四、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); // 找到referent在weak_table中對應的weak_entry_t
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;
// 找出weak引用referent的weak 指針地址數組以及數組長度
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 ptr的地址
if (referrer) {
if (*referrer == referent) { // 若是weak ptr確實weak引用了referent，則將weak ptr設置爲nil，這也就是爲何weak 指針會自動設置爲nil的緣由
*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();
}
}
}
weak_entry_remove(weak_table, entry); // 因爲referent要被釋放了，所以referent的weak_entry_t也要移除出weak_table
}
複製代碼
七、總結
- 一、weak的原理在於底層維護了一張weak_table_t結構的hash表，key是所指對象的地址，value是weak指針的地址數組。
- 二、weak 關鍵字的做用是弱引用，所引用對象的計數器不會加1，並在引用對象被釋放的時候自動被設置爲 nil。
- 三、對象釋放時，調用
clearDeallocating函數根據對象地址獲取全部weak指針地址的數組，而後遍歷這個數組把其中的數據設爲nil，最後把這個entry從weak表中刪除，最後清理對象的記錄。 - 四、文章中介紹了SideTable、weak_table_t、weak_entry_t這樣三個結構，它們之間的關係以下圖所示。
參考資料
相關文章
- 1. IOS開發底層之Weak底層原理實現
- 2. iOS 底層解析weak的實現原理
- 3. 淺談iOS之weak底層實現原理
- 4. iOS開發之weak底層實現原理
- 5. iOS中KVO的底層實現原理
- 6. iOS中Category的底層實現原理
- 7. weak實現原理
- 8. iOS底層原理
- 9. iOS kvo 底層實現原理
- 10. iOS KVO底層實現原理
- 更多相關文章...
- • MyBatis的工作原理 - MyBatis教程
- • BASE原理與最終一致性 - NoSQL教程
- • Java Agent入門實戰（三）-JVM Attach原理與使用
- • ☆技術問答集錦（13）Java Instrument原理
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. IOS開發底層之Weak底層原理實現
- 2. iOS 底層解析weak的實現原理
- 3. 淺談iOS之weak底層實現原理
- 4. iOS開發之weak底層實現原理
- 5. iOS中KVO的底層實現原理
- 6. iOS中Category的底層實現原理
- 7. weak實現原理
- 8. iOS底層原理
- 9. iOS kvo 底層實現原理
- 10. iOS KVO底層實現原理