1. 类扩展 VS 分类

1.1 类扩展（Extension）

  • 特殊的分类，也称作匿名分类
  • 可以给类添加成员属性，但是为私有变量
  • 可以给类添加方法，也是私有方法

1.2 分类（Category）

  • 专门用来给类添加新的方法
  • 不能给类添加成员属性，添加后无法读取（可通过Runtime给分类添加属性）
  • 分类中使用@property定义变量，只会生成变量的getter/setter方法的声明，不能生成方法的实现和下划线开头的成员变量

2. 类扩展的分析

2.1 cpp文件探索

在main函数中，写入LGPerson的类扩展

  1. #import <Foundation/Foundation.h>
  3. int main(int argc, const char * argv[]) {
  4.     @autoreleasepool {
  5.         NSLog(@"Hello, World!");
  6.     }
  7.     return 0;
  8. }
  10. @interface LGPerson : NSObject
  12. @property (nonatomic, copy) NSString *lgName;
  14. - (void)say666;
  16. @end
  18. @interface LGPerson ()
  20. @property (nonatomic, copy) NSString *ext_name;
  22. - (void)ext_sayNB;
  24. @end
  26. @implementation LGPerson
  28. - (void)say666{
  29.     NSLog(@"%@ - %s",self , __func__);
  30. }
  32. - (void)ext_sayNB{
  33.     NSLog(@"%@ - %s",self , __func__);
  34. }
  36. @end
  • 类扩展的书写位置：声明之后，实现之前

生成cpp文件

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

对于类扩展中声明的属性，同样会生成下划线开头的成员变量

  1. extern "C" unsigned long OBJC_IVAR_$_LGPerson$_lgName;
  2. extern "C" unsigned long OBJC_IVAR_$_LGPerson$_ext_name;
  3. struct LGPerson_IMPL {
  4.     struct NSObject_IMPL NSObject_IVARS;
  5.     NSString *_lgName;
  6.     NSString *_ext_name;
  7. };

生成属性的getter/setter方法

  1. static NSString * _I_LGPerson_lgName(LGPerson * self, SEL _cmd) { return (*(NSString **)((char *)self + OBJC_IVAR_$_LGPerson$_lgName)); }
  2. extern "C" __declspec(dllimport) void objc_setProperty (id, SEL, long, id, bool, bool);
  4. static void _I_LGPerson_setLgName_(LGPerson * self, SEL _cmd, NSString *lgName) { objc_setProperty (self, _cmd, __OFFSETOFIVAR__(struct LGPerson, _lgName), (id)lgName, 0, 1); }
  6. static NSString * _I_LGPerson_ext_name(LGPerson * self, SEL _cmd) { return (*(NSString **)((char *)self + OBJC_IVAR_$_LGPerson$_ext_name)); }
  7. static void _I_LGPerson_setExt_name_(LGPerson * self, SEL _cmd, NSString *ext_name) { objc_setProperty (self, _cmd, __OFFSETOFIVAR__(struct LGPerson, _ext_name), (id)ext_name, 0, 1); }

找到LGPerson的成员变量列表

  1. extern "C" unsigned long int OBJC_IVAR_$_LGPerson$_lgName __attribute__ ((used, section ("__DATA,__objc_ivar"))) = __OFFSETOFIVAR__(struct LGPerson, _lgName);
  2. extern "C" unsigned long int OBJC_IVAR_$_LGPerson$_ext_name __attribute__ ((used, section ("__DATA,__objc_ivar"))) = __OFFSETOFIVAR__(struct LGPerson, _ext_name);
  4. static struct /*_ivar_list_t*/ {
  5.     unsigned int entsize;  // sizeof(struct _prop_t)
  6.     unsigned int count;
  7.     struct _ivar_t ivar_list[2];
  8. } _OBJC_$_INSTANCE_VARIABLES_LGPerson __attribute__ ((used, section ("__DATA,__objc_const"))) = {
  9.     sizeof(_ivar_t),
  10.     2,
  11.     {{(unsigned long int *)&OBJC_IVAR_$_LGPerson$_lgName, "_lgName", "@\"NSString\"", 3, 8},
  12.      {(unsigned long int *)&OBJC_IVAR_$_LGPerson$_ext_name, "_ext_name", "@\"NSString\"", 3, 8}}
  13. };

