手撕 weak 源码

weak

来先复原一个小场景：

面试官：OC 中 weak 的作用和它的基本原理是什么？

你：weak 是一个修饰词，在开发中为避免出现对象之间的强引用而造成对象不能被正常释放而导致内存泄露的问题，我们会使用 weak 来修饰源码编辑器下载对象。weak 关键字的作用是弱引用，所引用对象的计数器不会加1，并在引用对象被释放的时候自动被设置为 nil。weak 的原理其实就是 runtime 维面试技巧护了一张 hashMap ,然后系统根据 使用了一系列的 hash 算法将 weak 修饰的对象 以 Key – Value 的形式保存在了这张 ha面试常见问题及回答技巧shMap 里。…………

来来来 …… 对号入座，是不是各位都是这么回答的。 其实之前我面龚俊试的时候也是这么回答的。直到有一天我发现了一张这样的 UML 图：

然后我瞬间顿(meng)悟(B)了，这 TM 的不就是 w源码网站eak 的整个数据结构嘛，然后我就根据我自己的理解加上简（fei）简(jin)单(ba)单(la)地研究了下 object 的源码我又画了这么一张思维导算法的特性图：

看到这里是不是你也源码顿(meng)悟(B)了。哈哈 ………… 莫急算法的时间复杂度取决于莫急，让我看来看看代码。 以下代码全部是在源码环境实现，需要源码的可以点数据结构有哪些击 →这里

搞一个weak 对象，打上断点，然后在打个汇编联调模式。 Debug --> Debug Work flow -算法的时间复杂度是指什么-&g数据结构c语言版严蔚敏第二版答案t;Always Show Disassembly

然后你会发现进到源码编辑器一个这样的神奇的断点，objc_initWeak

然后你全局搜一下就会发现下边的代码源码编辑器手机版下载

objc_initWeak(id *location, id newObj){
  if (!newObj) { // 如果 当前对象为空 直接返回 nil
    *location = nil;
    return nil;
  }
// 否则执行这段代码
  return storeWeak<DontHaveOld, DoHaveNew, DoCrashIfDeallocating>
    (location, (objc_object*)newObj);
}

