1.為什么要使用weak關(guān)鍵字修飾對象
因為使用weak修飾的對象在對象釋放的時候,引用它的指針會自動被置為nil;
2. weak和__unsafe_unretained差別,是不是__unsafe_unretained因為weak出現(xiàn)而不再使用了
__unsafe_unretained和weak區(qū)別在于,所引用的對象在釋放的時候,引用它的指針會不會自動被置為nil,可能會產(chǎn)生野指針,但這并不代表__unsafe_unretained就沒用了,在一些情況下合理使用__unsafe_unretained能夠帶來一定性能上的提升.
3.weak的底層的實現(xiàn)
image
參照代碼:
SideTable
struct SideTable {
weak_table_t weak_table;
....
};
weak_table
struct weak_table_t {
weak_entry_t *weak_entries;
};
weak_entry_t
struct weak_entry_t {
DisguisedPtr<objc_object> referent;
union {
struct {
weak_referrer_t *referrers;
};
};
...
};
可以得到一個結(jié)論,系統(tǒng)為我們創(chuàng)建了一個全局的weak_table,這個表里面有一個weak_entries這樣的一個一維數(shù)組,重點關(guān)注這個weak_entries這個數(shù)組中的每個結(jié)構(gòu)體weak_entry_t,其中referent為被弱引用的對象, 而referrers則是指向這個弱引用的的地址,舉個例子
@interface Dog : NSObject
@property (nonatomic,weak) NSObject *referent;
@end
// 暫時可認(rèn)為這個referent和weak_entry_t結(jié)構(gòu)體中的referent是一致的,而referrers[0] = & referent;(ps.假設(shè)目前就一個弱指針指向referent)
4.weak修飾對象的存儲
4.1 property中使用weak修飾
@property (nonatomic,weak) NSObject *referent;
// 底層實現(xiàn)函數(shù)入口
id objc_storeWeak(id *location, id newObj)
{
return storeWeak<DoHaveOld, DoHaveNew, DoCrashIfDeallocating>
(location, (objc_object *)newObj);
}
4.2 使用__weak修飾對象
__weak NSObject *referent
// 底層實現(xiàn)函數(shù)入口
id objc_initWeak(id *location, id newObj)
{
if (!newObj) {
*location = nil;
return nil;
}
return storeWeak<DontHaveOld, DoHaveNew, DoCrashIfDeallocating>
(location, (objc_object*)newObj);
}
其實不論是使用weak還是__weak底層都是調(diào)用storeWeak這個函數(shù),區(qū)別在于模板的第一個參數(shù)HaveOld,官方解釋如下
If HaveOld is true, the variable has an existing value
that needs to be cleaned up. This value might be nil.
進(jìn)入到storeWeak函數(shù)中
static id storeWeak(id *location, objc_object *newObj)
{
...
if (haveNew) {
newObj = (objc_object *)
weak_register_no_lock(&newTable->weak_table, (id)newObj, location,
crashIfDeallocating);
// Do not set *location anywhere else. That would introduce a race.
*location = (id)newObj;
}
...
}
關(guān)注weak_register_no_lock函數(shù)
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;
// 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(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;
}
優(yōu)先檢查weak_table中是否存在referent作為key的的weak_entry_t,如果存在,則插入一個新的指向這個弱引用對象的referrer地址,對應(yīng)的關(guān)系如下圖:
image
先看看在沒有weak_entry_t存儲了referent的時候如何處理,代碼如下
weak_entry_t new_entry(referent, referrer);
weak_grow_maybe(weak_table);
weak_entry_insert(weak_table, &new_entry);
先為這個referent創(chuàng)建了一個weak_entry_t,目前也就一個referrer弱引用referent,接下來判定weak_table的存儲空間是否足夠
static void weak_grow_maybe(weak_table_t *weak_table)
{
size_t old_size = TABLE_SIZE(weak_table);
// Grow if at least 3/4 full.
if (weak_table->num_entries >= old_size * 3 / 4) {
weak_resize(weak_table, old_size ? old_size*2 : 64);
}
}
static void weak_resize(weak_table_t *weak_table, size_t new_size)
{
size_t old_size = TABLE_SIZE(weak_table);
weak_entry_t *old_entries = weak_table->weak_entries;
weak_entry_t *new_entries = (weak_entry_t *)
calloc(new_size, sizeof(weak_entry_t));
// 因為mask為2^n,所以-1,是的mask等于全1的二進(jìn)制
weak_table->mask = new_size - 1;
weak_table->weak_entries = new_entries;
weak_table->max_hash_displacement = 0;
weak_table->num_entries = 0; // restored by weak_entry_insert below
// 重新將老的數(shù)據(jù)插入到插入到新分配的空間中
if (old_entries) {
weak_entry_t *entry;
weak_entry_t *end = old_entries + old_size;
for (entry = old_entries; entry < end; entry++) {
if (entry->referent) {
weak_entry_insert(weak_table, entry);
}
}
free(old_entries);
}
}
當(dāng)weak_table的num_entries大于總量的3/4,其中這個總量存儲在weak_table的mask字段中,初始使用64,以后每次擴容為上次大小的2倍.
接下來插入這個新的weak_entry_t
static void weak_entry_insert(weak_table_t *weak_table, weak_entry_t *new_entry)
{
weak_entry_t *weak_entries = weak_table->weak_entries;
assert(weak_entries != nil);
//
size_t begin = hash_pointer(new_entry->referent) & (weak_table->mask);
size_t index = begin;
size_t hash_displacement = 0;
while (weak_entries[index].referent != nil) {
index = (index+1) & weak_table->mask;
if (index == begin) bad_weak_table(weak_entries);
hash_displacement++;
}
// 這個index即為弱引用對象的地址,hash偏移后產(chǎn)生的
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_entry_insert的算法算是__weak實現(xiàn)的精華所在,如果直接使用弱引用對象的地址作為index,那么weak_entries的大小就要alloc對應(yīng)系統(tǒng)位數(shù)的內(nèi)存大小,顯然不可能,這樣內(nèi)存空間將會全部被占用.因此出現(xiàn)了上面這個方法,根據(jù)存儲對象的數(shù)量,動態(tài)申請內(nèi)存,再根據(jù)引用對象的地址mask后,一定是小于TABLE_SIZE,但是可能有兩個不同的對象,結(jié)尾的地址是相同的,這個時候就需要特殊處理,每次index++,直到這個index對應(yīng)的位置沒有被使用.
5.weak修飾對象的釋放
當(dāng)使用weak修飾的對象被釋放,調(diào)用流程如下圖所示
image
從圖可以看出referent對象在釋放以后,會去判定是否在weak表中有數(shù)據(jù),如果存在會利用weak_clear_no_lock函數(shù),將referrers全部置為nil,代碼如下
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);
// 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) {
// 這是為什么使用weak修飾屬性,在釋放的時候會被置為nil的原因
*referrer = nil;
}
}
}
// 從weak_table中移除這個entry
weak_entry_remove(weak_table, entry);
}
當(dāng)某個對象擁有weak屬性,在這個對象被釋放的時候,會調(diào)用下面這個方法,將引用地址置為nil
void objc_destroyWeak(id *location)
{
(void)storeWeak<DoHaveOld, DontHaveNew, DontCrashIfDeallocating>
(location, nil);
}
static id
storeWeak(id *location, objc_object *newObj)
{
// Clean up old value, if any.
if (haveOld) {
weak_unregister_no_lock(&oldTable->weak_table, oldObj, location);
}
}
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;
}
}
}
// 沒有弱引用指向這個對象,移除這個entry
if (empty) {
weak_entry_remove(weak_table, entry);
}
}
}
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;
}
}
}
size_t begin = w_hash_pointer(old_referrer) & (entry->mask);
size_t index = begin;
size_t hash_displacement = 0;
while (entry->referrers[index] != old_referrer) {
index = (index+1) & entry->mask;
if (index == begin) bad_weak_table(entry);
hash_displacement++;
}
entry->referrers[index] = nil;
entry->num_refs--;
}
