十二：底层探索 |
您所在的位置：网站首页 › 快速扫描发票的机器 › 十二：底层探索 |
十二：底层探索
|
在平时的开发中，我们通常会用weak来打破循环引用，避免内存泄漏。weak 关键字的作用是弱引用，所修饰对象的retainCount引用计数器不会加1，并在引用对象被释放的时候自动被设置为nil。本篇章我们就从底层来探索一下weak的实现原理。 一： weak初识 #import #import "WYPerson.h" int main(int argc, const char * argv[]) { @autoreleasepool { WYPerson *person =[[WYPerson alloc]init]; id __weak weakPerson = person; } return 0; }通过跟踪汇编和下符号断点的方式，我们把目标指向了objc_initWeak。 二：weak创建 1. objc_initWeak老规矩，看下objc_initWeak的定义 id objc_initWeak(id *location, id newObj) { if (!newObj) { *location = nil; return nil; } return storeWeak (location, (objc_object*)newObj); } location：表示__weak指针的地址，即例子中的weak指针取地址： &weakPerson ,它是一个指针的地址。 newObj：所引用的对象，即例子中的person 。 2. storeWeak注意：下面的代码已经去掉部分非重点的注释，需要看完整代码的朋友可以自行看下源码 static id storeWeak(id *location, objc_object *newObj) { assert(haveOld || haveNew); if (!haveNew) assert(newObj == nil); Class previouslyInitializedClass = nil; id oldObj; SideTable *oldTable; SideTable *newTable; retry: 🌹// 如果weak指针之前弱引用过一个obj，则将这个obj所对应的SideTable取出，赋值给oldTable if (haveOld) { oldObj = *location; oldTable = &SideTables()[oldObj]; } else { // 没有弱引用过，则oldTable = nil oldTable = nil; } 🌹// 如果weak指针要弱引用一个新的obj，则将该obj对应的SideTable取出，赋值给newTable if (haveNew) { newTable = &SideTables()[newObj]; } else { newTable = nil; } 🌹// 加锁操作，防止多线程中竞争冲突 SideTable::lockTwo(oldTable, newTable); 🌹// location 应该与 oldObj 保持一致，如果不同，说明当前的 location 已经处理过 oldObj 可是又被其他线程所修改 if (haveOld && *location != oldObj) { SideTable::unlockTwo(oldTable, newTable); goto retry; } if (haveNew && newObj) { Class cls = newObj->getIsa(); 🌹// 如果cls还没有初始化，先初始化，再尝试设置弱引用 if (cls != previouslyInitializedClass && !((objc_class *)cls)->isInitialized()) { SideTable::unlockTwo(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; 🌹// newObj 初始化后，重新获取一遍newObj goto retry; } } // Clean up old value, if any. 🌹// 如果weak指针之前弱引用过别的对象oldObj，则调用weak_unregister_no_lock，在oldObj的weak_entry_t中移除该weak指针地址 if (haveOld) { weak_unregister_no_lock(&oldTable->weak_table, oldObj, location); } // Assign new value, if any. 🌹// 如果weak指针需要弱引用新的对象newObj if (haveNew) { 🌹 // 调用weak_register_no_lock方法，将weak指针的地址记录到newObj对应的weak_entry_t中 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. 🌹// 更新newObj的isa指针的weakly_referenced bit标志位 if (newObj && !newObj->isTaggedPointer()) { newObj->setWeaklyReferenced_nolock(); } // Do not set *location anywhere else. That would introduce a race. 🌹// *location 赋值，也就是将weak指针直接指向了newObj，而且没有将newObj的引用计数+1 *location = (id)newObj; } else { // No new value. The storage is not changed. } SideTable::unlockTwo(oldTable, newTable); return (id)newObj; } HaveOld：weak指针之前是否已经指向了一个弱引用 HaveNew：weak指针是否需要指向一个新引用 CrashIfDeallocating：如果被弱引用的对象正在析构，此时再弱引用该对象，是否应该crash。此处我们看到代码中涉及到一个SideTable，可以看这篇文章 了解一下。SideTable在底层也是一个结构体类型，而对weak对象就是通过 weak_table来进行管理的，这是一个弱引用表,类型是weak_table_t。 struct SideTable { spinlock_t slock; // 自旋锁，用于上锁/解锁 SideTable RefcountMap refcnts; // 引用计数表 weak_table_t weak_table; // 弱引用表 ......省略部分 };weak_table_t也是一个结构体，其中关于weak_entry_t也一并贴出 struct weak_table_t { weak_entry_t *weak_entries; size_t num_entries; uintptr_t mask; uintptr_t max_hash_displacement; }; struct weak_entry_t { DisguisedPtr 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]; }; }; ......省略部分 };关于weak_table_t: weak_entries： hash数组，用来存储弱引用对象的相关信息weak_entry_t num_entries： hash数组中的元素个数 mask：hash数组长度-1，会参与hash计算。（注意，这里是hash数组的长度，而不是元素个数。比如，数组长度可能是64，而元素个数仅存了2个） max_hash_displacement：可能会发生的hash冲突的最大次数，用于判断是否出现了逻辑错误（hash表中的冲突次数绝不会超过改值）关于weak_entry_t： referrers: 是指向weak对象的所有变量。 referent: 是内存上的weak对象。看完SideTable的相关，下面不妨来个小小的总结： weak表是一个弱引用表，实现为一个weak_table_t结构体，存储了所有对象相关的的所有的弱引用信息。 weak_entry_t是存储在弱引用表中的一个内部结构体，它负责维护和存储指向一个对象的所有弱引用hash表。 weak_entry_t中的referrers 存储了指向weak对象的所有变量。用一张图来表示下这个关系或许更直观 图片来源 言归正传，回到storeWeak中，我们首次进入会走weak_register_no_lock，进行弱引用添加。 3. weak_register_no_lock已加上部分注释 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; 🌹// 如果被弱引用对象referent为nil 或者被弱引用对象采用了TaggedPointer计数方式，则直接返回 if (!referent || referent->isTaggedPointer()) return referent_id; // ensure that the referenced object is viable 🌹// 确保被引用的对象可用（没有在析构，同时应该支持weak弱引用） 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_table 中找到被弱引用对象 referent 对应的 weak_entry,并将 referrer 加入到 weak_entry 中 weak_entry_t *entry; if ((entry = weak_entry_for_referent(weak_table, referent))) { 🌹// 如果能找到 weak_entry,则讲 referrer 插入到 weak_entry 中 append_referrer(entry, referrer); } else { 🌹// 如果找不到 weak_entry，就新建一个 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_table：weak_table_t结构类型的全局的弱引用表。 referent_id：weak指针。 *referrer_id：weak指针地址。 crashIfDeallocating：若果被弱引用的对象正在析构，此时再弱引用该对象是否应该crash。weak_register_no_lock流程小结： 如果referent为nil 或 referent 采用了TaggedPointer计数方式，直接返回，不做任何操作。 如果对象正在析构，则抛出异常。 如果对象不能被weak引用，直接返回nil。 如果对象没有再析构且可以被weak引用，则调用weak_entry_for_referent方法根据弱引用对象的地址从弱引用表中找到对应的weak_entry 如果能够找到则调用append_referrer方法向其中插入weak指针地址。 否则新建一个weak_entry。 4. append_referrer源码已加上部分注释 static void append_referrer(weak_entry_t *entry, objc_object **new_referrer) { 🌹// 如果weak_entry 使用静态数组 inline_referrers if (! entry->out_of_line()) { // Try to insert inline. 🌹// 尝试将 referrer 插入数组 for (size_t i = 0; i < WEAK_INLINE_COUNT; i++) { if (entry->inline_referrers[i] == nil) { entry->inline_referrers[i] = new_referrer; return; } } // Couldn't insert inline. Allocate out of line. 🌹// 如果inline_referrers的位置已经存满了，则要转型为 referrers，动态数组 weak_referrer_t *new_referrers = (weak_referrer_t *) calloc(WEAK_INLINE_COUNT, sizeof(weak_referrer_t)); // This constructed table is invalid, but grow_refs_and_insert // will fix it and rehash it. 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()); 🌹// 如果动态数组中元素个数大于或等于数组总空间的3/4，则扩展数组空间为当前长度的一倍，然后将 referrer 插入数组 if (entry->num_refs >= TABLE_SIZE(entry) * 3/4) { return grow_refs_and_insert(entry, new_referrer); } 🌹// 如果不需要扩容，直接插入到weak_entry中 🌹// & (entry->mask) 保证 begin 的位置只能大于或等于数组的长度 size_t begin = w_hash_pointer(new_referrer) & (entry->mask); size_t index = begin; size_t hash_displacement = 0; while (entry->referrers[index] != nil) { hash_displacement++; 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; } weak_referrer_t &ref = entry->referrers[index]; ref = new_referrer; entry->num_refs++; }append_referrer所做的就是先找到弱引用对象的对应的weak_entry哈希数组，遍历插入，当然其中还伴随着扩容的操作 5. weak_unregister_no_lock如果weak指针之前指向了一个弱引用，则会调用这个方法将旧的weak指针地址移除。 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; 🌹// 查找到以前弱引用的对象 referent 所对应的 weak_entry_t if ((entry = weak_entry_for_referent(weak_table, referent))) { 🌹// 在以前弱引用的对象 referent 所对应的 weak_entry_t 的 hash 数组中，移除弱引用 referrer remove_referrer(entry, referrer); 🌹// 移除元素之后， 要检查一下 weak_entry_t 的 hash 数组是否已经空了 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 的hash数组已经空了，则需要将 weak_entry_t 从 weak_table 中移除 if (empty) { weak_entry_remove(weak_table, entry); } } // Do not set *referrer = nil. objc_storeWeak() requires that the // value not change. } 在weak_table中找出以前被弱引用的对象referent对应的weak_entry_t，在weak_entry_t中移除被弱引用的对象referrer。 移除元素后，判断此时weak_entry_t中是否还有元素。 如果此时weak_entry_t已经没有元素了，则需要将weak_entry_t从weak_table中移除。 三：weak释放weak的释放和上一篇章讲的关联对象的释放都在dealloc中进行，让我们加深下印象。 1. dealloc - (void)dealloc { _objc_rootDealloc(self); } void _objc_rootDealloc(id obj) { ASSERT(obj); obj->rootDealloc(); } inline void objc_object::rootDealloc() { if (isTaggedPointer()) return; // fixme necessary? 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); } }首先看下代码中的判断条件： 是优化过的isa、 没有被weak指针引用过、 没有关联对象、 没有C++析构函数、 没有sideTable，weak修饰的话就直接object_dispose 2. object_dispose在内部调用了objc_destructInstance id object_dispose(id obj) { if (!obj) return nil; objc_destructInstance(obj); free(obj); return nil; } *********************************** 3. objc_destructInstance void *objc_destructInstance(id obj) { if (obj) { // Read all of the flags at once for performance bool cxx = obj->hasCxxDtor(); bool assoc = obj->hasAssociatedObjects(); // This order is important. 🌹 // 如果有C++析构函数，则从运行相关函数 if (cxx) object_cxxDestruct(obj); 🌹// 如果有关联对象，则移除所有的关联对象，并将其自身从Association Manager的map中移除 if (assoc) _object_remove_assocations(obj); 🌹// 继续清理其它相关的引用 obj->clearDeallocating(); } return obj; }关联对象的移除就是在这里发生，而弱引用相关的是在clearDeallocating 4. clearDeallocating inline void 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(); } assert(!sidetable_present()); }一般的对象都是优化过的isa,一般都会走到clearDeallocating_slow中 5. clearDeallocating_slow NEVER_INLINE void objc_object::clearDeallocating_slow() { assert(isa.nonpointer && (isa.weakly_referenced || isa.has_sidetable_rc)); 🌹// 在全局的SideTables中，以this指针(要释放的对象)为key，找到对应的SideTable SideTable& table = SideTables()[this]; table.lock(); if (isa.weakly_referenced) { 🌹//要释放的对象被弱引用了，通过weak_clear_no_lock函数将指向该对象的弱引用指针置为nil weak_clear_no_lock(&table.weak_table, (id)this); } 🌹//使用了sideTable的辅助引用计数,直接在SideTable中擦除该对象的引用计数 if (isa.has_sidetable_rc) { table.refcnts.erase(this); } table.unlock(); }在SideTable找到对应的SideTable,然后在SideTable的weak_table中，将弱引用对象置空，主要的方法为weak_clear_no_lock。 6. 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在weak_table中对应的weak_entry_t 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; 🌹// 找出弱引用该对象的所有weak指针地址数组 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) { 🌹// 如果weak指针确实弱引用了对象 referent，则将weak指针设置为nil if (*referrer == referent) { *referrer = nil; } 🌹// 如果所存储的weak指针没有弱引用对象 referent，这可能是由于runtime代码的逻辑错误引起的，报错 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_entry_remove(weak_table, entry); }获取弱引用对象的地址，再找到与之相对应的对应的weak_table中的eak_entry_t数组，然后通过遍历找到对应的指针地址，采用最简单粗暴的方式直接置为nil，防止野指针。 四：流程图 weak创建流程图SideTables, SideTable, weak_table, weak_entry_t 从源码深入探究weak的实现 内存管理之weak原理探究 |
【本文地址】
今日新闻 |
推荐新闻 |