storeWeak(id *location, objc_object *newObj)
{
  ASSERT(haveOld || haveNew);
  if (!haveNew) ASSERT(newObj == nil);
  Class previouslyInitializedClass = nil;
  id oldObj;
  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) {
    oldObj = *location;
    oldTable = &SideTables()[oldObj];
  } else {
    oldTable = nil;
  }
  if (haveNew) {
    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();
    if (cls != previouslyInitializedClass && 
      !((objc_class *)cls)->isInitialized())
    {
      SideTable::unlockTwo<haveOld, haveNew>(oldTable, newTable);
      class_initialize(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) {
    newObj = (objc_object *)
      weak_register_no_lock(&newTable->weak_table, (id)newObj, location,
                 crashIfDeallocating ? CrashIfDeallocating : ReturnNilIfDeallocating);
    // weak_register_no_lock returns nil if weak store should be rejected
    // Set is-weakly-referenced bit in refcount table.
    if (!newObj->isTaggedPointerOrNil()) {
      newObj->setWeaklyReferenced_nolock();
    }
    // Do not set *location anywhere else. That would introduce a race.
    *location = (id)newObj;
  }
  else {
    // No new value. The storage is not changed.
  }
  SideTable::unlockTwo<haveOld, haveNew>(oldTable, newTable);
  // This must be called without the locks held, as it can invoke
  // arbitrary code. In particular, even if _setWeaklyReferenced
  // is not implemented, resolveInstanceMethod: may be, and may
  // call back into the weak reference machinery.
  callSetWeaklyReferenced((id)newObj);
  return (id)newObj;
}
///存储
weak_register_no_lock(weak_table_t *weak_table, id referent_id, 
                      id *referrer_id, WeakRegisterDeallocatingOptions deallocatingOptions)
{
    objc_object *referent = (objc_object *)referent_id;
    objc_object **referrer = (objc_object **)referrer_id;
    if (referent->isTaggedPointerOrNil()) return referent_id;
    // ensure that the referenced object is viable
    if (deallocatingOptions == ReturnNilIfDeallocating ||
        deallocatingOptions == CrashIfDeallocating) {
        bool deallocating;
        if (!referent->ISA()->hasCustomRR()) {
            deallocating = referent->rootIsDeallocating();
        }
        else {
            // Use lookUpImpOrForward so we can avoid the assert in
            // class_getInstanceMethod, since we intentionally make this
            // callout with the lock held.
            auto allowsWeakReference = (BOOL(*)(objc_object *, SEL))
            lookUpImpOrForwardTryCache((id)referent, @selector(allowsWeakReference),
                                       referent->getIsa());
            if ((IMP)allowsWeakReference == _objc_msgForward) {
                return nil;
            }
            deallocating =
            ! (*allowsWeakReference)(referent, @selector(allowsWeakReference));
        }
        if (deallocating) {
            if (deallocatingOptions == 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;
    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;
}
///
/** 
 * Return the weak reference table entry for the given referent. 
 * If there is no entry for referent, return NULL. 
 * Performs a lookup.
 *
 * @param weak_table 
 * @param referent The object. Must not be nil.
 * 
 * @return The table of weak referrers to this object. 
 */
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;
    size_t begin = hash_pointer(referent) & weak_table->mask;
    size_t index = begin;
    size_t hash_displacement = 0;
    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];
}

哈哈哈 是不是 在骂我，全TM 是源码，没错我感觉源码就是最好的东西，上边 关键的注释我都做了翻译，慢慢看你就能看懂了，兄 dei ~ 加油算法

来，接下来在看看 dealloc 的源码

在 Object 源码环境全局搜索一算法的有穷性是指下

// Replaced by CF (throws an NS Exception)
// 类方法没有实现 这里被替换了 返回一个异常
+ (void)dealloc {
}
// Replaced by NSZombies
- (void)dealloc {
    _objc_rootDealloc(self);
}

_objc_rootDeal巩汉林回应冯潇霆loc —> rootDealloc() —>

inline void
objc_object::rootDealloc()
{
    if (isTaggedPointer()) return;  // fixme necessary?
    if (fastpath(isa.nonpointer                     &&
                 !isa.weakly_referenced             &&
                 !isa.has_assoc                     &&
#if ISA_HAS_CXX_DTOR_BIT
                 !isa.has_cxx_dtor                  &&
#else
                 !isa.getClass(false)->hasCxxDtor() &&
#endif
                 !isa.has_sidetable_rc))
    {// 这边都是直接销毁 self
        assert(!sidetable_present());
        free(this);
    } 
    else {// 这里是 在 weak Map 里边查找 self 的入口
        object_dispose((id)this);
    }
}

可以先按我工行2.5亿存款不翼而飞的步骤一步步往里走，或者是自己慢慢研究

object_dispose —>object_d面试自我介绍一分钟isp算法的五个特性ose—>objc_destructInstance—>clearDeallocating — clearDeallocating_slow —>weak_clear_no_lock

/**
 * Called by dealloc; nils out all weak pointers that point to the 
 *  由dealloc调用;对象的所有弱指针
 * provided object so that they can no longer be used.
 * 提供的对象，使它们不再被使用
 * @param weak_table 
 * @param referent The object being deallocated. 
 */
void 
weak_clear_no_lock(weak_table_t *weak_table, id referent_id) 
{
    objc_object *referent = (objc_object *)referent_id;
    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 %pn", referent);
        return;
    }
    // zero out references
    weak_referrer_t *referrers;
    size_t count;
    if (entry->out_of_line()) {
        referrers = entry->referrers;
        count = TABLE_SIZE(entry);
    } 
    else {
        referrers = entry->inline_referrers;
        count = WEAK_INLINE_COUNT;
    }
    /// for 循环 就问你 能不能看懂 就问你屌不屌
    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_entry_remove(weak_table, entry);
}

结论

• 初始化时：runtime会调用objc_initWeak函数，初始数据结构化一个新的weak指针指向对象的地址面试常见问题及回答技巧。
• 添加引用时：objc数据结构教程第5版李春葆答案_initWeak函数会调用objc_storeWeak()函数，objc_storeWeak()的作用是更新指针指向，创建对应的弱引用表。
• 释放时，调用clearDeallocating函数。clearDeallocating函数首先根据对象地址获取所有weak指针地址的数组，然后遍历这个数组把其中的数据设google为nil，最后把这个entry从weak表中删除工行2.5亿存款不翼而飞，最后清理对象的记录。