iOS——retain和release底层原理

retain实现原理

retain的源码：

1. //使用此方法等价于使用[this retain]
2. inline id
3. objc_object::retain()
4. {
5.   //确保对象不是tagged pointer
6.     ASSERT(!isTaggedPointer());
8.     return rootRetain(false, RRVariant::FastOrMsgSend);
9. }

复制代码

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

复制代码

1. ALWAYS_INLINE id
2. objc_object::rootRetain(bool tryRetain, objc_object::RRVariant variant)
3. {
4.     if (slowpath(isTaggedPointer())) return (id)this;
6.     bool sideTableLocked = false;
7.     bool transcribeToSideTable = false;
8.   //为什么有isa？因为需要对引用计数+1，即retain+1，而引用计数存储在isa的bits中，需要进行新旧isa的替换
9.     isa_t oldisa;
10.     isa_t newisa;
12.     oldisa = LoadExclusive(&isa.bits);
14.     if (variant == RRVariant::FastOrMsgSend) {
15.         // 这些检查只对 objc_retain()
16.         // 他们在这里是为了避免我们重新装载isa。
17.         if (slowpath(oldisa.getDecodedClass(false)->hasCustomRR())) {
18.             ClearExclusive(&isa.bits);
19.             if (oldisa.getDecodedClass(false)->canCallSwiftRR()) {
20.                 return swiftRetain.load(memory_order_relaxed)((id)this);
21.             }
22.             return ((id(*)(objc_object *, SEL))objc_msgSend)(this, @selector(retain));
23.         }
24.     }
26.     if (slowpath(!oldisa.nonpointer)) {
27.         // 一个类永远是一个类，所以我们可以执行一次检查
28.         // 在CAS环外
29.         if (oldisa.getDecodedClass(false)->isMetaClass()) {
30.             ClearExclusive(&isa.bits);
31.             return (id)this;
32.         }
33.     }
34.     //重点
35.     do {
36.     // 初始化 transcribeToSideTable 为 false，表示不需要将引用计数转移到 side table
37.     //这里是先设置默认情况下的transcribeToSideTable
38.     transcribeToSideTable = false;
39.     // 将 oldisa 的值赋给 newisa，用于后续的引用计数增加操作
40.     newisa = oldisa;
41.    
42.     // 检查 newisa 是否为 nonpointer isa
43.     //nonpointer isa 是一种优化技术，用于将额外的信息编码到 isa 指针中。它和taggedPointer是不一样的
44.     if (slowpath(!newisa.nonpointer)) {
45.         // 如果 newisa 不是 nonpointer isa，清除 isa 的原子锁
46.         ClearExclusive(&isa().bits);
47.         // 如果 tryRetain 为 true，尝试 sidetable 的 tryRetain 方法
48.         if (tryRetain) return sidetable_tryRetain() ? (id)this : nil;
49.         // 否则调用 sidetable 的 retain 方法
50.         else return sidetable_retain(sideTableLocked);
51.     }
52.    
53.     // 不检查 newisa.fast_rr，因为我们已经调用了 RR 覆盖
54.     // 检查对象是否正在被 deallocating
55.     if (slowpath(newisa.isDeallocating())) {
56.         // 如果对象正在被 deallocating，清除 isa 的原子锁
57.         ClearExclusive(&isa().bits);
58.         // 如果 sideTableLocked 为 true，解锁 side table
59.         if (sideTableLocked) {
60.             ASSERT(variant == RRVariant::Full);
61.             sidetable_unlock();
62.         }
63.         // 如果 tryRetain 为 true，返回 nil，表示无法增加引用计数；否则返回对象本身
64.         if (slowpath(tryRetain)) {
65.             return nil;
66.         } else {
67.             return (id)this;
68.         }
69.     }
70.    
71.     uintptr_t carry;
72.     // 增加引用计数，即对 newisa.bits 中的引用计数位进行加一操作
73.     newisa.bits = addc(newisa.bits, RC_ONE, 0, &carry);  // extra_rc++
74.    
75.     // 检查引用计数是否溢出
76.     if (slowpath(carry)) {
77.         // 如果引用计数溢出，且 variant 不为 Full，清除 isa 的原子锁并调用 rootRetain_overflow
78.         if (variant != RRVariant::Full) {
79.             ClearExclusive(&isa().bits);
80.             return rootRetain_overflow(tryRetain);
81.         }
82.         // 保留一半的引用计数在 inline，并准备将另一半复制到 side table
83.         if (!tryRetain && !sideTableLocked) sidetable_lock();
84.         sideTableLocked = true;
85.         transcribeToSideTable = true;
86.         newisa.extra_rc = RC_HALF;
87.         newisa.has_sidetable_rc = true;
88.     }
89. // 尝试将 newisa 存储到 isa.bits 中，如果存储失败，则循环重新尝试
90. } while (slowpath(!StoreExclusive(&isa().bits, &oldisa.bits, newisa.bits)));
93.     if (variant == RRVariant::Full) {
94.         if (slowpath(transcribeToSideTable)) {
95.             // 把剩下的一半放到 side table.
96.             sidetable_addExtraRC_nolock(RC_HALF);
97.         }
99.         if (slowpath(!tryRetain && sideTableLocked)) sidetable_unlock();
100.     } else {
101.         ASSERT(!transcribeToSideTable);
102.         ASSERT(!sideTableLocked);
103.     }
105.     return (id)this;
106. }

