在项目中我们经常用到weak指针，其可以保证在指向的对象释放后，weak指针自动置为nil，以防止崩溃，因为在OC中向nil发送消息是没有任何处理的。通过__weak、property weak等形式，都可以将指针修饰为weak类型的。
weak的实现原理其实很简单，概括来说就是，在内存中有一个名为weak_table_t的哈希表，weak_table_t中存储着App所有的weak对象及指针。当有对象被weak指针修饰时，会将被修饰的对象及指针添加到weak_table_t表中。当被weak指针的作用域消失时，weak指针会被销毁，随后会 从哈希表中查找对应的weak指针，并将指针置为nil。
weak引用表
SideTables
在weak的实现中很多地方都用到了SideTables函数，此函数内部直接返回了一个哈希表，哈希表名为SideTablesMap。此函数用来保存整个程序所有被weak指针指向的对象，和应用程序是一对一的。每个对象对应其中的一个元素，例如两个weak指针指向一个对象，则这个对象对应一个SideTable对象，这个对象中保存这两个weak指针。
按照比较新的runtime 779.1版本，对于SideTables的定义如下。SideTables本质上是一个静态函数，其内部是通过SideTablesMap实现的。
static StripedMap<SideTable>& SideTables() {
return SideTablesMap.get();
}
下面定义是一个嵌套模型，其中SideTablesMap是一个objc命名空间下的ExplicitInit类，其内部实现的上面的get函数。StripedMap也是一个模型，传入的SideTable就是全局的weak表所在的结构体。
static objc::ExplicitInit<StripedMap<SideTable>> SideTablesMap;
ExplicitInit
ExplicitInit是一个模板类，传入的type就是上面定义的StripedMap。在get函数中有reinterpret_cast关键字，这个关键字类似于强制类型转换，改变类型但存储的数据不变。
template <typename Type>
class ExplicitInit {
alignas(Type) uint8_t _storage[sizeof(Type)];
public:
template <typename... Ts>
void init(Ts &&... Args) {
new (_storage) Type(std::forward<Ts>(Args)...);
}
Type &get() {
return *reinterpret_cast<Type *>(_storage);
}
};
StripedMap
我们继续来看StripedMap模板的定义：
template<typename T>
class StripedMap {
#if TARGET_OS_IPHONE && !TARGET_OS_SIMULATOR //如果是iphone设备Map的数量为8
enum { StripeCount = 8 };
#else
enum { StripeCount = 64 };
#endif
struct PaddedT {
T value alignas(CacheLineSize); //T value 64字节对齐
};
PaddedT array[StripeCount];// 所有PaddedT struct 类型数据被存储在array数组中(这里的PaddedT 带入代码中即 SideTable)。
static unsigned int indexForPointer(const void *p) {// index的hash算法，该方法以void *作为key 来获取void *对应在StripedMap 中的位置
uintptr_t addr = reinterpret_cast<uintptr_t>(p);
return ((addr >> 4) ^ (addr >> 9)) % StripeCount;
}
//苹果为array数组写了一些公共的存取数据的方法，主要是调用indexForPointer方法，使得外部传入的对象地址指针直接hash到对应的array节点,这里主要是对&符号重写，所以我们经常看到&SideTables()[obj]这种调用操作，实际上就是调用这个array[indexForPointer(p)].value从而获取SideTable
public:
T& operator[] (const void *p) {
return array[indexForPointer(p)].value;
}
const T& operator[] (const void *p) const {
return const_cast<StripedMap<T>>(this)[p];
}
// Shortcuts for StripedMaps of locks.
void lockAll() {
for (unsigned int i = 0; i < StripeCount; i++) {
array[i].value.lock();
}
}
void unlockAll() {
for (unsigned int i = 0; i < StripeCount; i++) {
array[i].value.unlock();
}
}
void forceResetAll() {
for (unsigned int i = 0; i < StripeCount; i++) {
array[i].value.forceReset();
}
}
void defineLockOrder() {
for (unsigned int i = 1; i < StripeCount; i++) {
lockdebug_lock_precedes_lock(&array[i-1].value, &array[i].value);
}
}
void precedeLock(const void *newlock) {
// assumes defineLockOrder is also called
lockdebug_lock_precedes_lock(&array[StripeCount-1].value, newlock);
}
void succeedLock(const void *oldlock) {
// assumes defineLockOrder is also called
lockdebug_lock_precedes_lock(oldlock, &array[0].value);
}
const void *getLock(int i) {
if (i < StripeCount) return &array[i].value;
else return nil;
}
#if DEBUG
StripedMap() {
// Verify alignment expectations.
uintptr_t base = (uintptr_t)&array[0].value;
uintptr_t delta = (uintptr_t)&array[1].value - base;
ASSERT(delta % CacheLineSize == 0);
ASSERT(base % CacheLineSize == 0);
}
#else
constexpr StripedMap() {}
#endif
};
SideTable
SideTable结构体是weak实现的核心，结构体中定义了引用计数表和弱引用表，弱引用使用weak_table字段。下面的slock自旋锁，两个表都会使用同一个锁。
struct SideTable {
// 自旋锁，保证线程安全
spinlock_t slock;
// 引用计数表，在未开启isa指针优化，或isa指针存储满了才会用
RefcountMap refcnts;
// 弱引用表
weak_table_t weak_table;
};
weak_table_t
weak_table_t是弱引用表，所有的弱引用都会被存储在这个表中。在下面结构体变量的定义中，weak_entries是一个哈希表的结构，其中key是堆区内存地址，通过key可以获取weak_entries链表中对应的weak_entry_t，也就是指针数组。
struct weak_table_t {
// 弱引用数组，用来存储weak_entry_t对象，是一个链表结构
weak_entry_t *weak_entries;
// 弱引用数组大小，如果到阈值会自动扩容
size_t num_entries;
// 进行哈希运算的mask，大小是num_entries-1
uintptr_t mask;
// 最大冲突数，一般不会大于这个数
uintptr_t max_hash_displacement;
};
weak_entry_t
weak_entry_t结构体内部的定义是一个union联合体，联合体中包含两个结构体，此结构体用来存储指针地址。在存储时会判断，如果同一个对象的weak指针数量少于4，则使用inline_referrers定长数组，否则使用referrers动态长度数组。
有趣的是，因为是union联合体，当weak指针数量大于4之后，不需要另外开辟空间，在当前空间直接覆盖inline_referrers的存储区域，使用referrers哈希表。
#define WEAK_INLINE_COUNT 4
struct weak_entry_t {
DisguisedPtr<objc_object> referent;
union {
struct {
// 弱引用该对象的，指针地址的哈希数组
weak_referrer_t *referrers;
// 是否使用动态长度数组
uintptr_t out_of_line_ness : 2;
// referrers数组中的元素
uintptr_t num_refs : PTR_MINUS_2;
// 参与哈希运算的值，是referrers数组分配的长度，会随着动态扩容而改变
uintptr_t mask;
uintptr_t max_hash_displacement;
};
struct {
weak_referrer_t inline_referrers[WEAK_INLINE_COUNT];
};
};
};
weak_referrer_t
无论是inline_referrers数组还是referrers链表，都是一个weak_referrer_t的定义，在这个typedef中定义了一个指向objc_object的指针，isa指针都是被优化为objc_object的，所以这个指针指向这个被优化的isa。也可以简单理解为，weak_referrer_t本质上存储着被weak修饰的指针地址。
结合weak_entry_t的定义，可以知道referrers数组存储结构，就是直接将DisguisedPtr转换后的整型负数，存储在referrers数组中。
typedef DisguisedPtr<objc_object *> weak_referrer_t;
DisguisedPtr
DisguisedPtr是一个模板工具类，主要起到将指针和整型相互转换的作用，目的是为了隐藏指针，起到一个伪装的作用。隐藏指针的作用在于，一方面是为了安全性，另一方面也防止leaks这些检测工具的误判。
template <typename T>
class DisguisedPtr {
// 存储地址转换为整数的结果
uintptr_t value;
// 将地址转为整数，并取反
static uintptr_t disguise(T* ptr) {
return -(uintptr_t)ptr;
}
// 将转换为负数的地址，先取反随后转换为地址
static T* undisguise(uintptr_t val) {
return (T*)-val;
}
public:
// 构造函数
DisguisedPtr() { }
// 通过指针，初始化value
DisguisedPtr(T* ptr)
: value(disguise(ptr)) { }
DisguisedPtr(const DisguisedPtr<T>& ptr)
: value(ptr.value) { }
// 运算符重载，将指针转换为DisguisedPtr的过程，直接由“&”取地址符来实现
DisguisedPtr<T>& operator = (T* rhs) {
value = disguise(rhs);
return *this;
}
DisguisedPtr<T>& operator = (const DisguisedPtr<T>& rhs) {
value = rhs.value;
return *this;
}
operator T* () const {
return undisguise(value);
}
// 运算符重载，将地址转为指针
T* operator -> () const {
return undisguise(value);
}
T& operator * () const {
return *undisguise(value);
}
T& operator [] (size_t i) const {
return undisguise(value)[i];
}
};
创建weak指针
objc_initWeak
通过__weak等形式创建的指针，编译器会将其转换为objc_initWeak函数的调用，并将被指向对象及weak指针传进去。但需要注意的是，此函数并不是线程并发安全的，所以需要注意多线程的使用。
id objc_initWeak(id *location, id newObj) {
if (!newObj) {
*location = nil;
return nil;
}
return storeWeak<DontHaveOld, DoHaveNew, DoCrashIfDeallocating>
(location, (objc_object*)newObj);
}
在调用函数后会将haveNew、newObj等参数传入，供storeWeak调用。
storeWeak
无论是创建weak指针还是销毁weak指针，其内部实现都是通过storeWeak函数实现的。storeWeak函数是一个C++的模板函数，函数会传入五个参数。其中haveOld和haveNew是互斥的，haveNew则表示新创建的weak指针，haveOld则表示将已有的weak指针置为nil，或将指针重定向。
由于storeWeak函数中的代码量较大，所以只保留了核心代码，不重要的代码都删掉了，看的也清楚点。如果是通过objc_initWeak调用进来，下面template的三个bool参数定义，分别如下。
-
haveOld=false -
haveNew=true -
crashIfDeallocating=true
template <HaveOld haveOld, HaveNew haveNew,
CrashIfDeallocating crashIfDeallocating>
static id
storeWeak(id *location, objc_object *newObj)
{
if (!haveNew) assert(newObj == nil);
Class previouslyInitializedClass = nil;
id oldObj;
SideTable *oldTable;
SideTable *newTable;
retry:
// 判断location是否已经指向weak对象，有的话先把旧对象取出来
if (haveOld) {
oldObj = *location;
oldTable = &SideTables()[oldObj];
} else {
oldTable = nil;
}
// 将新传入的对象，对应的weak表取出来，如果这个对象之前被weak指针指向过，则返回有值
if (haveNew) {
newTable = &SideTables()[newObj];
} else {
newTable = nil;
}
// 如果有旧对象，但是不是location所指向的，也就是当前传入的对象。则表示从retry执行到这里，可能被其他线程改过，所以需要重新执行retry
if (haveOld && *location != oldObj) {
goto retry;
}
// 有新对象，则判断类是否初始化，没有初始化则先初始化，再重新执行retry
if (haveNew && newObj) {
Class cls = newObj->getIsa();
if (cls != previouslyInitializedClass &&
!((objc_class *)cls)->isInitialized())
{
_class_initialize(_class_getNonMetaClass(cls, (id)newObj));
previouslyInitializedClass = cls;
goto retry;
}
}
// 如果location指针指向过其他对象，则执行weak_unregister_no_lock，将weak表和旧对象解绑
if (haveOld) {
weak_unregister_no_lock(&oldTable->weak_table, oldObj, location);
}
// 将传入的新对象，以及新对象的指针地址，添加到weak表中
if (haveNew) {
newObj = (objc_object *)
weak_register_no_lock(&newTable->weak_table, (id)newObj, location,
crashIfDeallocating);
if (newObj && !newObj->isTaggedPointer()) {
newObj->setWeaklyReferenced_nolock();
}
*location = (id)newObj;
}
return (id)newObj;
}
在storeWeak函数中会进行判断，如果是haveNew则表示创建一个weak指针，这时会判断被指向的对象是否第一次传入，如果是则会创建新的内存空间，如果是第二次被weak指向则取出之前已经创建的weak_table。当释放weak指针时也是如此，先取出SideTable对象再从weak_table中移除对应的weak指针。
随后会进入一个判断，会判断弱引用对象所属的类对象是否未执行+initialized方法，如果未执行则调用下面的代码初始化类对象。以保证在弱引用对象和+initialized方法之间，不会产生死锁。
最后会进入具体的实现中，这些实现代码都在objc-weak.mm中。移除weak引用或指针重定向会通过weak_unregister_no_lock函数实现，添加新的weak引用则会通过weak_register_no_lock函数实现。
weak_register_no_lock
weak_register_no_lock函数是添加weak引用的关键，在函数中会有是否可以进行weak操作的判断，如果不符合条件则return或抛出异常。需要注意的是，在NSObject.mm文件中提供了allowsWeakReference方法，可以通过此方法返回是否允许使用weak引用，在下面的代码中也会向此方法发送消息来做确认。
weak_register_no_lock函数传入的四个参数如下。
-
weak_table，全局的weak哈希表 -
referent_id，weak指针。 -
*referrer_id，weak指针地址。 -
crashIfDeallocating，如果weak指向的地址正在释放中，是否crash。
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;
// 判断传入的对象是否为空，以及是否tagged pointer这些边界判断
if (!referent || referent->isTaggedPointer()) return referent_id;
bool deallocating;
if (!referent->ISA()->hasCustomRR()) {
deallocating = referent->rootIsDeallocating();
}
else {
// 有自定义的retain实现，执行自定义方法
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("error");
} else {
return nil;
}
}
// 判断堆区内存是否有被weak引用过，如果有的话就加入到已有的weak_entry_t中
weak_entry_t *entry;
if ((entry = weak_entry_for_referent(weak_table, referent))) {
append_referrer(entry, referrer);
}
else {
// 如果没有，则创建一个weak_entry_t，并插入到全局的weak_table哈希表中
weak_entry_t new_entry(referent, referrer);
weak_grow_maybe(weak_table);
weak_entry_insert(weak_table, &new_entry);
}
return referent_id;
}
在函数中通过referent获取到被weak引用的对象，通过referrer获取到指针对象，随后会将这两个变量包装成weak_entry_t结构体，并调用对应的函数添加到哈希表中。
执行添加操作的有两个关键函数，当对象第一次有weak指针指向时，会调用weak_entry_insert将weak_entry_t插入到哈希表中，后面的weak指向都会调用append_referrer函数向表中添加referrer。
weak_entry_for_referent
weak_entry_for_referent函数用来查找referent，weak指向的堆区地址，也就是objc_object对象的地址。随后通过hash_pointer函数找到referent所在的index，也就是哈希表的key。在while循环中遍历weak_entries表，从index开始查找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;
// 通过哈希算法获取到referent的index，也就是所在的下标
size_t begin = hash_pointer(referent) & weak_table->mask;
size_t index = begin;
size_t hash_displacement = 0;
// 循环时从index所在的下标开始，这样查找速度会很快
while (weak_table->weak_entries[index].referent != referent) {
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;
}
}
return &weak_table->weak_entries[index];
}
append_referrer
此函数是对weak_entry_t进行插入，向数组后面拼接指向指针的地址。内部会根据哈希表大小，决定用动态数组还是定长数组，并且会根据使用情况，对动态数组进行扩容。并最终插入到weak_entry_t的末尾。
static void append_referrer(weak_entry_t *entry, objc_object **new_referrer)
{
// 如果还未开启动态长度数组，则进入这里
if (! entry->out_of_line()) {
// 先尝试定长数组，如果有空位置就插入
for (size_t i = 0; i < WEAK_INLINE_COUNT; i++) {
if (entry->inline_referrers[i] == nil) {
entry->inline_referrers[i] = new_referrer;
return;
}
}
// 如果定长数组存满了，就创建动态数组，并将定长数组的对象插入进来
weak_referrer_t *new_referrers = (weak_referrer_t *)
calloc(WEAK_INLINE_COUNT, sizeof(weak_referrer_t));
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());
// 判断weak_entry_t已经使用的大小，是否超过了已经开辟的3/4，如果超过则进行动态扩容
if (entry->num_refs >= TABLE_SIZE(entry) * 3/4) {
return grow_refs_and_insert(entry, new_referrer);
}
// 通过哈希算法查找当前的index
size_t begin = w_hash_pointer(new_referrer) & (entry->mask);
size_t index = begin;
size_t hash_displacement = 0;
// 通过while循环，找到referrers数组的最新一个为空的位置
while (entry->referrers[index] != nil) {
hash_displacement++;
// 由于扩容是成倍扩容的，所以mask的值一定是，0x111, 0x1111, 0x11111
index = (index+1) & entry->mask;
if (index == begin) bad_weak_table(entry);
}
if (hash_displacement > entry->max_hash_displacement) {
entry->max_hash_displacement = hash_displacement;
}
// 将new_referrer插入到新的空位置，并将count加一
weak_referrer_t &ref = entry->referrers[index];
ref = new_referrer;
entry->num_refs++;
}
weak_entry_insert
在weak_table_t中定义了weak_entries结构体变量，这是一个数组结构，弱引用对象都保存在这里。当插入一个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++;
}
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指针指向一个新的对象，这时候会涉及到指针重定向。新建weak指针会传入newObj并调用对应的函数，weak指针作用域销毁会传入oldObj并调用对应的函数，而指针重定向则这两个参数都有值，haveNew和haveOld也都是有值的。
指针重定向会在一次storeWeak函数调用中处理，并按顺序先调用weak_unregister_no_lock函数，先将weak指针从哈希表中移除，再调用weak_register_no_lock函数添加到新的SideTable中。
dealloc
rootDealloc
当对象释放时，会调用dealloc方法，并调用到rootDealloc来实现释放逻辑。在释放时会判断，如果没有弱引用等逻辑，可以直接调用free函数释放，否则调用object_dispose函数处理释放逻辑。
inline void
objc_object::rootDealloc()
{
if (isTaggedPointer()) return;
// 如果符合下面条件，则直接调用free函数释放内存
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);
}
}
objc_destructInstance
object_dispose函数中调用的objc_destructInstance函数，在objc_destructInstance函数中，执行了一些释放和收尾的工作。而weak的释放操作，就在clearDeallocating中完成的。
void *objc_destructInstance(id obj)
{
if (obj) {
bool cxx = obj->hasCxxDtor();
bool assoc = obj->hasAssociatedObjects();
if (cxx) object_cxxDestruct(obj);
if (assoc) _object_remove_assocations(obj);
obj->clearDeallocating();
}
return obj;
}
clearDeallocating
在clearDeallocating函数中，会判断是否开启指针优化，如果未开启则执行sidetable的释放逻辑。如果开启了指针优化，并且有weak指针，或引用计数的逻辑，则执行clearDeallocating_slow函数。
inline void
objc_object::clearDeallocating()
{
if (slowpath(!isa.nonpointer)) {
sidetable_clearDeallocating();
}
else if (slowpath(isa.weakly_referenced || isa.has_sidetable_rc)) {
clearDeallocating_slow();
}
assert(!sidetable_present());
}
在clearDeallocating_slow函数内部，实际上通过weak_clear_no_lock函数对weak指针释放逻辑进行的实现。
weak_clear_no_lock
weak最核心的功能，即对象释放时，将weak指针指向nil。这个逻辑就在weak_clear_no_lock函数中实现的。
void
weak_clear_no_lock(weak_table_t *weak_table, id referent_id)
{
objc_object *referent = (objc_object *)referent_id;
// 根据被释放的对象referent_id，从weak_table中找到weak_entry_t结构体
weak_entry_t *entry = weak_entry_for_referent(weak_table, referent);
if (entry == nil) {
return;
}
weak_referrer_t *referrers;
size_t count;
// 判断用的是定长数组，还是动态数组，并将数组赋值给referrers指针
if (entry->out_of_line()) {
referrers = entry->referrers;
count = TABLE_SIZE(entry);
}
else {
referrers = entry->inline_referrers;
count = WEAK_INLINE_COUNT;
}
// 遍历weak数组，并将指向weak堆区地址的指针，都置为nil
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_table哈希表中，将weak_entry_t移除
weak_entry_remove(weak_table, entry);
}
释放优化
objc_destroyWeak
当weak作为一个局部变量出现时，编译器会对weak进行优化。创建对象后，会通过objc_initWeak的方式将weak指针添加到哈希表中。在作用域结束时，会通过objc_destroyWeak将weak直接释放掉。
当weak指针作用域消失时，系统会调用objc_destroyWeak函数来处理，并在函数内部调用storeWeak函数。随后storeWeak函数中会传入haveOld，表示是执行移除weak的操作。
void objc_destroyWeak(id *location)
{
(void)storeWeak<DoHaveOld, DontHaveNew, DontCrashIfDeallocating>
(location, nil);
}
weak_unregister_no_lock
weak_unregister_no_lock函数是在storeWeak函数中调用的，当weak指针第一次指向或重新指向时，都会调用storeWeak函数。如果重新指向，会调用weak_unregister_no_lock先将之前的移除掉。
函数会通过referent获取到被weak引用的对象，通过referrer获取到指针对象。随后会通过weak_entry_for_referent函数查找被指向的对象是否有weak_entry_t，如果找到则进入if语句中。
在if语句中会调用remove_referrer函数，将被weak指针从weak_entry_t中移除，并将weak指针置nil，这步就是最关键的一步了。随后会判断，如果被指向的对象，所有weak指针都没有了，则将对象从weak_table的哈希表中移除。
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_entry_t对象，如果有的话则进入if语句
if ((entry = weak_entry_for_referent(weak_table, referent))) {
// 从weak_entry_t中删除referrer引用
remove_referrer(entry, referrer);
// 判断删除后，weak_entry_t是否还有弱引用指针指向这块内存地址
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;
}
}
}
// 如果为空，则将weak_entry_t从全局weak_table哈希表中删除
if (empty) {
weak_entry_remove(weak_table, entry);
}
}
}
remove_referrer
这是weak实现的关键函数，和向weak_entry_t中添加一样，只是这个过程是逆向的。会先遍历inline_referrers数组中有没有指针对象，如果有则将指针置为nil，否则就查找referrers数组。
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;
while (entry->referrers[index] != old_referrer) {
index = (index+1) & entry->mask;
if (index == begin) bad_weak_table(entry);
}
entry->referrers[index] = nil;
entry->num_refs--;
}
