OC 底层探索 16、类的加载 - 类的扩展 & 分类关联对象

一、类扩展

1、类扩展与分类

category：

• 准用来给类添加新方法；
• 不能添加成员变量，即使添加了也无法取到；
• 属性可添加，但只会生成 setter/getter 的声明而没有相应的实现 --> 可通过 runtime 进行关联实现。

extension：

• 可看做匿名分类；
• 可以给类添加成员属性，但是私有的；
• 可以给类添加方法，也是私有的。

类扩展：

类的扩展必须在实现前，如下图 error 信息：

类扩展的本质是什么呢？  

2、类扩展 - Extension 的本质

1、cpp 文件的编译查看

在main.m 文件中添加如下简单代码，

clang -rewrite-objc main.m -o main.cpp

编译 main.m 文件成 .cpp:

编译后文件代码：

setter/getter 的实现:

由上可验证：通过类扩展添加的属性变量，在编译时生成了 成员变量 ivar 和 setter(objc_setProperty()) / getter 方法的声明与实现。

方法列表 method_list 中，类扩展添加的方法和原本可重点二分法一样，编译时已经编译到 method_list 中了。

我们使用之前类加载分析时的 objc 源码工程 进行验证，运行：

方法们见下图：

这里也可验证。更多操作：1、将添加的分类删除，重新运行，结果相同；2、将 MyPerson 类的 load 方法实现注释掉，依然相同：

总结： 类的扩展在编译时就会被加载到类中了，直接成为为类的一部分和类共存了(自然类扩展添加的东西不存在脏内存问题，rwe 永远NULL)。

扩展和分类不同，分类更主要用于动态的添加。 

二、关联对象 

一直分类添加的属性是没有 setter/getter 方法的实现的，我们可通过 runtime 的关联方法进行动态添加。

对 Myperson 的 cateMore_name 进行赋值，运行工程，断点在 setCateMore_name 处，进入源码：

get() 点进去没有找到实现相关代码，进入 SetAssocHook: 发现是 _base_objc_setAssociatedObject 方法的调用，继续点进去，到了 _object_set_associative_reference。

1、源码分析

1）_object_set_associative_reference() 源码01：

void
_object_set_associative_reference(id object, const void *key, id value, uintptr_t policy)
{
    // This code used to work when nil was passed for object and key. Some code
    // probably relies on that to not crash. Check and handle it explicitly.
    // rdar://problem/44094390
    if (!object && !value) return;

    if (object->getIsa()->forbidsAssociatedObjects())
        _objc_fatal("objc_setAssociatedObject called on instance (%p) of class %s which does not allow associated objects", object, object_getClassName(object));
    // DisguisedPtr 相当于 包装了一下原来的对象
    DisguisedPtr<objc_object> disguised{(objc_object *)object};
    // 包装一下 policy 和 value
    ObjcAssociation association{policy, value};// 构造函数

    // retain the new value (if any) outside the lock.
    association.acquireValue();/**
                                inline void acquireValue() { // 根据关联方法设置的类型 policy 处理 retain 和 copy，其他场景不处理
                                    if (_value) {
                                        switch (_policy & 0xFF) {
                                        case OBJC_ASSOCIATION_SETTER_RETAIN:// retain
                                            _value = objc_retain(_value);
                                            break;
                                        case OBJC_ASSOCIATION_SETTER_COPY:// copy
                                            _value = ((id(*)(id, SEL))objc_msgSend)(_value, @selector(copy));
                                            break;
                                        }
                                    }
                                }
                                */

    {
        AssociationsManager manager;/**
                                     // class AssociationsManager manages a lock / hash table singleton pair.
                                     // Allocating an instance acquires the lock

                                     class AssociationsManager {
                                         using Storage = ExplicitInitDenseMap<DisguisedPtr<objc_object>, ObjectAssociationMap>;
                                         static Storage _mapStorage; // 静态变量

                                     public:
                                         AssociationsManager()   { AssociationsManagerLock.lock(); } // 初始化, 加 lock 锁避免了多线程对其重复操作，但并非表明它不可多次操作
                                         ~AssociationsManager()  { AssociationsManagerLock.unlock(); } // 析构

                                         AssociationsHashMap &get() {
                                             return _mapStorage.get();
                                         }

                                         static void init() {
                                             _mapStorage.init();
                                         }
                                     };
                                     */
    
        // AssociationsHashMap 关联对象的表 全部的关联对象都在此表中 此表示唯一的
        // _mapStorage.get() --> static Storage _mapStorage;//静态变量 全场唯一
        AssociationsHashMap &associations(manager.get());

        if (value) {
            auto refs_result = associations.try_emplace(disguised, ObjectAssociationMap{});
            /** refs_result:
             $0 = {
               first = {
                 Ptr = 0x00000001012000c0
                 End = 0x0000000101200100
               }
               second = true
             }
             */
            if (refs_result.second) {// refs_result 的 second 是个 bool 值
                /* it's the first association we make */
                object->setHasAssociatedObjects();
            }

            /* establish or replace the association */ // 进行 建立或替换 association
            auto &refs = refs_result.first->second; // 空的桶子
            auto result = refs.try_emplace(key, std::move(association));
            if (!result.second) {
                association.swap(result.first->second);// swap 移动
            }
        } else {// value 是空值 --> 进行移除操作
            auto refs_it = associations.find(disguised);// 通过 disguised 找
            if (refs_it != associations.end()) {
                auto &refs = refs_it->second;
                auto it = refs.find(key);
                if (it != refs.end()) {
                    association.swap(it->second);
                    refs.erase(it);// 消掉移除
                    if (refs.size() == 0) {
                        associations.erase(refs_it);// 消掉移除

                    }
                }
            }
        }
    }

    // release the old value (outside of the lock).
    association.releaseHeldValue();
}