找到LGPerson的方法列表

  1. static struct /*_method_list_t*/ {
  2.     unsigned int entsize;  // sizeof(struct _objc_method)
  3.     unsigned int method_count;
  4.     struct _objc_method method_list[10];
  5. } _OBJC_$_INSTANCE_METHODS_LGPerson __attribute__ ((used, section ("__DATA,__objc_const"))) = {
  6.     sizeof(_objc_method),
  7.     10,
  8.     {{(struct objc_selector *)"say666", "v16@0:8", (void *)_I_LGPerson_say666},
  9.     {(struct objc_selector *)"ext_sayNB", "v16@0:8", (void *)_I_LGPerson_ext_sayNB},
  10.     {(struct objc_selector *)"lgName", "@16@0:8", (void *)_I_LGPerson_lgName},
  11.     {(struct objc_selector *)"setLgName:", "v24@0:8@16", (void *)_I_LGPerson_setLgName_},
  12.     {(struct objc_selector *)"ext_name", "@16@0:8", (void *)_I_LGPerson_ext_name},
  13.     {(struct objc_selector *)"setExt_name:", "v24@0:8@16", (void *)_I_LGPerson_setExt_name_},
  14.     {(struct objc_selector *)"lgName", "@16@0:8", (void *)_I_LGPerson_lgName},
  15.     {(struct objc_selector *)"setLgName:", "v24@0:8@16", (void *)_I_LGPerson_setLgName_},
  16.     {(struct objc_selector *)"ext_name", "@16@0:8", (void *)_I_LGPerson_ext_name},
  17.     {(struct objc_selector *)"setExt_name:", "v24@0:8@16", (void *)_I_LGPerson_setExt_name_}}
  18. };

类扩展和分类的明显区别，不会生成额外的结构体存储类扩展的信息、类扩展中的属性和方法，和LGPerson主类的属性和方法融为一体

2.2 objc源码探索

在项目中，创建LGPerson+Ext.h类扩展

  1. #import "LGPerson.h"
  3. @interface LGPerson ()
  5. @property (nonatomic, copy) NSString *ext_name;
  7. - (void)ext_say666;
  9. @end

在LGPerson中，实现ext_say666方法

  1. #import "LGPerson.h"
  2. #import "LGPerson+Ext.h"
  4. @implementation LGPerson
  6. + (void)load{
  7.     NSLog(@"%@ - %s",self , __func__);
  8. }
  10. - (void)say1{
  11.     NSLog(@"%@ : %s",self,__func__);
  12. }
  14. - (void)ext_say666{
  15.     NSLog(@"%@ : %s",self,__func__);
  16. }
  18. @end

主类执行流程没有任何变化，在realizeClassWithoutSwift函数中，读取ro方法列表中，同时也包含类扩展中声明的方法
image.png

所以类扩展并不会影响主类的加载流程，在编译时，类扩展中的属性和方法和主类融为一体

创建的类扩展只有·h文件，所以只做声明，实现需要依赖于当前的主类

3. 关联对象

分类中，不能直接使用属性的getter/setter方法，只能使用关联对象的方式实现成员变量的效果

关联对象的两个核心方法，值的存储和读取

值的存储

  1. void
  2. objc_setAssociatedObject(id object, const void *key, id value, objc_AssociationPolicy policy)
  • object：被关联者
  • key：标识符
  • value：值
  • policy：关联策略

值的读取

  1. void objc_removeAssociatedObjects(id object)
  • object：被关联者
  • key：标识符

关联策略

  1. typedef OBJC_ENUM(uintptr_t, objc_AssociationPolicy) {
  2.     OBJC_ASSOCIATION_ASSIGN = 0,           /**< Specifies a weak reference to the associated object. */
  3.     OBJC_ASSOCIATION_RETAIN_NONATOMIC = 1, /**< Specifies a strong reference to the associated object. 
  4.                                             *   The association is not made atomically. */
  5.     OBJC_ASSOCIATION_COPY_NONATOMIC = 3,   /**< Specifies that the associated object is copied. 
  6.                                             *   The association is not made atomically. */
  7.     OBJC_ASSOCIATION_RETAIN = 01401,       /**< Specifies a strong reference to the associated object.
  8.                                             *   The association is made atomically. */
  9.     OBJC_ASSOCIATION_COPY = 01403          /**< Specifies that the associated object is copied.
  10.                                             *   The association is made atomically. */
  11. };
  • nonatomic、atomic、assign、retain、copy等修饰

3.1 objc_setAssociatedObject & objc_getAssociatedObject

  1. void
  2. objc_setAssociatedObject(id object, const void *key, id value, objc_AssociationPolicy policy)
  3. {
  4.     _object_set_associative_reference(object, key, value, policy);
  5. }
  7. id
  8. objc_getAssociatedObject(id object, const void *key)
  9. {
  10.     return _object_get_associative_reference(object, key);
  11. }
  • objc_setAssociatedObject和objc_getAssociatedObject函数为中间层层代码，目的是对业务层进行隔离。因为底层API根据不同版本会发生变化，但中间层代码是保持不变的，所以开发者不用担心因底层API变化导致程序的修改

