OC 和 Swift 的弱引用源码分析

id objc_initWeak(id *location, id newObj)
{
    // 查看对象是否有效
    // 无效对象立刻使指针置空
    if (!newObj) {
        *location = nil;
        return nil;
    }

    return storeWeak<DontHaveOld, DoHaveNew, DoCrashIfDeallocating>
        (location, (objc_object*)newObj);
}

template <HaveOld haveOld, HaveNew haveNew, CrashIfDeallocating crashIfDeallocating>
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:
    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) {
        // 线程冲突处理，
        // 如果有旧值，但 location 指向的对象不为 oldObj，那很可能被其它线程修改过，  
        // 解锁并重试
        SideTable::unlockTwo<haveOld, haveNew>(oldTable, newTable);
        goto retry;
    }

    // 确保新值的 isa 已经调用 +initialize 初始化，
    // 避免弱引用机制和 +initialize 机制间的死锁
    if (haveNew  &&  newObj) {
        // 获得新值的 isa
        Class cls = newObj->getIsa();
        if (cls != previouslyInitializedClass  &&
            !((objc_class *)cls)->isInitialized())
        {
            // 新值 isa 非空，并且未初始化，
            // 解锁
            SideTable::unlockTwo<haveOld, haveNew>(oldTable, newTable);
            // 初始化 isa
            _class_initialize(_class_getNonMetaClass(cls, (id)newObj));

            // 如果这个 isa 正在当前线程运行 +initialize
            //（例如在 +initialize 方法里对自己的实例调用了 storeWeak ），
            // 很显然会处于一个正在初始化，但未初始化完的状态，
            // 所以设置 previouslyInitializedClass 为这个类进行标记
            previouslyInitializedClass = cls;

            // 重试
            goto retry;
        }
    }

    // 清除旧值
    if (haveOld) {
        // 从 oldObj 的弱引用条目删除弱引用的地址
        weak_unregister_no_lock(&oldTable->weak_table, oldObj, location);
    }

    // 设置新值
    if (haveNew) {
        // 把弱引用的地址注册到 newOjb 的弱引用条目
        newObj = (objc_object *)
            weak_register_no_lock(&newTable->weak_table, (id)newObj, location,
                                  crashIfDeallocating);

        // 如果 weakStore 操作应该被拒绝，weak_register_no_lock 会返回 nil，否则
        // 对被引用对象设置弱引用标记位（is-weakly-referenced bit）
        if (newObj  &&  !newObj->isTaggedPointer()) {
            newObj->setWeaklyReferenced_nolock();
        }

        *location = (id)newObj;
    }
    else {
        // 没有新值，不用更改
    }

    SideTable::unlockTwo<haveOld, haveNew>(oldTable, newTable);

    return (id)newObj;
}

struct SideTable {
    spinlock_t slock;           // 用于原子操作的自旋锁
    RefcountMap refcnts;        // 引用计数哈希表
    weak_table_t weak_table;    // weak 表

    // ...
};

reinterpret_cast <new_type> (expression)

struct weak_table_t {
    // 弱引用条目列表
    weak_entry_t *weak_entries;
    // 条目数量
    size_t    num_entries;
    // 条目列表大小
    uintptr_t mask;
    // 最大哈希偏移值
    uintptr_t max_hash_displacement;
};

typedef DisguisedPtr<objc_object *> weak_referrer_t;
#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;
            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];
        };
    };

    // ...
};

/**
 * Called by dealloc; nils out all weak pointers that point to the
 * provided object so that they can no longer be used.
 */
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) {
        return;
    }

    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;
    }

    // 把它们全置为 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_entry_remove(weak_table, entry);
}

struct WeakReference {
  uintptr_t Value;
};

void swift::swift_weakInit(WeakReference *ref, HeapObject *value) {
  ref->Value = (uintptr_t)value | WR_NATIVE;
  SWIFT_RT_ENTRY_CALL(swift_unownedRetain)(value);
}

HeapObject *swift::swift_weakLoadStrong(WeakReference *ref) {
  auto object = ref->Value;
  if (object == nullptr) return nullptr;
  if (object->refCount.isDeallocating()) {
    swift_weakRelease(object);
    ref->Value = nullptr;
    return nullptr;
  }
  return swift_tryRetain(object);
}

void swift::swift_weakRelease(HeapObject *object) {
  if (!object) return;

  if (object->weakRefCount.decrementShouldDeallocate()) {
    // Only class objects can be weak-retained and weak-released.
    auto metadata = object->metadata;
    assert(metadata->isClassObject());
    auto classMetadata = static_cast<const ClassMetadata*>(metadata);
    assert(classMetadata->isTypeMetadata());
    swift_slowDealloc(object, classMetadata->getInstanceSize(),
                      classMetadata->getInstanceAlignMask());
  }
}