1、先运行一下工程，执行代码通过 lldb 先查看信息具体是什么：

_object_set_associative_reference() --> try_emplace()

2、try_emplace() 代码-源码02

  // Inserts key,value pair into the map if the key isn't already in the map.
  // The value is constructed in-place if the key is not in the map, otherwise
  // it is not moved.
  template <typename... Ts>
  std::pair<iterator, bool> try_emplace(const KeyT &Key, Ts &&... Args) {
    BucketT *TheBucket;
    if (LookupBucketFor(Key, TheBucket))// 关联的 key 在不在 bucket 中
      return std::make_pair(
               makeIterator(TheBucket, getBucketsEnd(), true),
               false); // Already in map.已经在了

    // Otherwise, insert the new element.
    // key 是新的，把 key 插入 bucket 中 
    TheBucket = InsertIntoBucket(TheBucket, Key, std::forward<Ts>(Args)...);
    return std::make_pair(
             makeIterator(TheBucket, getBucketsEnd(), true),
             true);
  }

3、LookupBucketFor()，有2个方法，外部进入下面的那个参数是非 const 的函数，但最终是会走到上面的函数中，并进行 while(){}：

LookupBucketFor(const LookupKeyT &Val, const BucketT *&FoundBucket) 代码 - 源码03：

template<typename LookupKeyT>
  bool LookupBucketFor(const LookupKeyT &Val,
                       const BucketT *&FoundBucket) const {
    const BucketT *BucketsPtr = getBuckets();
    const unsigned NumBuckets = getNumBuckets();

    if (NumBuckets == 0) {
      FoundBucket = nullptr;
      return false;
    }

    // FoundTombstone - Keep track of whether we find a tombstone while probing.
    const BucketT *FoundTombstone = nullptr;
    const KeyT EmptyKey = getEmptyKey();
    const KeyT TombstoneKey = getTombstoneKey();
    assert(!KeyInfoT::isEqual(Val, EmptyKey) &&
           !KeyInfoT::isEqual(Val, TombstoneKey) &&
           "Empty/Tombstone value shouldn't be inserted into map!");

    unsigned BucketNo = getHashValue(Val) & (NumBuckets-1);// 哈希函数 算下标
    unsigned ProbeAmt = 1;
    // 开始 while
    while (true) {
      const BucketT *ThisBucket = BucketsPtr + BucketNo;// 指针位置移动
      // Found Val's bucket?  If so, return it.
      // 找到了 value 的 bucket 则返回 bucket 赋给外部的值->FoundBucket，然后return寻找的结果为true
      if (LLVM_LIKELY(KeyInfoT::isEqual(Val, ThisBucket->getFirst()))) {
        FoundBucket = ThisBucket;
        return true;
      }

      // If we found an empty bucket, the key doesn't exist in the set.
      // Insert it and return the default value.
      // 找到了一个空的 bucket --> 插入一个空的 bucket 并赋给 FoundBucket，然后return查找结果为false
      if (LLVM_LIKELY(KeyInfoT::isEqual(ThisBucket->getFirst(), EmptyKey))) {
        // If we've already seen a tombstone while probing, fill it in instead
        // of the empty bucket we eventually probed to.
        FoundBucket = FoundTombstone ? FoundTombstone : ThisBucket;
        return false;
      }

      // 处理 然后进行继续 while 循环操作
      // If this is a tombstone, remember it.  If Val ends up not in the map, we
      // prefer to return it than something that would require more probing.
      // Ditto for zero values.
      if (KeyInfoT::isEqual(ThisBucket->getFirst(), TombstoneKey) &&
          !FoundTombstone)
        FoundTombstone = ThisBucket;  // Remember the first tombstone found.
      if (ValueInfoT::isPurgeable(ThisBucket->getSecond())  &&  !FoundTombstone)
        FoundTombstone = ThisBucket;

      // Otherwise, it's a hash collision or a tombstone, continue quadratic
      // probing.
      if (ProbeAmt > NumBuckets) {
        FatalCorruptHashTables(BucketsPtr, NumBuckets);
      }
      BucketNo += ProbeAmt++;
      BucketNo &= (NumBuckets-1);
    }
  } 