3.2 _object_set_associative_reference

  1. void
  2. _object_set_associative_reference(id object, const void *key, id value, uintptr_t policy)
  3. {
  4.     // This code used to work when nil was passed for object and key. Some code
  5.     // probably relies on that to not crash. Check and handle it explicitly.
  6.     // rdar://problem/44094390
  7.     if (!object && !value) return;
  9.     if (object->getIsa()->forbidsAssociatedObjects())
  10.         _objc_fatal("objc_setAssociatedObject called on instance (%p) of class %s which does not allow associated objects", object, object_getClassName(object));
  12.     //将不同类型的object，保存成统一结构
  13.     DisguisedPtr<objc_object> disguised{(objc_object *)object};
  14.     //将关联策略和值，以面向对象的方式进行存储
  15.     ObjcAssociation association{policy, value};
  17.     // retain the new value (if any) outside the lock.
  18.     //根据不同的关联策略进行处理
  19.     association.acquireValue();
  21.     bool isFirstAssociation = false;
  22.     {
  23.         //调用构造函数，加锁。函数作用域结束AssociationsManager释放，调用析构函数，解锁
  24.         AssociationsManager manager;
  25.         //获取唯⼀的全局静态哈希Map
  26.         //验证方式：get函数中调用_mapStorage.get()，而_mapStorage为static修饰
  27.         AssociationsHashMap &associations(manager.get());
  29.         if (value) {
  30.             //被关联者和ObjectAssociationMap进行关联
  31.             auto refs_result = associations.try_emplace(disguised, ObjectAssociationMap{});
  32.             if (refs_result.second) {
  33.                 /* it's the first association we make */
  34.                 //首次关联，打标记
  35.                 isFirstAssociation = true;
  36.             }
  38.             /* establish or replace the association */
  39.             //建立或替换关联
  40.             auto &refs = refs_result.first->second;
  41.             auto result = refs.try_emplace(key, std::move(association));
  42.             if (!result.second) {
  43.                 //如果存在旧值，替换为新值
  44.                 association.swap(result.first->second);
  45.             }
  46.         } else {
  48.             //value不存在，移除关联
  49.             //通过关联对象寻址Iterator
  50.             auto refs_it = associations.find(disguised);
  51.             if (refs_it != associations.end()) {
  52.                 //获取ObjectAssociationMap
  53.                 auto &refs = refs_it->second;
  54.                 //通过key寻址Iterator
  55.                 auto it = refs.find(key);
  56.                 if (it != refs.end()) {
  57.                     //替换ObjcAssociation，新值替换旧值
  58.                     association.swap(it->second);
  59.                     //移除旧值
  60.                     refs.erase(it);
  61.                     if (refs.size() == 0) {
  62.                         //如果关联对象关联的Iterator为空，直接移除
  63.                         associations.erase(refs_it);
  64.                     }
  65.                 }
  66.             }
  67.         }
  68.     }
  70.     // Call setHasAssociatedObjects outside the lock, since this
  71.     // will call the object's _noteAssociatedObjects method if it
  72.     // has one, and this may trigger +initialize which might do
  73.     // arbitrary stuff, including setting more associated objects.
  74.     //在nonpointerIsa中标记
  75.     if (isFirstAssociation)
  76.         object->setHasAssociatedObjects();
  78.     // release the old value (outside of the lock).
  79.     //释放旧值
  80.     association.releaseHeldValue();
  81. }

【步骤一】

  • 将不同类型的object，保存成统一的DisguisedPtr<objc_object>结构

  • 将关联策略和值，以面向对象的方式进行存储ObjcAssociation类中

  • 根据不同的关联策略进行处理

【步骤二】

  • 调用构造函数，加锁。函数作用域结束AssociationsManager释放，调用析构函数，解锁

  • AssociationsHashMap为单例，在内存中只有一份

【步骤三】

  • 如果value存在，进行关联

    • 调用AssociationsHashMap的try_emplace函数，将object和ObjectAssociationMap关联

    • 返回结果refs_result，如果是首次关联，打标记

    • 在refs_result中找到object关联的Bucket

    • 调用Bucket的try_emplace函数，将key关联ObjcAssociation类

    • 如果存在旧值，替换为新值

  • 如果传入的value不存在，移除关联

    • 通过关联对象寻址Iterator

    • 获取ObjectAssociationMap

    • 替换ObjcAssociation，新值替换旧值

    • 移除旧值

    • 如果关联对象关联的Iterator为空，直接移除

【步骤四】

  • 在nonpointerIsa中标记，当对象销毁时，关联对象也要跟随销毁

  • 释放旧值

3.2.1 AssociationsHashMap单例

  1. class AssociationsManager {
  2.     using Storage = ExplicitInitDenseMap<DisguisedPtr<objc_object>, ObjectAssociationMap>;
  3.     static Storage _mapStorage;
  5. public:
  6.     AssociationsManager()   { AssociationsManagerLock.lock(); }
  7.     ~AssociationsManager()  { AssociationsManagerLock.unlock(); }
  9.     AssociationsHashMap &get() {
  10.         return _mapStorage.get();
  11.     }
  13.     static void init() {
  14.         _mapStorage.init();
  15.     }
  16. };
  • AssociationsManager的get函数，调用_mapStorage的get函数
  • _mapStorage：使用static修饰，全局静态对象
  • AssociationsManager()：构造函数，加锁
  • ~AssociationsManager()：析构函数，解锁
  • 加锁、解锁操作，保证对象的安全性，防止冲突