复制代码

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

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

复制代码

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

release

源码：

1. // Equivalent to calling [this release], with shortcuts if there is no override
2. inline void
3. objc_object::release()
4. {
5.     ASSERT(!isTaggedPointer());
7.     rootRelease(true, RRVariant::FastOrMsgSend);
8. }
10. ALWAYS_INLINE bool
11. objc_object::rootRelease()
12. {
13.     return rootRelease(true, RRVariant::Fast);
14. }
16. inline void
17. objc_object::release()
18. {
19.     ASSERT(!isTaggedPointer());
21.     if (fastpath(!ISA()->hasCustomRR())) {
22.         // Standard RR of a class is a no-op.
23.         if (!ISA()->isMetaClass())
24.             sidetable_release();
25.         return;
26.     }
28.     ((void(*)(objc_object *, SEL))objc_msgSend)(this, @selector(release));
29. }

复制代码

2. ALWAYS_INLINE bool
3. objc_object::rootRelease(bool performDealloc, objc_object::RRVariant variant)
4. {
5.     // 如果是标记指针，直接返回 false
6.     if (slowpath(isTaggedPointer())) return false;
8.     bool sideTableLocked = false; // 用于标记侧表是否被锁定
10.     isa_t newisa, oldisa; // 定义 isa_t 类型的变量 newisa 和 oldisa
12.     // 加载 isa 值到 oldisa 中
13.     oldisa = LoadExclusive(&isa().bits);
15.     // 如果引用计数变种是 FastOrMsgSend
16.     if (variant == RRVariant::FastOrMsgSend) {
17.         // 这些检查仅对 objc_release() 有意义
18.         // 它们在这里是为了避免重新加载 isa
19.         if (slowpath(oldisa.getDecodedClass(false)->hasCustomRR())) {
20.             ClearExclusive(&isa().bits); // 清除独占标记
21.             if (oldisa.getDecodedClass(false)->canCallSwiftRR()) {
22.                 // 如果可以调用 Swift 的引用计数方法
23.                 swiftRelease.load(memory_order_relaxed)((id)this);
24.                 return true;
25.             }
26.             // 调用 objc_msgSend 的 release 方法
27.             ((void(*)(objc_object *, SEL))objc_msgSend)(this, @selector(release));
28.             return true;
29.         }
30.     }
32.     // 检查 isa 是否为指针形式
33.     if (slowpath(!oldisa.nonpointer)) {
34.         // 一个类永远是一个类，所以我们可以在 CAS 循环外进行此检查
35.         if (oldisa.getDecodedClass(false)->isMetaClass()) {
36.             ClearExclusive(&isa().bits); // 清除独占标记
37.             return false;
38.         }
39.     }
41. #if !ISA_HAS_INLINE_RC
42.     // 如果不支持内联引用计数，使用侧表
43.     ClearExclusive(&isa().bits); // 清除独占标记
44.     return sidetable_release(sideTableLocked, performDealloc);
45. #else
46. retry:
47.     do {
48.         newisa = oldisa; // 将 oldisa 赋值给 newisa
49.         if (slowpath(!newisa.nonpointer)) {
50.             ClearExclusive(&isa().bits); // 清除独占标记
51.             return sidetable_release(sideTableLocked, performDealloc);
52.         }
53.         if (slowpath(newisa.isDeallocating())) {
54.             ClearExclusive(&isa().bits); // 清除独占标记
55.             if (sideTableLocked) {
56.                 ASSERT(variant == RRVariant::Full);
57.                 sidetable_unlock(); // 解锁侧表
58.             }
59.             return false;
60.         }
62.         // 不检查 newisa.fast_rr; 我们已经调用了任何 RR 重载
63.         uintptr_t carry;
64.         newisa.bits = subc(newisa.bits, RC_ONE, 0, &carry); // extra_rc--
65.         if (slowpath(carry)) {
66.             // 不清除独占标记
67.             goto underflow;
68.         }
69.     } while (slowpath(!StoreReleaseExclusive(&isa().bits, &oldisa.bits, newisa.bits)));
71.     if (slowpath(newisa.isDeallocating()))
72.         goto deallocate;
74.     if (variant == RRVariant::Full) {
75.         if (slowpath(sideTableLocked)) sidetable_unlock();
76.     } else {
77.         ASSERT(!sideTableLocked);
78.     }
79.     return false;
81. underflow:
82.     // newisa.extra_rc-- 下溢：从侧表借用或析构
84.     // 放弃 newisa 以撤销递减
85.     newisa = oldisa;
87.     if (slowpath(newisa.has_sidetable_rc)) {
88.         if (variant != RRVariant::Full) {
89.             ClearExclusive(&isa().bits); // 清除独占标记
90.             return rootRelease_underflow(performDealloc);
91.         }
93.         // 将引用计数从侧表转移到内联存储
95.         if (!sideTableLocked) {
96.             ClearExclusive(&isa().bits); // 清除独占标记
97.             sidetable_lock(); // 锁定侧表
98.             sideTableLocked = true;
99.             // 需要重新开始以避免与指针非指针转换的竞争
100.             oldisa = LoadExclusive(&isa().bits);
101.             goto retry;
102.         }
104.         // 尝试从侧表中删除一些引用计数
105.         auto borrow = sidetable_subExtraRC_nolock(RC_HALF);
107.         bool emptySideTable = borrow.remaining == 0; // 如果侧表中没有引用计数，将清空侧表
109.         if (borrow.borrowed > 0) {
110.             // 侧表引用计数减少
111.             // 尝试将它们添加到内联计数
112.             bool didTransitionToDeallocating = false;
113.             newisa.extra_rc = borrow.borrowed - 1; // 重新执行原始递减
114.             newisa.has_sidetable_rc = !emptySideTable;
116.             bool stored = StoreReleaseExclusive(&isa().bits, &oldisa.bits, newisa.bits);
118.             if (!stored && oldisa.nonpointer) {
119.                 // 内联更新失败
120.                 // 立即重试。这可以防止在 LL/SC 架构上发生活锁，
121.                 // 因为侧表访问本身可能会丢失预留
122.                 uintptr_t overflow;
123.                 newisa.bits =
124.                     addc(oldisa.bits, RC_ONE * (borrow.borrowed-1), 0, &overflow);
125.                 newisa.has_sidetable_rc = !emptySideTable;
126.                 if (!overflow) {
127.                     stored = StoreReleaseExclusive(&isa().bits, &oldisa.bits, newisa.bits);
128.                     if (stored) {
129.                         didTransitionToDeallocating = newisa.isDeallocating();
130.                     }
131.                 }
132.             }
134.             if (!stored) {
135.                 // 内联更新失败
136.                 // 将保留重新放回侧表
137.                 ClearExclusive(&isa().bits);
138.                 sidetable_addExtraRC_nolock(borrow.borrowed);
139.                 oldisa = LoadExclusive(&isa().bits);
140.                 goto retry;
141.             }
143.             // 从侧表借用后的递减成功
144.             if (emptySideTable)
145.                 sidetable_clearExtraRC_nolock();
147.             if (!didTransitionToDeallocating) {
148.                 if (slowpath(sideTableLocked)) sidetable_unlock();
149.                 return false;
150.             }
151.         }
152.         else {
153.             // 侧表最终为空，进入析构路径
154.         }
155.     }
157. deallocate:
158.     // 真的要析构了
160.     ASSERT(newisa.isDeallocating());
161.     ASSERT(isa().isDeallocating());
163.     if (slowpath(sideTableLocked)) sidetable_unlock();
165.     __c11_atomic_thread_fence(__ATOMIC_ACQUIRE);
167.     if (performDealloc) {
168.         this->performDealloc();
169.     }
170.     return true;
171. #endif // ISA_HAS_INLINE_RC
172. }

