void 
objc_setAssociatedObject(id object, void *key, id value, objc_AssociationPolicy policy) {
    _object_set_associative_reference(object, key, value, policy);
}

void
_object_set_associative_reference(id object, void *key, id value, uintptr_t policy) {
    /*
     将 object 对象包装成 DisguisedPtr，
     这么做有如下目的：
     1. 避免被 ARC 错误处理；
     2. 原生指针值的哈希分布可能不均匀，导致哈希冲突率高；
     3. 防逆向分析。
     */
    DisguisedPtr<objc_object> disguised{(objc_object *)object};
    
    // 将 value 和 policy(内存管理策略) 包装成一个 ObjcAssociation 对象。
    ObjcAssociation association{policy, value};

    association.acquireValue() = {
      if (_value) {
             // 根据内存管理策略对 value 执行 retain 或 copy 操作。
             switch (_policy & 0xFF) {
             case OBJC_ASSOCIATION_SETTER_RETAIN:
                 _value = objc_retain(_value);
                 break;
             case OBJC_ASSOCIATION_SETTER_COPY:
                 _value = ((id(*)(id, SEL))objc_msgSend)(_value, @selector(copy));
                 break;
             }
         }
    }

    bool isFirstAssociation = false;
    {
        // 获取全局锁（在构造函数中加锁，在析构函数中解锁，这项技术被称为 RAII）
        AssociationsManager manager;
        // 获取全局关联对象的哈希表。
        AssociationsHashMap &associations(manager.get());

        if (value) {// 设置关联值
            auto refs_result = associations.try_emplace(disguised, ObjectAssociationMap{});
            // 标记是否为首次关联
            if (refs_result.second) {
                isFirstAssociation = true;
            }

            // 获取 object 对应的关联表（内层哈希表）
            auto &refs = refs_result.first->second;
            // 插入或替换 key 对应的关联值
            auto result = refs.try_emplace(key, std::move(association));
            
            // 若 key 已存在，交换旧值用于后续释放
            if (!result.second) {
                association.swap(result.first->second);
            }
        } else {// 删除关联值
            auto refs_it = associations.find(disguised);
            
            // 检查关联表是否为空
            if (refs_it != associations.end()) {
                // 获取 object 对应的关联表（内层哈希表）
                auto &refs = refs_it->second;
                // 获取 key 对应的数据。
                auto it = refs.find(key);
                
                if (it != refs.end()) {
                    // 获取旧值用于释放。
                    association.swap(it->second);
                    // 从内部表上删除键值对
                    refs.erase(it);
                    // 若内层表为空，从全局关联表中移除这个内层表。
                    if (refs.size() == 0) {
                        associations.erase(refs_it);
                    }
                }
            }
        }
    }// 这里会释放局部变量 manager，并执行它的析构函数然后释放掉全局锁。
    
    // 如果是首次设置关联对象，修改 isa 上的 has_assoc 字段为 true。
    if (isFirstAssociation) {
        object->setHasAssociatedObjects();
    }

    // 释放旧值
    association.releaseHeldValue() = {
        if (_value && (_policy & OBJC_ASSOCIATION_SETTER_RETAIN)) {
            objc_release(_value);
        }
    }
}

id objc_getAssociatedObject(id object, const void *key) {
    return _object_get_associative_reference(object, key);
}

id
_object_get_associative_reference(id object, const void *key) {
    ObjcAssociation association{};

    {
        // 获取全局锁（在构造函数中加锁，在析构函数中解锁）
        AssociationsManager manager;
        // 获取全局关联对象哈希表
        AssociationsHashMap &associations(manager.get());
        // 获取 object 对应的关联表（内层哈希表）
        AssociationsHashMap::iterator i = associations.find((objc_object *)object);
        // 判断内层表是否为空
        if (i != associations.end()) {
            ObjectAssociationMap &refs = i->second;
            // 通过 key 找到对应数据。
            ObjectAssociationMap::iterator j = refs.find(key);
            if (j != refs.end()) {
                association = j->second;
                // 获取对象并执行 retain 操作。
                association.retainReturnedValue();
            }
        }
    }// 这里会执行 manager 的析构函数并释放全局锁。

    // 将对象加入自动释放池并返回。
    return association.autoreleaseReturnedValue();
}

void objc_removeAssociatedObjects(id object)  {
    if (object && object->hasAssociatedObjects()) {
        _object_remove_associations(object, /*deallocating*/false);
    }
}

void
_object_remove_associations(id object, bool deallocating) {
    ObjectAssociationMap refs{};

    {
        // 获取全局锁（在构造函数中加锁，在析构函数中解锁）
        AssociationsManager manager;
        // 获取全局关联对象哈希表
        AssociationsHashMap &associations(manager.get());
        // 获取 object 对应的关联表（内层哈希表）
        AssociationsHashMap::iterator i = associations.find((objc_object *)object);
        if (i != associations.end()) {
            // 获取旧值用于释放
            refs.swap(i->second);
            
            bool didReInsert = false;
            
            /*
             如果是由 dealloc 触发的，会检查关联对象的内存管理策略是否为 OBJC_ASSOCIATION_SYSTEM_OBJECT。
             这是一个系统内部使用的特殊策略，它要求相关对象必须在其它所有普通关联对象都释放完成后才能被释放。
             猜测这种设计可能是为了确保某些系统级对象能在整个释放流程中保持可用状态。
             */
            if (!deallocating) {
                for (auto &ref: refs) {
                    if (ref.second.policy() & OBJC_ASSOCIATION_SYSTEM_OBJECT) {
                        i->second.insert(ref);
                        didReInsert = true;
                    }
                }
            }
            
            if (!didReInsert) {
                // 从全局关联表中移除这个内部表
                associations.erase(i);
            }
        }
    }// 这里会执行 manager 的析构函数并释放全局锁。
    
    SmallVector<ObjcAssociation *, 4> laterRefs;
    
    // 遍历并释放所有的关联对象。
    for (auto &i: refs) {
        if (i.second.policy() & OBJC_ASSOCIATION_SYSTEM_OBJECT) {
            if (deallocating)
                laterRefs.append(&i.second);
        } else {
            // 释放目标对象。
            i.second.releaseHeldValue();
        }
    }
    
    // 遍历并释放 OBJC_ASSOCIATION_SYSTEM_OBJECT 对象。
    for (auto *later: laterRefs) {
        later->releaseHeldValue();
    }
}

dealloc
└── _objc_rootDealloc
    └── rootDealloc
        └── object_dispose
            └── objc_destructInstance
                └── _object_remove_associations