weak 弱引用,不持有对象,对象的引用计数不增加; 当对象相互持有时,造成循环引用,导致内存泄漏,weak打破相互持有,防止内存泄漏。
用作修饰属性和__weak关键字
使用:
delegate:
@property (nonatomic, weak) id <xxxDelegate> delegate;
block:
@property (nonatomic, copy) void (^blcok)(void);
__weak typeof(self) weakSelf = self;
self.blcok = ^{
//weakSelf
};
weak是怎么实现的呢?
原理是,把弱引用指针和该指针所指向的对象关联起来保存到一个hash表中管理,对象dealloc时清空该对象关联的弱引用。
首先看下对象生命周期,创建->使用->释放,从这三个过程展开
通过在苹果开源代码中objc-weak.h和objc-weak.m
弱引用创建
- objc_initWeak 创建
/**
* @return storeWeak方法返回的是newObj
* @param location __weak 指针地址
* @param newObj 指针指向的对象地址
* 健壮性判断和 三个bool类型 具体在 storeWeak中介绍
* 不是线程安全的
*/
id
objc_initWeak(id *location, id newObj)
{
if (!newObj) {
*location = nil;
return nil;
}
return storeWeak<DontHaveOld, DoHaveNew, DoCrashIfDeallocating>
(location, (objc_object*)newObj);
}
- objc_storeWeak 保存
载查看保存过程首先要先了解以下内容
haveOld: 当前weak指针是否指向对象,true 指向对象,这个对象需要被释放,这个对象可能是nil; false就是没有指向对象
haveNew: 是否分配新的值,true会被分配新的值;false不会被分配。
DontCrashIfDeallocating: true: newObject已经被释放或者newObject不支持弱引用;false用nil替代存储
SideTable
struct SideTable {
spinlock_t slock; //自旋锁
RefcountMap refcnts;//引用计数hash表
weak_table_t weak_table; //内部包含弱引用hash表
...
};
每个对象都有一个SideTable,sideTable是存储在StripedMap中,stripedMap是一个静态的。
weak_table_t
struct weak_table_t {
weak_entry_t *weak_entries;
size_t num_entries; //表的容量 每次扩大2倍 默认64
uintptr_t mask; //mask 默认是size_t-1 规范hash变量的范围在[0 - (size-1)]中;使用 w_hash_pointer(new_referrer) & (entry->mask)
uintptr_t max_hash_displacement; //最大偏移量
};
以对象的地址为指针,weak_entry_t的结构体为value保存 ,weak_entry_t 是保存weak对象的hash表(已obj地址为key)。这里的hash表解决冲突使用的是开放定址法。
weak_entry_t
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; //容量
uintptr_t mask;//
uintptr_t max_hash_displacement;
};
struct {
// out_of_line_ness field is low bits of inline_referrers[1]
weak_referrer_t inline_referrers[WEAK_INLINE_COUNT];
};
};
.....
};
DisguisedPtr<objc_object> 对对象的封装,为了隐藏一些信息,不被外部查看(包括通过内存工具)
union中
out_of_line_ness 判断标示为如果 out_of_line_ness == 0b10 使用 union中 referrers 就是上面的;否则使用inline_referrers;
inline_referrers size为4;对象对应的弱引用指针个数小于等于4使用inline_referrers,大于4使用referrers。ps(inline_referrers是一个数组,按顺序排列, 不用对弱引用指针地址进行hash算法;referrers是hash表通过开放定址法解决冲突)
num_refs 指针容量最小为8
mask: num_refs-1 做&运算保证对对象地址hash后范围在[0-mask)
max_hash_displacement: 最大偏移量,解决hash冲突时最大偏移量,没有hash冲突为0
out_of_line_ness: 这个标示为什么会是2呢,不清楚。
总结下上面的结构:
SideTable中包含有结构体weak_table_t,weak_table_t中含有hash表weak_entries,weak_entries是以object的地址为key,value是weak_entry_t,weak_entry_t中包含weak_referrer_t,用来存放weak的指针
- weak_unregister_no_lock
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_table_t. entry weak_entry_t
if ((entry = weak_entry_for_referent(weak_table, referent))) {
//移除 referrer
remove_referrer(entry, referrer);
//判断指向对象的weak指针是否还有
bool empty = true;
//weak指针两个不同的存放方式
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);
}
}
// referrer 在objc_storeWeak()中还有用所以不能置空
// Do not set *referrer = nil. objc_storeWeak() requires that the
// value not change.
}
weak_unregister_no_lock 功能是删除对象所对应的weak 指针,删除后再判断对象是否还有
- weak_register_no_lock
id
weak_register_no_lock(weak_table_t *weak_table, id referent_id,
id *referrer_id, bool crashIfDeallocating)
{
//new obj
objc_object *referent = (objc_object *)referent_id;
//弱引用指针
objc_object **referrer = (objc_object **)referrer_id;
//isTaggedPointer 是不会被释放的,所以不用处理
if (!referent || referent->isTaggedPointer()) return referent_id;
// ensure that the referenced object is viable
//确定 new obj是存在的
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_entry_t *entry;
//是否在weak_table 已经存在该对象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;
}
weak_register_no_lock 功能是向对象关联weak指针;(ps:TaggedPointer是一个特殊类型,使用很小空间的对象(所使用的size小于等于指针的size);例如NSString的长度小于9为使就是TaggedPointer类型,相当于把对象存放在指针里面,并且不会释放)。
/**
* @return storeWeak方法返回的是newObj
* @param location __weak 指针地址
* @param newObj 指针指向的对象地址
*/
OBJC_EXPORT id _Nullable
objc_storeWeak(id _Nullable * _Nonnull location, id _Nullable obj)
OBJC_AVAILABLE(10.7, 5.0, 9.0, 1.0, 2.0);
objc_storeWeak具体实现
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含有成员变量 weak_table_t(保存weak指针的hash表)
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指针指向的对象放到oldObj
oldObj = *location;
//获取oldObj所对应的SideTable
oldTable = &SideTables()[oldObj];
} else {
oldTable = nil;
}
if (haveNew) {
//获取oldObj所对应的SideTable
newTable = &SideTables()[newObj];
} else {
newTable = nil;
}
//加锁
SideTable::lockTwo<haveOld, haveNew>(oldTable, newTable);
// 判断是否在多线程下被修改
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();
//判断cls非空并且已经+initialized(initialized class第一次实例化前调用)
if (cls != previouslyInitializedClass &&
!((objc_class *)cls)->isInitialized())
{
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;
goto retry;
}
}
// Clean up old value, if any.
//清除就职
if (haveOld) {
weak_unregister_no_lock(&oldTable->weak_table, oldObj, location);
}
// Assign new value, if any.
//分配新值
if (haveNew) {
//如果注册失败返回nil
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
// 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.
//weak指针指向对象
*location = (id)newObj;
}
else {
//无新值 不设置
// No new value. The storage is not changed.
}
//解锁
SideTable::unlockTwo<haveOld, haveNew>(oldTable, newTable);
//返回
return (id)newObj;
}
总结流程:
释放
weak_clear_no_lock
void
weak_clear_no_lock(weak_table_t *weak_table, id referent_id)
{
//dealloc的对象
objc_object *referent = (objc_object *)referent_id;
//查找对象对用的entry
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;
//根据 out_of_line判断使用的是数组/hash表
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) {
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();
}
}
}
//删除 entry
weak_entry_remove(weak_table, entry);
}
以上是基本过程,有些方法没有说到,使一些hash表的操作,有兴趣的朋友,可以下载源码自己查看。
SideTable的整体图解形式如下:(图画的不太标准)