复制代码

1. uintptr_t
2. objc_object::sidetable_release(bool locked, bool performDealloc)
3. {
4. #if SUPPORT_NONPOINTER_ISA
5.     ASSERT(!isa().nonpointer);
6. #endif
7.     // 获取当前对象的侧表
8.     SideTable& table = SideTables()[this];
10.     bool do_dealloc = false; // 标记是否需要析构
12.     // 如果未锁定侧表，先锁定它
13.     if (!locked) table.lock();
14.    
15.     // 尝试在侧表的引用计数字典中插入一个新条目
16.     // 如果该对象不在侧表中，插入 {this, SIDE_TABLE_DEALLOCATING}
17.     auto it = table.refcnts.try_emplace(this, SIDE_TABLE_DEALLOCATING);
18.     auto &refcnt = it.first->second; // 获取引用计数
20.   //判断是否进行了插入操作
21.     if (it.second) {
22.         // 如果对象之前不在侧表中，表示这是第一次插入
23.         // 设置 do_dealloc 为 true，表示需要析构
24.         do_dealloc = true;
25.     } else if (refcnt < SIDE_TABLE_DEALLOCATING) {
26.         // 如果引用计数小于 SIDE_TABLE_DEALLOCATING
27.         // 表示引用计数为负数，可能设置了 SIDE_TABLE_WEAKLY_REFERENCED
28.         // 设置 do_dealloc 为 true，并将引用计数标记为 SIDE_TABLE_DEALLOCATING
29.         do_dealloc = true;
30.         refcnt |= SIDE_TABLE_DEALLOCATING;
31.     } else if (! (refcnt & SIDE_TABLE_RC_PINNED)) {
32.         // 如果引用计数未固定（未设置 SIDE_TABLE_RC_PINNED）
33.         // 将引用计数减一
34.         refcnt -= SIDE_TABLE_RC_ONE;
35.     }
37.     // 解锁侧表
38.     table.unlock();
40.     // 如果需要析构且 performDealloc 为真，执行析构操作
41.     if (do_dealloc && performDealloc) {
42.         this->performDealloc();
43.     }
45.     // 返回是否需要析构
46.     return do_dealloc;
47. }