验证AssociationsManager和AssociationsHashMap的单例模式，将AssociationsManager中的构造函数和析构函数注释，避免锁递归报错

  1. void test(){
  3.     AssociationsManager manager1;
  4.     AssociationsHashMap &associations1(manager1.get());
  6.     printf("AssociationsManager1：%p\n", &manager1);
  7.     printf("AssociationsHashMap1：%p\n", &associations1);
  9.     AssociationsManager manager2;
  10.     AssociationsHashMap &associations2(manager2.get());
  12.     printf("AssociationsManager2：%p\n", &manager2);
  13.     printf("AssociationsHashMap2：%p\n", &associations2);
  15.     AssociationsManager manager3;
  16.     AssociationsHashMap &associations3(manager3.get());
  18.     printf("AssociationsManager3：%p\n", &manager3);
  19.     printf("AssociationsHashMap3：%p\n", &associations3);
  20. }
  22. -------------------------
  24. AssociationsManager1：0x7ffeefbff258
  25. AssociationsHashMap1：0x100370188
  26. AssociationsManager2：0x7ffeefbff248
  27. AssociationsHashMap2：0x100370188
  28. AssociationsManager3：0x7ffeefbff238
  29. AssociationsHashMap3：0x100370188
  • AssociationsManager不是单例对象，每次创建的内存地址都不一样
  • AssociationsHashMap为单例对象，内存地址一致

3.2.2 AssociationsManager的初始化

AssociationsManager的init函数使用static修饰，表示类对象函数，找到它的初始化时机

_objc_associations_init函数

  1. void
  2. _objc_associations_init()
  3. {
  4.     AssociationsManager::init();
  5. }

arr_init函数

  1. void arr_init(void) 
  2. {
  3.     AutoreleasePoolPage::init();
  4.     SideTablesMap.init();
  5.     _objc_associations_init();
  6. }

map_images_nolock函数

  1. void 
  2. map_images_nolock(unsigned mhCount, const char * const mhPaths[],
  3.                   const struct mach_header * const mhdrs[])
  4. {
  5.     ...
  7.     if (firstTime) {
  8.         sel_init(selrefCount);
  9.         arr_init();
  11.         ...
  12.     }
  14.     ...
  15. }

AssociationsManager初始化流程：map_images→map_images_nolock→arr_init→_objc_associations_init

也就是在此时，系统创建了AssociationsHashMap关联对象表。和它一起被创建的全局系统表，还有AutoreleasePoolPage自动释放池，以及SideTablesMap散列表

SideTablesMap散列表中包含两张子表，分别是RefcountMap引用计数表，还有weak_table_t弱引用表

3.2.3 AssociationsHashMap结构

image.png

AssociationsHashMap为双层HashMap结构

  1. typedef DenseMap<DisguisedPtr<objc_object>, ObjectAssociationMap> AssociationsHashMap;
  • DisguisedPtr<objc_object>为被关联者，它所对应的值还是一张HashMap

image.png

ObjectAssociationMap为HashMap结构

  1. typedef DenseMap<const void *, ObjcAssociation> ObjectAssociationMap;
  • const void *为标识号，它所对应的值为ObjcAssociation类

image.png

ObjcAssociation为class结构

  1. class ObjcAssociation {
  2.     uintptr_t _policy;
  3.     id _value;
  5.     ...
  6. }
  • _policy：关联策略
  • _value：值

3.2.4 try_emplace函数

  1.   template <typename... Ts>
  2.   std::pair<iterator, bool> try_emplace(const KeyT &Key, Ts &&... Args) {
  3.     BucketT *TheBucket;
  5.     //查看Bucket在map中是否存在，存在将Bucket返回
  6.     if (LookupBucketFor(Key, TheBucket))
  7.       return std::make_pair(
  8.                makeIterator(TheBucket, getBucketsEnd(), true),
  9.                false); // Already in map.
  11.     // Otherwise, insert the new element.
  12.     //不存在，插入Bucket并返回
  13.     TheBucket = InsertIntoBucket(TheBucket, Key, std::forward<Ts>(Args)...);
  14.     return std::make_pair(
  15.              makeIterator(TheBucket, getBucketsEnd(), true),
  16.              true);
  17.   }
  • 通过std::make_pair生成相应的键值对
  • LookupBucketFor函数，查看Bucket在map中是否存在，存在将Bucket返回
  • 不存在，调用InsertIntoBucket函数，插入Bucket并返回

3.2.5 LookupBucketFor函数