4、InsertIntoBucket() 代码：

template <typename KeyArg, typename... ValueArgs>
  BucketT *InsertIntoBucket(BucketT *TheBucket, KeyArg &&Key,
                            ValueArgs &&... Values) {
    TheBucket = InsertIntoBucketImpl(Key, Key, TheBucket);

    TheBucket->getFirst() = std::forward<KeyArg>(Key);
    ::new (&TheBucket->getSecond()) ValueT(std::forward<ValueArgs>(Values)...);
    return TheBucket;
  }

InsertIntoBucketImpl() 代码：

template <typename LookupKeyT>
  BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
                                BucketT *TheBucket) {
    // If the load of the hash table is more than 3/4, or if fewer than 1/8 of
    // the buckets are empty (meaning that many are filled with tombstones),
    // grow the table.
    //
    // The later case is tricky.  For example, if we had one empty bucket with
    // tons of tombstones, failing lookups (e.g. for insertion) would have to
    // probe almost the entire table until it found the empty bucket.  If the
    // table completely filled with tombstones, no lookup would ever succeed,
    // causing infinite loops in lookup.
    unsigned NewNumEntries = getNumEntries() + 1;
    unsigned NumBuckets = getNumBuckets();
    if (LLVM_UNLIKELY(NewNumEntries * 4 >= NumBuckets * 3)) {
      this->grow(NumBuckets * 2);
      LookupBucketFor(Lookup, TheBucket);
      NumBuckets = getNumBuckets();
    } else if (LLVM_UNLIKELY(NumBuckets-(NewNumEntries+getNumTombstones()) <=
                             NumBuckets/8)) {
      this->grow(NumBuckets);
      LookupBucketFor(Lookup, TheBucket);
    }
    ASSERT(TheBucket);

    // Only update the state after we've grown our bucket space appropriately
    // so that when growing buckets we have self-consistent entry count.
    // If we are writing over a tombstone or zero value, remember this.
    if (KeyInfoT::isEqual(TheBucket->getFirst(), getEmptyKey())) {
      // Replacing an empty bucket.
      incrementNumEntries();
    } else if (KeyInfoT::isEqual(TheBucket->getFirst(), getTombstoneKey())) {
      // Replacing a tombstone.
      incrementNumEntries();
      decrementNumTombstones();
    } else {
      // we should be purging a zero. No accounting changes.
      ASSERT(ValueInfoT::isPurgeable(TheBucket->getSecond()));
      TheBucket->getSecond().~ValueT();
    }

    return TheBucket;
  }