复制代码

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

dealloc

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

1. inline void objc_object::rootDealloc()
2. {
3.     // 如果对象是 tagged pointer（标记指针），直接返回
4.     if (isTaggedPointer()) return;  // fixme necessary?
5.    
6. #if !ISA_HAS_INLINE_RC
7.     // 如果没有内联引用计数，直接调用 object_dispose 释放对象
8.     object_dispose((id)this);
9. #else
10.     // 如果有内联引用计数，并且满足以下所有条件，则直接释放内存
11.     if (fastpath(isa().nonpointer &&               // 非指针 ISA
12.                  !isa().weakly_referenced &&       // 没有弱引用
13.                  !isa().has_assoc &&               // 没有关联对象
14. #if ISA_HAS_CXX_DTOR_BIT
15.                  !isa().has_cxx_dtor &&            // 没有 C++ 析构函数
16. #else
17.                  !isa().getClass(false)->hasCxxDtor() && // 没有 C++ 析构函数
18. #endif
19.                  !isa().has_sidetable_rc))         // 没有使用 side table 引用计数
20.     {
21.         // 确认没有 side table 存在
22.         assert(!sidetable_present());
23.         // 直接释放内存
24.         free(this);
25.     }
26.     else {
27.         // 否则，调用 object_dispose 释放对象
28.         object_dispose((id)this);
29.     }
30. #endif // ISA_HAS_INLINE_RC
31. }