image.png

  • 两个函数的区别在于Bucket参数的const修饰
  • 作用：为value查找适当的Bucket，并将其返回

LookupBucketFor函数一，Bucket使用const修饰

  1.   template<typename LookupKeyT>
  2.   bool LookupBucketFor(const LookupKeyT &Val,
  3.                        const BucketT *&FoundBucket) const {
  4.     const BucketT *BucketsPtr = getBuckets();
  5.     const unsigned NumBuckets = getNumBuckets();
  7.     if (NumBuckets == 0) {
  8.       FoundBucket = nullptr;
  9.       return false;
  10.     }
  12.     // FoundTombstone - Keep track of whether we find a tombstone while probing.
  13.     const BucketT *FoundTombstone = nullptr;
  14.     const KeyT EmptyKey = getEmptyKey();
  15.     const KeyT TombstoneKey = getTombstoneKey();
  16.     assert(!KeyInfoT::isEqual(Val, EmptyKey) &&
  17.            !KeyInfoT::isEqual(Val, TombstoneKey) &&
  18.            "Empty/Tombstone value shouldn't be inserted into map!");
  20.     //哈希函数，计算下标
  21.     unsigned BucketNo = getHashValue(Val) & (NumBuckets-1);
  22.     unsigned ProbeAmt = 1;
  23.     while (true) {
  24.       //内存平移，获取Bucket
  25.       const BucketT *ThisBucket = BucketsPtr + BucketNo;
  26.       // Found Val's bucket?  If so, return it.
  27.       //找到Bucket，直接返回
  28.       if (LLVM_LIKELY(KeyInfoT::isEqual(Val, ThisBucket->getFirst()))) {
  29.         FoundBucket = ThisBucket;
  30.         return true;
  31.       }
  33.       // If we found an empty bucket, the key doesn't exist in the set.
  34.       // Insert it and return the default value.
  35.       //Bucket为空，返回默认值
  36.       if (LLVM_LIKELY(KeyInfoT::isEqual(ThisBucket->getFirst(), EmptyKey))) {
  37.         // If we've already seen a tombstone while probing, fill it in instead
  38.         // of the empty bucket we eventually probed to.
  39.         FoundBucket = FoundTombstone ? FoundTombstone : ThisBucket;
  40.         return false;
  41.       }
  43.       // If this is a tombstone, remember it.  If Val ends up not in the map, we
  44.       // prefer to return it than something that would require more probing.
  45.       // Ditto for zero values.
  46.       //哈希冲突，再次哈希
  47.       if (KeyInfoT::isEqual(ThisBucket->getFirst(), TombstoneKey) &&
  48.           !FoundTombstone)
  49.         FoundTombstone = ThisBucket;  // Remember the first tombstone found.
  50.       if (ValueInfoT::isPurgeable(ThisBucket->getSecond())  &&  !FoundTombstone)
  51.         FoundTombstone = ThisBucket;
  53.       // Otherwise, it's a hash collision or a tombstone, continue quadratic
  54.       // probing.
  55.       if (ProbeAmt > NumBuckets) {
  56.         FatalCorruptHashTables(BucketsPtr, NumBuckets);
  57.       }
  58.       BucketNo += ProbeAmt++;
  59.       BucketNo &= (NumBuckets-1);
  60.     }
  61.   }
  • 哈希函数，计算下标
  • 内存平移，获取Bucket
  • 找到Bucket，直接返回
  • Bucket为空，返回默认值
  • 哈希冲突，再次哈希

LookupBucketFor函数二，Bucket未使用const修饰

  1.   template <typename LookupKeyT>
  2.   bool LookupBucketFor(const LookupKeyT &Val, BucketT *&FoundBucket) {
  4.     //创建空Bucket
  5.     const BucketT *ConstFoundBucket;
  6.     //调用LookupBucketFor函数一
  7.     bool Result = const_cast<const DenseMapBase *>(this)
  8.       ->LookupBucketFor(Val, ConstFoundBucket);
  9.     //将ConstFoundBucket赋值FoundBucket
  10.     FoundBucket = const_cast<BucketT *>(ConstFoundBucket);
  11.     //返回结果，是否查找到Bucket
  12.     return Result;
  13.   }
  • 创建空Bucket
  • 调用LookupBucketFor函数一
  • 将ConstFoundBucket赋值FoundBucket
  • 返回结果，是否查找到Bucket

3.2.6 InsertIntoBucket函数

  1.   template <typename KeyArg, typename... ValueArgs>
  2.   BucketT *InsertIntoBucket(BucketT *TheBucket, KeyArg &&Key,
  3.                             ValueArgs &&... Values) {
  4.     TheBucket = InsertIntoBucketImpl(Key, Key, TheBucket);
  6.     TheBucket->getFirst() = std::forward<KeyArg>(Key);
  7.     ::new (&TheBucket->getSecond()) ValueT(std::forward<ValueArgs>(Values)...);
  8.     return TheBucket;
  9.   }
  • 调用InsertIntoBucketImpl函数

