weak

作用：

1. weak属性修饰符用来修饰对象，是弱引用；被weak修饰的对象引用计数不会+1，当引用的对象释放掉之后，weak会自动置为nil，从而避免野指针访问无用内存（对象被释放）而导致的crash。
2. weak修饰的对象可以避免引用循环。

原理：

runtime机制会针对每个对象生成一个weak表，这是一个hash表，key是被引用对象的指针，value是指向对象指针的weak指针地址数组（一个对象可以被多个弱引用指针指向）

weak修饰的对象的 初始化 → 销毁 的过程：

• 初始化时： runtime 会调用 objc_initweak 函数，将 weak 指针指向对象的地址
• 添加引用时：objc_initweak （objc_initweak的实现，实际上就是判断对象是否有效）函数会调用 objc_storeWeak()函数，objc_storeWeak()的作用是更新指针指向，创建对应的弱引用表
• 释放时：调用 clearDeallocating 函数。clearDeallocating 函数首先根据对象地址获取所有weak指针地址的数组，然后遍历这个数组把其中的数据设为nil，最后把这个 entry 从 weak 表中删除，最后清理对象的记录。

实现 weak 后，为什么对象释放后会自动为nil?

runtime 对注册的类会进行布局，对于weak对象会放入一个hash表中，用weak指向的对象内存地址作为key，当此对象的引用计数为0的时候会dealloc，假如weak指向的对象内存地址是a，那么就会以a为键，在这个weak表中搜索，找到所有以a为键的weak对象，从而设置为nil。

当weak引用指向的对象被释放时，又是如何处理weak指针的呢？

• 调用objc_release
• 因为对象的引用计数为0，所以指向dealloc
• 在dealloc中，调用了 _objc_rootDealloc 函数
• 在 _objc_rootDealloc中，调用了 object_dispose 函数
• 在 object_dispose中，又调用了 objc_destructInstance 函数
• 最后调用 clearDeallocating 函数。详细过程如下：
  1. 从 weak 表获取废弃对象的地址为键值的记录
  2. 将包含在记录中的所有附有 weak 修饰符变量的地址，赋值为 nil
  3. 将 weak 表中该记录删除
  4. 从引用计数表中删除废弃对象的地址为键值的记录

objc_initWeak

id
objc_initWeak(id *location, id newObj)
{
    if (!newObj) {
        *location = nil;
        return nil;
    }

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

storeWeak

// haveOld: true - 变量有值
//          false - 需要被及时清理，当前值可能为nil
//
// haveNew: true - 需要被分配的新值，当前值可能为nil
//          false - 不需要分配新值
// crashIfDeallocating: true - 说明 newObj 已经释放或者 newObj 不支持弱引用，该过程需要暂停
//                      false - 用 nil 代替存储
template <HaveOld haveOld, HaveNew haveNew,
          CrashIfDeallocating crashIfDeallocating>
static id 
storeWeak(id *location, objc_object *newObj)
{
    // 该过程用来更新弱引用指针的指向
    // 初始化 previouslyInitializedClass 指针
    Class previouslyInitializedClass = nil;
    id oldObj;
    // 声明两个 SideTable
    // 1.新旧散列创建
    SideTable *oldTable;
    SideTable *newTable;
    
    // 获得新值和旧值的锁存位置（用地址作为唯一标识）
    // 通过地址来建立索引标志，防止重复
    // 下面指向的操作会改变旧值

 retry:
    if (haveOld) {
        // 更改指针，获得以 oldObj 为索引存储的值地址
        oldObj = *location;
        oldTable = &SideTables()[oldObj];
    } else {
        oldTable = nil;
    }
    if (haveNew) {
        // 更改新值指针，获得以 newObj 为索引所存储的值地址
        newTable = &SideTables()[newObj];
    } else {
        newTable = nil;
    }

    // 加锁操作，防止多线程中竞争冲突
    SideTable::lockTwo<haveOld, haveNew>(oldTable, newTable);
    // 避免线程冲突重处理
    // location 应该与 oldObj 保持一致，如果不同，说明当前的 location 已经处理过 oldObj 可是又被其他线程所修改
    if (haveOld  &&  *location != oldObj) {
        SideTable::unlockTwo<haveOld, haveNew>(oldTable, newTable);
        goto retry;
    }

    // 防止弱引用间死锁
    // 并且通过 +initialize 初始化构造器保证所有弱引用的 isa 非空指向
    if (haveNew  &&  newObj) {
        // 获得新对象的 isa 指针
        Class cls = newObj->getIsa();
        // 判断 isa 非空且已经初始化
        if (cls != previouslyInitializedClass  &&  
            !((objc_class *)cls)->isInitialized()) 
        {   // 解锁
            SideTable::unlockTwo<haveOld, haveNew>(oldTable, newTable);
            // 对其 isa 指针进行初始化
            class_initialize(cls, (id)newObj);
   
            // 如果该类已经完成执行 +initialize 方法是最理想的情况
            // 如果该类 +initialize 在线程中
            // 例如 +initialize 正在调用 storeWeak 方法
            // 需要手动对其增加保护策略，并设置 previouslyInitializedClass 指针进行标记
            previouslyInitializedClass = cls;

            // 重新尝试
            goto retry;
        }
    }

    // 2.清除旧值
    if (haveOld) {
        weak_unregister_no_lock(&oldTable->weak_table, oldObj, location);
    }

    // 3.分配新值
    if (haveNew) {
        newObj = (objc_object *)
            weak_register_no_lock(&newTable->weak_table, (id)newObj, location, 
                                  crashIfDeallocating);
        // 如果弱引用被释放 weak_register_no_lock 方法返回 nil
        // 在引用计数表那张散列表的weak引用对象的引用计数中标识为weak引用
        if (newObj  &&  !newObj->isTaggedPointer()) {
            newObj->setWeaklyReferenced_nolock();
        }

        // 之前不要设置 location 对象，这里需要更改指针指向
        *location = (id)newObj;
    }
    else {
        // 没有新值，则无需更改
    }
    
    SideTable::unlockTwo<haveOld, haveNew>(oldTable, newTable);

    return (id)newObj;
}

SideTable

struct SideTable {
    // 保证原子操作的自旋锁
    spinlock_t slock;
    // 引用计数的 hash 表
    RefcountMap refcnts;
    // weak 引用全局hash表
    weak_table_t weak_table;

    SideTable() {
        memset(&weak_table, 0, sizeof(weak_table));
    }

    ~SideTable() {
        _objc_fatal("Do not delete SideTable.");
    }

    void lock() { slock.lock(); }
    void unlock() { slock.unlock(); }
    void forceReset() { slock.forceReset(); }

    // Address-ordered lock discipline for a pair of side tables.

    template<HaveOld, HaveNew>
    static void lockTwo(SideTable *lock1, SideTable *lock2);
    template<HaveOld, HaveNew>
    static void unlockTwo(SideTable *lock1, SideTable *lock2);
};

weak 表

struct weak_table_t {
    // 保存了所有指向指定对象的 weak 指针
    weak_entry_t *weak_entries;
    // 存储空间
    size_t    num_entries;
    // 参与判断引用计数辅助量
    uintptr_t mask;
    // hash key 最大偏移量
    uintptr_t max_hash_displacement;
};