iOS——retain和release底层原理

retain实现原理

retain的源码：

//使用此方法等价于使用[this retain]
inline id 
objc_object::retain()
{//确保对象不是tagged pointerASSERT(!isTaggedPointer());return rootRetain(false, RRVariant::FastOrMsgSend);
}

ALWAYS_INLINE id 
objc_object::rootRetain()
{//分为快速路径和慢速路径，以优化性能和处理溢出情况。return rootRetain(false, RRVariant::Fast);
}

ALWAYS_INLINE id
objc_object::rootRetain(bool tryRetain, objc_object::RRVariant variant)
{if (slowpath(isTaggedPointer())) return (id)this;bool sideTableLocked = false;bool transcribeToSideTable = false;//为什么有isa？因为需要对引用计数+1，即retain+1，而引用计数存储在isa的bits中，需要进行新旧isa的替换isa_t oldisa;isa_t newisa;oldisa = LoadExclusive(&isa.bits);if (variant == RRVariant::FastOrMsgSend) {// 这些检查只对 objc_retain()// 他们在这里是为了避免我们重新装载isa。if (slowpath(oldisa.getDecodedClass(false)->hasCustomRR())) {ClearExclusive(&isa.bits);if (oldisa.getDecodedClass(false)->canCallSwiftRR()) {return swiftRetain.load(memory_order_relaxed)((id)this);}return ((id(*)(objc_object *, SEL))objc_msgSend)(this, @selector(retain));}}if (slowpath(!oldisa.nonpointer)) {// 一个类永远是一个类，所以我们可以执行一次检查// 在CAS环外if (oldisa.getDecodedClass(false)->isMetaClass()) {ClearExclusive(&isa.bits);return (id)this;}}//重点do {// 初始化 transcribeToSideTable 为 false，表示不需要将引用计数转移到 side table//这里是先设置默认情况下的transcribeToSideTabletranscribeToSideTable = false;// 将 oldisa 的值赋给 newisa，用于后续的引用计数增加操作newisa = oldisa;// 检查 newisa 是否为 nonpointer isa//nonpointer isa 是一种优化技术，用于将额外的信息编码到 isa 指针中。它和taggedPointer是不一样的if (slowpath(!newisa.nonpointer)) {// 如果 newisa 不是 nonpointer isa，清除 isa 的原子锁ClearExclusive(&isa().bits);// 如果 tryRetain 为 true，尝试 sidetable 的 tryRetain 方法if (tryRetain) return sidetable_tryRetain() ? (id)this : nil;// 否则调用 sidetable 的 retain 方法else return sidetable_retain(sideTableLocked);}// 不检查 newisa.fast_rr，因为我们已经调用了 RR 覆盖// 检查对象是否正在被 deallocatingif (slowpath(newisa.isDeallocating())) {// 如果对象正在被 deallocating，清除 isa 的原子锁ClearExclusive(&isa().bits);// 如果 sideTableLocked 为 true，解锁 side tableif (sideTableLocked) {ASSERT(variant == RRVariant::Full);sidetable_unlock();}// 如果 tryRetain 为 true，返回 nil，表示无法增加引用计数；否则返回对象本身if (slowpath(tryRetain)) {return nil;} else {return (id)this;}}uintptr_t carry;// 增加引用计数，即对 newisa.bits 中的引用计数位进行加一操作newisa.bits = addc(newisa.bits, RC_ONE, 0, &carry);  // extra_rc++// 检查引用计数是否溢出if (slowpath(carry)) {// 如果引用计数溢出，且 variant 不为 Full，清除 isa 的原子锁并调用 rootRetain_overflowif (variant != RRVariant::Full) {ClearExclusive(&isa().bits);return rootRetain_overflow(tryRetain);}// 保留一半的引用计数在 inline，并准备将另一半复制到 side tableif (!tryRetain && !sideTableLocked) sidetable_lock();sideTableLocked = true;transcribeToSideTable = true;newisa.extra_rc = RC_HALF;newisa.has_sidetable_rc = true;}
// 尝试将 newisa 存储到 isa.bits 中，如果存储失败，则循环重新尝试
} while (slowpath(!StoreExclusive(&isa().bits, &oldisa.bits, newisa.bits)));if (variant == RRVariant::Full) {if (slowpath(transcribeToSideTable)) {// 把剩下的一半放到 side table.sidetable_addExtraRC_nolock(RC_HALF);}if (slowpath(!tryRetain && sideTableLocked)) sidetable_unlock();} else {ASSERT(!transcribeToSideTable);ASSERT(!sideTableLocked);}return (id)this;
}

这段代码的逻辑是：首先初始化并赋值变量，然后进入循环，检查 newisa 是否为 nonpointer isa，如果不是，则清除 isa 的原子锁。如果 tryRetain 为真，则尝试调用 sidetable_tryRetain 增加引用计数，否则调用 sidetable_retain 增加引用计数。如果对象正在被释放，则清除 isa 的原子锁，并根据条件返回 nil 或对象。接着，尝试增加引用计数并检查是否溢出，如果溢出，则将部分引用计数转移到 side table 并设置相关标志。循环结束时，检查并处理 side table 的引用计数操作。
我们再看看sidetable_tryRetain方法：

bool
objc_object::sidetable_tryRetain()
{
#if SUPPORT_NONPOINTER_ISA
//确保对象的 isa 不是 nonpointer isa（如果支持 nonpointer isa）ASSERT(!isa().nonpointer);
#endif//从全局的sideTable中获取当前对象的sideTableSideTable& table = SideTables()[this];// NO SPINLOCK HERE// _objc_rootTryRetain() is called exclusively by _objc_loadWeak(), // which already acquired the lock on our behalf.// fixme can't do this efficiently with os_lock_handoff_s// if (table.slock == 0) {//     _objc_fatal("Do not call -_tryRetain.");// }bool result = true;//在 SideTable 的 refcnts 中尝试插入当前对象。如果插入成功，则表示该对象以前没有引用计数记录，新建的条目引用计数为 1。auto it = table.refcnts.try_emplace(this, SIDE_TABLE_RC_ONE);//获取并引用映射中元素的值部分auto &refcnt = it.first->second;//如果插入了新条目（即条目不存在），什么也不做，因为条目已经初始化为 SIDE_TABLE_RC_ONE。if (it.second) {//如果条目已经存在，检查是否有 SIDE_TABLE_DEALLOCATING 标志。如果有，设置 result 为 false，表示无法增加引用计数。} else if (refcnt & SIDE_TABLE_DEALLOCATING) {result = false;//如果条目已经存在并且没有 SIDE_TABLE_DEALLOCATING 标志，再检查是否有 SIDE_TABLE_RC_PINNED 标志。如果没有，增加引用计数 SIDE_TABLE_RC_ONE。} else if (! (refcnt & SIDE_TABLE_RC_PINNED)) {refcnt += SIDE_TABLE_RC_ONE;}return result;
}

这段代码用于尝试增加对象的引用计数。
首先确保对象的 isa 不是 nonpointer isa，然后从全局的 SideTables 中获取当前对象的 SideTable。
在 SideTable 的 refcnts 中尝试插入当前对象。如果插入成功，则表示该对象以前没有引用计数记录，新建的条目引用计数为 1。如果对象已经存在于 SideTable 中，检查引用计数标志：
如果对象正在被释放（DEALLOCATING），返回 false，表示增加引用计数失败。
如果引用计数没有被固定（没有 SIDE_TABLE_RC_PINNED 标志），增加引用计数。

retain总体流程大概如下图：

release

源码：

// Equivalent to calling [this release], with shortcuts if there is no override
inline void
objc_object::release()
{ASSERT(!isTaggedPointer());rootRelease(true, RRVariant::FastOrMsgSend);
}ALWAYS_INLINE bool 
objc_object::rootRelease()
{return rootRelease(true, RRVariant::Fast);
}inline void
objc_object::release()
{ASSERT(!isTaggedPointer());if (fastpath(!ISA()->hasCustomRR())) {// Standard RR of a class is a no-op.if (!ISA()->isMetaClass())sidetable_release();return;}((void(*)(objc_object *, SEL))objc_msgSend)(this, @selector(release));
}

ALWAYS_INLINE bool
objc_object::rootRelease(bool performDealloc, objc_object::RRVariant variant)
{// 如果是标记指针，直接返回 falseif (slowpath(isTaggedPointer())) return false;bool sideTableLocked = false; // 用于标记侧表是否被锁定isa_t newisa, oldisa; // 定义 isa_t 类型的变量 newisa 和 oldisa// 加载 isa 值到 oldisa 中oldisa = LoadExclusive(&isa().bits);// 如果引用计数变种是 FastOrMsgSendif (variant == RRVariant::FastOrMsgSend) {// 这些检查仅对 objc_release() 有意义// 它们在这里是为了避免重新加载 isaif (slowpath(oldisa.getDecodedClass(false)->hasCustomRR())) {ClearExclusive(&isa().bits); // 清除独占标记if (oldisa.getDecodedClass(false)->canCallSwiftRR()) {// 如果可以调用 Swift 的引用计数方法swiftRelease.load(memory_order_relaxed)((id)this);return true;}// 调用 objc_msgSend 的 release 方法((void(*)(objc_object *, SEL))objc_msgSend)(this, @selector(release));return true;}}// 检查 isa 是否为指针形式if (slowpath(!oldisa.nonpointer)) {// 一个类永远是一个类，所以我们可以在 CAS 循环外进行此检查if (oldisa.getDecodedClass(false)->isMetaClass()) {ClearExclusive(&isa().bits); // 清除独占标记return false;}}#if !ISA_HAS_INLINE_RC// 如果不支持内联引用计数，使用侧表ClearExclusive(&isa().bits); // 清除独占标记return sidetable_release(sideTableLocked, performDealloc);
#else
retry:do {newisa = oldisa; // 将 oldisa 赋值给 newisaif (slowpath(!newisa.nonpointer)) {ClearExclusive(&isa().bits); // 清除独占标记return sidetable_release(sideTableLocked, performDealloc);}if (slowpath(newisa.isDeallocating())) {ClearExclusive(&isa().bits); // 清除独占标记if (sideTableLocked) {ASSERT(variant == RRVariant::Full);sidetable_unlock(); // 解锁侧表}return false;}// 不检查 newisa.fast_rr; 我们已经调用了任何 RR 重载uintptr_t carry;newisa.bits = subc(newisa.bits, RC_ONE, 0, &carry); // extra_rc--if (slowpath(carry)) {// 不清除独占标记goto underflow;}} while (slowpath(!StoreReleaseExclusive(&isa().bits, &oldisa.bits, newisa.bits)));if (slowpath(newisa.isDeallocating()))goto deallocate;if (variant == RRVariant::Full) {if (slowpath(sideTableLocked)) sidetable_unlock();} else {ASSERT(!sideTableLocked);}return false;underflow:// newisa.extra_rc-- 下溢：从侧表借用或析构// 放弃 newisa 以撤销递减newisa = oldisa;if (slowpath(newisa.has_sidetable_rc)) {if (variant != RRVariant::Full) {ClearExclusive(&isa().bits); // 清除独占标记return rootRelease_underflow(performDealloc);}// 将引用计数从侧表转移到内联存储if (!sideTableLocked) {ClearExclusive(&isa().bits); // 清除独占标记sidetable_lock(); // 锁定侧表sideTableLocked = true;// 需要重新开始以避免与指针非指针转换的竞争oldisa = LoadExclusive(&isa().bits);goto retry;}// 尝试从侧表中删除一些引用计数auto borrow = sidetable_subExtraRC_nolock(RC_HALF);bool emptySideTable = borrow.remaining == 0; // 如果侧表中没有引用计数，将清空侧表if (borrow.borrowed > 0) {// 侧表引用计数减少// 尝试将它们添加到内联计数bool didTransitionToDeallocating = false;newisa.extra_rc = borrow.borrowed - 1; // 重新执行原始递减newisa.has_sidetable_rc = !emptySideTable;bool stored = StoreReleaseExclusive(&isa().bits, &oldisa.bits, newisa.bits);if (!stored && oldisa.nonpointer) {// 内联更新失败// 立即重试。这可以防止在 LL/SC 架构上发生活锁，// 因为侧表访问本身可能会丢失预留uintptr_t overflow;newisa.bits =addc(oldisa.bits, RC_ONE * (borrow.borrowed-1), 0, &overflow);newisa.has_sidetable_rc = !emptySideTable;if (!overflow) {stored = StoreReleaseExclusive(&isa().bits, &oldisa.bits, newisa.bits);if (stored) {didTransitionToDeallocating = newisa.isDeallocating();}}}if (!stored) {// 内联更新失败// 将保留重新放回侧表ClearExclusive(&isa().bits);sidetable_addExtraRC_nolock(borrow.borrowed);oldisa = LoadExclusive(&isa().bits);goto retry;}// 从侧表借用后的递减成功if (emptySideTable)sidetable_clearExtraRC_nolock();if (!didTransitionToDeallocating) {if (slowpath(sideTableLocked)) sidetable_unlock();return false;}}else {// 侧表最终为空，进入析构路径}}deallocate:// 真的要析构了ASSERT(newisa.isDeallocating());ASSERT(isa().isDeallocating());if (slowpath(sideTableLocked)) sidetable_unlock();__c11_atomic_thread_fence(__ATOMIC_ACQUIRE);if (performDealloc) {this->performDealloc();}return true;
#endif // ISA_HAS_INLINE_RC
}

uintptr_t
objc_object::sidetable_release(bool locked, bool performDealloc)
{
#if SUPPORT_NONPOINTER_ISAASSERT(!isa().nonpointer);
#endif// 获取当前对象的侧表SideTable& table = SideTables()[this];bool do_dealloc = false; // 标记是否需要析构// 如果未锁定侧表，先锁定它if (!locked) table.lock();// 尝试在侧表的引用计数字典中插入一个新条目// 如果该对象不在侧表中，插入 {this, SIDE_TABLE_DEALLOCATING}auto it = table.refcnts.try_emplace(this, SIDE_TABLE_DEALLOCATING);auto &refcnt = it.first->second; // 获取引用计数//判断是否进行了插入操作if (it.second) {// 如果对象之前不在侧表中，表示这是第一次插入// 设置 do_dealloc 为 true，表示需要析构do_dealloc = true;} else if (refcnt < SIDE_TABLE_DEALLOCATING) {// 如果引用计数小于 SIDE_TABLE_DEALLOCATING// 表示引用计数为负数，可能设置了 SIDE_TABLE_WEAKLY_REFERENCED// 设置 do_dealloc 为 true，并将引用计数标记为 SIDE_TABLE_DEALLOCATINGdo_dealloc = true;refcnt |= SIDE_TABLE_DEALLOCATING;} else if (! (refcnt & SIDE_TABLE_RC_PINNED)) {// 如果引用计数未固定（未设置 SIDE_TABLE_RC_PINNED）// 将引用计数减一refcnt -= SIDE_TABLE_RC_ONE;}// 解锁侧表table.unlock();// 如果需要析构且 performDealloc 为真，执行析构操作if (do_dealloc && performDealloc) {this->performDealloc();}// 返回是否需要析构return do_dealloc;
}

实现了 objc_object 的引用计数减少操作，并根据引用计数的变化决定是否需要进行对象的析构。

dealloc

dealloc用于在对象的引用计数为0的时候，释放该对象，那么在底层，它是如何实现的呢.

inline void objc_object::rootDealloc()
{// 如果对象是 tagged pointer（标记指针），直接返回if (isTaggedPointer()) return;  // fixme necessary?#if !ISA_HAS_INLINE_RC// 如果没有内联引用计数，直接调用 object_dispose 释放对象object_dispose((id)this);
#else// 如果有内联引用计数，并且满足以下所有条件，则直接释放内存if (fastpath(isa().nonpointer &&               // 非指针 ISA!isa().weakly_referenced &&       // 没有弱引用!isa().has_assoc &&               // 没有关联对象
#if ISA_HAS_CXX_DTOR_BIT!isa().has_cxx_dtor &&            // 没有 C++ 析构函数
#else!isa().getClass(false)->hasCxxDtor() && // 没有 C++ 析构函数
#endif!isa().has_sidetable_rc))         // 没有使用 side table 引用计数{// 确认没有 side table 存在assert(!sidetable_present());// 直接释放内存free(this);} else {// 否则，调用 object_dispose 释放对象object_dispose((id)this);}
#endif // ISA_HAS_INLINE_RC
}

用于销毁和释放对象：

id object_dispose(id obj)
{// 如果 obj 是空指针，则直接返回 nilif (!obj) return nil;// 调用 objc_destructInstance 函数，销毁对象实例的内容objc_destructInstance(obj);// 释放对象所占用的内存free(obj);// 返回 nil，表示对象已被销毁return nil;
}

objc_object::clearDeallocating()
{if (slowpath(!isa.nonpointer)) {// Slow path for raw pointer isa.// 如果要释放的对象没有采用了优化过的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.// 如果要释放的对象采用了优化过的isa引用计数，并且有弱引用或者使用了sideTable的辅助引用计数clearDeallocating_slow();}//确保 side table 中没有该对象的引用计数记录。assert(!sidetable_present());
}

上面这段代码根据是否采用了优化过的isa做引用计数分为两种:

1. 要释放的对象没有采用优化过的isa引用计数:会调用sidetable_clearDeallocating() 函数在 side table 中清理对象的引用计数。

void 
objc_object::sidetable_clearDeallocating()
{// 在全局的SideTables中，以this指针(要释放的对象)为key，找到对应的SideTableSideTable& table = SideTables()[this];// clear any weak table items// clear extra retain count and deallocating bit// (fixme warn or abort if extra retain count == 0 ?)table.lock();//在散列表SideTable中找到对应的引用计数表RefcountMap，拿到要释放的对象的引用计数RefcountMap::iterator it = table.refcnts.find(this);if (it != table.refcnts.end()) {//如果要释放的对象被弱引用了，通过weak_clear_no_lock函数将指向该对象的弱引用指针置为nilif (it->second & SIDE_TABLE_WEAKLY_REFERENCED) {weak_clear_no_lock(&table.weak_table, (id)this);}//从引用计数表中擦除该对象的引用计数table.refcnts.erase(it);}table.unlock();
}

先找到对应的 SideTable，并对其加锁。
查找引用计数表 refcnts 中该对象的引用计数。
如果找到该对象的引用计数且被弱引用，则清理弱引用。
最后擦除该对象的引用计数，并解锁 SideTable。

2. 如果该对象采用了优化过的isa引用计数并且该对象有弱引用或者使用了sideTable的辅助引用计数,就会调用clearDeallocating_slow()函数处理引用计数

NEVER_INLINE voidobjc_object::clearDeallocating_slow(){assert(isa.nonpointer  &&  (isa.weakly_referenced || isa.has_sidetable_rc));// 在全局的SideTables中，以this指针(要释放的对象)为key，找到对应的SideTableSideTable& table = SideTables()[this];table.lock();if (isa.weakly_referenced) {//要释放的对象被弱引用了，通过weak_clear_no_lock函数将指向该对象的弱引用指针置为nilweak_clear_no_lock(&table.weak_table, (id)this);}//使用了sideTable的辅助引用计数,直接在SideTable中擦除该对象的引用计数if (isa.has_sidetable_rc) {table.refcnts.erase(this);}table.unlock();
}

找到对应的 SideTable，并对其加锁。
如果对象被弱引用，清理弱引用。
如果对象使用了 side table 的引用计数，擦除该对象的引用计数。
最后解锁 SideTable。

以上两种情况都涉及weak_clear_no_lock函数, 它的作用就是将被弱引用对象的弱引用指针置为nil.

dealloc的流程：如果对象是 tagged pointer，则直接返回。如果没有内联引用计数，调用 object_dispose 释放对象；如果有内联引用计数，并且对象满足非指针 ISA、没有弱引用、没有关联对象、没有 C++ 析构函数以及没有使用 side table 引用计数等条件，则直接释放内存。否则，调用 object_dispose 进行标准的对象销毁和内存释放。