InsertIntoBucketImpl函数

  1.   template <typename LookupKeyT>
  2.   BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
  3.                                 BucketT *TheBucket) {
  4.     // If the load of the hash table is more than 3/4, or if fewer than 1/8 of
  5.     // the buckets are empty (meaning that many are filled with tombstones),
  6.     // grow the table.
  7.     //
  8.     // The later case is tricky.  For example, if we had one empty bucket with
  9.     // tons of tombstones, failing lookups (e.g. for insertion) would have to
  10.     // probe almost the entire table until it found the empty bucket.  If the
  11.     // table completely filled with tombstones, no lookup would ever succeed,
  12.     // causing infinite loops in lookup.
  13.     unsigned NewNumEntries = getNumEntries() + 1;
  14.     unsigned NumBuckets = getNumBuckets();
  15.     if (LLVM_UNLIKELY(NewNumEntries * 4 >= NumBuckets * 3)) {
  16.       this->grow(NumBuckets * 2);
  17.       LookupBucketFor(Lookup, TheBucket);
  18.       NumBuckets = getNumBuckets();
  19.     } else if (LLVM_UNLIKELY(NumBuckets-(NewNumEntries+getNumTombstones()) <=
  20.                              NumBuckets/8)) {
  21.       this->grow(NumBuckets);
  22.       LookupBucketFor(Lookup, TheBucket);
  23.     }
  24.     ASSERT(TheBucket);
  26.     // Only update the state after we've grown our bucket space appropriately
  27.     // so that when growing buckets we have self-consistent entry count.
  28.     // If we are writing over a tombstone or zero value, remember this.
  29.     if (KeyInfoT::isEqual(TheBucket->getFirst(), getEmptyKey())) {
  30.       // Replacing an empty bucket.
  31.       incrementNumEntries();
  32.     } else if (KeyInfoT::isEqual(TheBucket->getFirst(), getTombstoneKey())) {
  33.       // Replacing a tombstone.
  34.       incrementNumEntries();
  35.       decrementNumTombstones();
  36.     } else {
  37.       // we should be purging a zero. No accounting changes.
  38.       ASSERT(ValueInfoT::isPurgeable(TheBucket->getSecond()));
  39.       TheBucket->getSecond().~ValueT();
  40.     }
  42.     return TheBucket;
  43.   }
  • 如果哈希表的负载大于3/4，两倍扩容

3.3 _object_get_associative_reference

  1. id
  2. _object_get_associative_reference(id object, const void *key)
  3. {
  4.     ObjcAssociation association{};
  6.     {
  7.         //调用构造函数，加锁。函数作用域结束AssociationsManager释放，调用析构函数，解锁
  8.         AssociationsManager manager;
  9.         //获取唯⼀的全局静态哈希Map
  10.         AssociationsHashMap &associations(manager.get());
  11.         //通过关联对象寻址Iterator
  12.         AssociationsHashMap::iterator i = associations.find((objc_object *)object);
  13.         if (i != associations.end()) {
  14.             //获取ObjectAssociationMap
  15.             ObjectAssociationMap &refs = i->second;
  16.             //通过key寻址Iterator
  17.             ObjectAssociationMap::iterator j = refs.find(key);
  18.             if (j != refs.end()) {
  19.                 //获取ObjcAssociation
  20.                 association = j->second;
  21.                 //保留返回值
  22.                 association.retainReturnedValue();
  23.             }
  24.         }
  25.     }
  27.     //生成自动返回值
  28.     return association.autoreleaseReturnedValue();
  29. }

【第一步】

  • 调用构造函数，加锁。函数作用域结束AssociationsManager释放，调用析构函数，解锁

  • AssociationsHashMap为单例，在内存中只有一份

【第二步】

  • 通过关联对象寻址Iterator

  • 获取ObjectAssociationMap

【第三步】

  • 通过key寻址Iterator

  • 获取ObjcAssociation

  • 保留返回值

【第四步】

  • 生成自动返回值

3.4 关联对象的销毁

关联对象的销毁，依赖于被关联对象的生命周期。当被关联对象被销毁时，它的关联对象会自动销毁

对象销毁流程：

  • C++函数释放 ：objc_cxxDestruct
  • 关联对象销毁：_object_remove_assocations
  • 弱引用销毁：weak_clear_no_lock
  • 清空引用计数：table.refcnts.erase
  • 销毁对象：free

3.4.1 dealloc

  1. - (void)dealloc {
  2.     _objc_rootDealloc(self);
  3. }

3.4.2 _objc_rootDealloc

  1. void
  2. _objc_rootDealloc(id obj)
  3. {
  4.     ASSERT(obj);
  6.     obj->rootDealloc();
  7. }