复制代码

用于销毁和释放对象：

1. id object_dispose(id obj)
2. {
3.     // 如果 obj 是空指针，则直接返回 nil
4.     if (!obj) return nil;
6.     // 调用 objc_destructInstance 函数，销毁对象实例的内容
7.     objc_destructInstance(obj);
8.    
9.     // 释放对象所占用的内存
10.     free(obj);
12.     // 返回 nil，表示对象已被销毁
13.     return nil;
14. }

复制代码

1. objc_object::clearDeallocating()
2. {
3.     if (slowpath(!isa.nonpointer)) {
4.         // Slow path for raw pointer isa.
5.         // 如果要释放的对象没有采用了优化过的isa引用计数
6.         sidetable_clearDeallocating();
7.     }
8.     else if (slowpath(isa.weakly_referenced  ||  isa.has_sidetable_rc)) {
9.         // Slow path for non-pointer isa with weak refs and/or side table data.
10.         // 如果要释放的对象采用了优化过的isa引用计数，并且有弱引用或者使用了sideTable的辅助引用计数
11.         clearDeallocating_slow();
12.    }
13.    //确保 side table 中没有该对象的引用计数记录。
14.     assert(!sidetable_present());
15. }

复制代码

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

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

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

复制代码

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

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

1. NEVER_INLINE void
3. objc_object::clearDeallocating_slow()
5. {
6.     assert(isa.nonpointer  &&  (isa.weakly_referenced || isa.has_sidetable_rc));
8.     // 在全局的SideTables中，以this指针(要释放的对象)为key，找到对应的SideTable
9.     SideTable& table = SideTables()[this];
10.     table.lock();
11.     if (isa.weakly_referenced) {
12.         //要释放的对象被弱引用了，通过weak_clear_no_lock函数将指向该对象的弱引用指针置为nil
13.         weak_clear_no_lock(&table.weak_table, (id)this);
14.     }
15.     //使用了sideTable的辅助引用计数,直接在SideTable中擦除该对象的引用计数
16.     if (isa.has_sidetable_rc) {
17.         table.refcnts.erase(this);
18.     }
19.     table.unlock();
20. }

复制代码

找到对应的 SideTable，并对其加锁。
如果对象被弱引用，整理弱引用。
如果对象使用了 side table 的引用计数，擦除该对象的引用计数。
末了解锁 SideTable。
以上两种情况都涉及weak_clear_no_lock函数, 它的作用就是将被弱引用对象的弱引用指针置为nil.
dealloc的流程：如果对象是 tagged pointer，则直接返回。如果没有内联引用计数，调用 object_dispose 释放对象；如果有内联引用计数，而且对象满意非指针 ISA、没有弱引用、没有关联对象、没有 C++ 析构函数以及没有使用 side table 引用计数等条件，则直接释放内存。否则，调用 object_dispose 进行标准的对象销毁和内存释放。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。