5、setHasAssociatedObjects() 源码见下面代码:

执行到‘源码01’ 处，second 值的判断(try_emplace() 的返回值)，是第一次插入则为 true

--> setHasAssociatedObjects(), nopointer isa --> isa.has_assoc 关联标志位设为了 true。 isa结构见《OC 底层探索 03 中isa 结构》。

inline void
objc_object::setHasAssociatedObjects()
{
    if (isTaggedPointer()) return;

 retry:
    isa_t oldisa = LoadExclusive(&isa.bits);
    isa_t newisa = oldisa;
    if (!newisa.nonpointer  ||  newisa.has_assoc) {
        ClearExclusive(&isa.bits);
        return;
    }
    newisa.has_assoc = true;// isa 的关联标志位
    if (!StoreExclusive(&isa.bits, oldisa.bits, newisa.bits)) goto retry;
}

2、执行流程

1）断点调试执行流程

1、处理第一此关联：

走进 try_emplace() 第一次执行 de 流程：

_object_set_associative_reference() - 开始set关联

　　--> try_emplace() - refs_result

　　　　--> LookupBucketFor() - 找bucket : return false --> InsertIntoBucket() - 插入一个空的 bucket :

　　　　　　--> InsertIntoBucketImpl() --> LookupBucketFor() - 得到一个空的bucket

　　--> setHasAssociatedObjects() - isa.hsa_assoc设为true

--> 再次 执行到 try_emplace() - refs_result.first->second

继续执行工程，第二次走进入 try_emplace() ，bucket 不为空：

2、添加第2个关联时执行：

对象关联流程图：

2）关联类的 map 的结构分析

1、lldb 数据分析：

2、类型de 结构分析：

 

首次 try_emplace() 数据:

第 2 次 try_emplace() 数据: 

 

总结(套娃，buckets 中装了 buckets 又装了 bucket)：

tips：关联对象移除吗？需要！--> dealloc 流程 如下：

源码： 

// 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 {// isa.has_assoc = true - 有关联对象
        object_dispose((id)this);
    }
}

/***********************************************************************
* object_dispose
* fixme
* Locking: none
**********************************************************************/
id 
object_dispose(id obj)
{
    if (!obj) return nil;

    objc_destructInstance(obj);    
    free(obj);

    return nil;
}

/***********************************************************************
* objc_destructInstance
* Destroys an instance without freeing memory. 
* Calls C++ destructors.
* Calls ARC ivar cleanup.
* Removes associative references.
* Returns `obj`. Does nothing if `obj` is nil.
**********************************************************************/
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.
        if (cxx) object_cxxDestruct(obj);
        if (assoc) _object_remove_assocations(obj);
        obj->clearDeallocating();
    }

    return obj;
}

// Unlike setting/getting an associated reference,
// this function is performance sensitive because of
// raw isa objects (such as OS Objects) that can't track
// whether they have associated objects.
void
_object_remove_assocations(id object)
{
    ObjectAssociationMap refs{};

    {
        AssociationsManager manager;
        AssociationsHashMap &associations(manager.get());
        AssociationsHashMap::iterator i = associations.find((objc_object *)object);
        if (i != associations.end()) {
            refs.swap(i->second);
            associations.erase(i);// 擦除抹掉
        }
    }

    // release everything (outside of the lock).释放所有
    for (auto &i: refs) {
        i.second.releaseHeldValue();
        /**
            inline void releaseHeldValue() {
                if (_value && (_policy & OBJC_ASSOCIATION_SETTER_RETAIN)) {
                    objc_release(_value);
                }
        }
        */
    }
}

// clearDeallocating
inline void 
objc_object::clearDeallocating()
{
    if (slowpath(!isa.nonpointer)) {
        // Slow path for raw pointer 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.
        clearDeallocating_slow();
    }

    assert(!sidetable_present());
}    

以上。