3.4.3 rootDealloc

  1. inline void
  2. objc_object::rootDealloc()
  3. {
  4.     if (isTaggedPointer()) return;  // fixme necessary?
  6.     if (fastpath(isa.nonpointer                     &&
  7.                  !isa.weakly_referenced             &&
  8.                  !isa.has_assoc                     &&
  9. #if ISA_HAS_CXX_DTOR_BIT
  10.                  !isa.has_cxx_dtor                  &&
  11. #else
  12.                  !isa.getClass(false)->hasCxxDtor() &&
  13. #endif
  14.                  !isa.has_sidetable_rc))
  15.     {
  16.         assert(!sidetable_present());
  17.         free(this);
  18.     } 
  19.     else {
  20.         object_dispose((id)this);
  21.     }
  22. }
  • 判断C++析构函数的调用、关联对象的销毁、弱引用的销毁、引用计数是否清空，全部符合条件，调用free函数销毁对象
  • 否则，调用object_dispose函数，继续销毁流程

3.4.4 object_dispose

  1. id 
  2. object_dispose(id obj)
  3. {
  4.     if (!obj) return nil;
  6.     objc_destructInstance(obj);    
  7.     free(obj);
  9.     return nil;
  10. }

3.4.5 objc_destructInstance

  1. void *objc_destructInstance(id obj) 
  2. {
  3.     if (obj) {
  4.         // Read all of the flags at once for performance.
  5.         bool cxx = obj->hasCxxDtor();
  6.         bool assoc = obj->hasAssociatedObjects();
  8.         // This order is important.
  9.         if (cxx) object_cxxDestruct(obj);
  10.         if (assoc) _object_remove_assocations(obj, /*deallocating*/true);
  11.         obj->clearDeallocating();
  12.     }
  14.     return obj;
  15. }
  • object_cxxDestruct：调用C++的析构函数
  • _object_remove_assocations：关联对象销毁
  • clearDeallocating，弱引用销毁、清空引用计数

3.4.6 _object_remove_assocations

  1. void
  2. _object_remove_assocations(id object, bool deallocating)
  3. {
  4.     ObjectAssociationMap refs{};
  6.     {
  7.         //调用构造函数，加锁。函数作用域结束AssociationsManager释放，调用析构函数，解锁
  8.         AssociationsManager manager;
  9.         //获取唯⼀的全局静态哈希Map
  10.         AssociationsHashMap &associations(manager.get());
  11.         //通过关联对象寻址Iterator
  12.         AssociationsHashMap::iterator i = associations.find((objc_object *)object);
  13.         if (i != associations.end()) {
  15.             //替换
  16.             refs.swap(i->second);
  18.             // If we are not deallocating, then SYSTEM_OBJECT associations are preserved.
  19.             bool didReInsert = false;
  20.             if (!deallocating) {
  21.                 for (auto &ref: refs) {
  22.                     if (ref.second.policy() & OBJC_ASSOCIATION_SYSTEM_OBJECT) {
  23.                         i->second.insert(ref);
  24.                         didReInsert = true;
  25.                     }
  26.                 }
  27.             }
  28.             //移除Iterator
  29.             if (!didReInsert)
  30.                 associations.erase(i);
  31.         }
  32.     }
  34.     // Associations to be released after the normal ones.
  35.     SmallVector<ObjcAssociation *, 4> laterRefs;
  37.     // release everything (outside of the lock).
  38.     for (auto &i: refs) {
  39.         if (i.second.policy() & OBJC_ASSOCIATION_SYSTEM_OBJECT) {
  40.             // If we are not deallocating, then RELEASE_LATER associations don't get released.
  41.             if (deallocating)
  42.                 laterRefs.append(&i.second);
  43.         } else {
  44.             i.second.releaseHeldValue();
  45.         }
  46.     }
  48.     //循环销毁
  49.     for (auto *later: laterRefs) {
  50.         later->releaseHeldValue();
  51.     }
  52. }

关联对象销毁流程：dealloc→_objc_rootDealloc→rootDealloc→object_dispose→objc_destructInstance→_object_remove_assocations

3.4.7 clearDeallocating

  1. inline void 
  2. objc_object::clearDeallocating()
  3. {
  4.     if (slowpath(!isa.nonpointer)) {
  5.         // Slow path for raw pointer isa.
  6.         sidetable_clearDeallocating();
  7.     }
  8.     else if (slowpath(isa.weakly_referenced  ||  isa.has_sidetable_rc)) {
  9.         // Slow path for non-pointer isa with weak refs and/or side table data.
  10.         clearDeallocating_slow();
  11.     }
  13.     assert(!sidetable_present());
  14. }

3.4.8 clearDeallocating_slow

  1. NEVER_INLINE void
  2. objc_object::clearDeallocating_slow()
  3. {
  4.     ASSERT(isa.nonpointer  &&  (isa.weakly_referenced || isa.has_sidetable_rc));
  6.     SideTable& table = SideTables()[this];
  7.     table.lock();
  8.     if (isa.weakly_referenced) {
  9.         weak_clear_no_lock(&table.weak_table, (id)this);
  10.     }
  11.     if (isa.has_sidetable_rc) {
  12.         table.refcnts.erase(this);
  13.     }
  14.     table.unlock();
  15. }
  • weak_clear_no_lock：弱引用销毁
  • table.refcnts.erase：清空引用计数

总结

类扩展 VS 分类：

  • 类扩展（Extension）
    • 特殊的分类，也称作匿名分类
    • 可以给类添加成员属性，但是为私有变量
    • 可以给类添加方法，也是私有方法
  • 分类（Category）
    • 专门用来给类添加新的方法
    • 不能给类添加成员属性，添加后无法读取（可通过Runtime给分类添加属性）
    • 分类中使用@property定义变量，只会生成变量的getter/setter方法的声明，不能生成方法的实现和下划线开头的成员变量

类扩展的分析：

  • 所以类扩展并不会影响主类的加载流程，在编译时，类扩展中的属性和方法和主类融为一体
  • 创建的类扩展只有·h文件，所以只做声明，实现需要依赖于当前的主类

关联对象：

  • 分类中，不能直接使用属性的getter/setter方法，只能使用关联对象的方式实现成员变量的效果
  • objc_setAssociatedObject
    • object：被关联者
    • key：标识符
    • value：值
    • policy：关联策略
  • objc_removeAssociatedObjects
    • object：被关联者
    • key：标识符
  • 关联策略：nonatomic、atomic、assign、retain、copy等修饰

objc_setAssociatedObject & objc_getAssociatedObject：

  • 函数为中间层层代码，目的是对业务层进行隔离。因为底层API根据不同版本会发生变化，但中间层代码是保持不变的，所以开发者不用担心因底层API变化导致程序的修改

_object_set_associative_reference：

【步骤一】

  • 将不同类型的object，保存成统一的DisguisedPtr<objc_object>结构
  • 将关联策略和值，以面向对象的方式进行存储ObjcAssociation类中
  • 根据不同的关联策略进行处理

【步骤二】

  • 调用构造函数，加锁。函数作用域结束AssociationsManager释放，调用析构函数，解锁
  • AssociationsHashMap为单例，在内存中只有一份

【步骤三】

  • 如果value存在，进行关联
    • 调用AssociationsHashMap的try_emplace函数，将object和ObjectAssociationMap关联
    • 返回结果refs_result，如果是首次关联，打标记
    • 在refs_result中找到object关联的Bucket
    • 调用Bucket的try_emplace函数，将key关联ObjcAssociation类
    • 如果存在旧值，替换为新值
  • 如果传入的value不存在，移除关联
    • 通过关联对象寻址Iterator
    • 获取ObjectAssociationMap
    • 替换ObjcAssociation，新值替换旧值
    • 移除旧值
    • 如果关联对象关联的Iterator为空，直接移除

【步骤四】

  • 在nonpointerIsa中标记，当对象销毁时，关联对象也要跟随销毁
  • 释放旧值

_object_get_associative_reference：

【第一步】

  • 调用构造函数，加锁。函数作用域结束AssociationsManager释放，调用析构函数，解锁
  • AssociationsHashMap为单例，在内存中只有一份

【第二步】

  • 通过关联对象寻址Iterator
  • 获取ObjectAssociationMap

【第三步】

  • 通过key寻址Iterator
  • 获取ObjcAssociation
  • 保留返回值

【第四步】

  • 生成自动返回值

关联对象的销毁：

  • 关联对象的销毁，依赖于被关联对象的生命周期。当被关联对象被销毁时，它的关联对象会自动销毁
  • 对象销毁流程：
    • C++函数释放 ：objc_cxxDestruct
    • 关联对象销毁：_object_remove_assocations
    • 弱引用销毁：weak_clear_no_lock
    • 清空引用计数：table.refcnts.erase
    • 销毁对象：free
  • 销毁流程：dealloc→_objc_rootDealloc→rootDealloc→object_dispose→objc_destructInstance→_object_remove_assocations

AssociationsHashMap：

  • 单例，使用static修饰，全局静态对象
  • 双层HashMap结构

AssociationsManager：

  • 可创建多份，并为唯一
  • AssociationsManager()：构造函数，加锁
  • ~AssociationsManager()：析构函数，解锁
  • 加锁、解锁操作，保证对象的安全性，防止冲突

AssociationsManager的初始化：

  • 初始化流程：map_images→map_images_nolock→arr_init→_objc_associations_init
  • 在map_images时，系统创建AssociationsHashMap关联对象表。和它一起被创建的全局系统表，还有AutoreleasePoolPage自动释放池，以及SideTablesMap散列表
  • SideTablesMap散列表中包含两张子表，分别是RefcountMap引用计数表，还有weak_table_t弱引用表