iOS底层原理 - Runtime-01

1.Objective-C是一门动态性比较强的编程语言，跟C、C++等语言有着很大的不同
2.Objective-C的动态性是由Runtime API来支撑的
3.Runtime API提供的接口基本都是C语言的，源码由C\C++\汇编语言编写

一.isa详解

我们都知道实例化对象的isa指针并不是直接等于类对象的指针地址而是&ISA_MASK 才等于类对象的指针地址，或者说类对象的isa指针地址是&ISA_MASK 才等于元类对象的指针地址

要想学习Runtime，首先要了解它底层的一些常用数据结构，比如isa指针

在arm64架构之前，isa就是一个普通的指针，存储着Class、Meta-Class对象的内存地址

从arm64架构开始，对isa进行了优化，变成了一个共用体（union）结构，还使用位域来存储更多的信息

union isa_t {
    isa_t() { }
    isa_t(uintptr_t value) : bits(value) { }
    Class cls;
    uintptr_t bits;
    uintptr_t nonpointer        : 1;         
      uintptr_t has_assoc         : 1;          
      uintptr_t indexcls          : 15;         
      uintptr_t magic             : 4;          
      uintptr_t has_cxx_dtor      : 1;          
      uintptr_t weakly_referenced : 1;          
      uintptr_t deallocating      : 1;          
      uintptr_t has_sidetable_rc  : 1;          
      uintptr_t extra_rc          : 7
  }
};

isa详解 – 位域

nonpointer
0，代表普通的指针，存储着Class、Meta-Class对象的内存地址
1，代表优化过，使用位域存储更多的信息

has_assoc
是否有设置过关联对象，如果没有，释放时会更快

has_cxx_dtor
是否有C++的析构函数（.cxx_destruct），如果没有，释放时会更快

shiftcls
存储着Class、Meta-Class对象的内存地址信息

magic
用于在调试时分辨对象是否未完成初始化

weakly_referenced
是否有被弱引用指向过，如果没有，释放时会更快

deallocating
对象是否正在释放

extra_rc
里面存储的值是引用计数器减1

has_sidetable_rc
引用计数器是否过大无法存储在isa中
如果为1，那么引用计数会存储在一个叫SideTable的类的属性中

Class的结构

struct objc_class : objc_object {
    Class isa;
    Class superclass;
    class_rw_t *data() { 
        return bits.data();
    }
    cache_t cache;             // 方法缓存
    class_data_bits_t bits;    // 用于获取具体的类信息
}

struct class_rw_t {
    // Be warned that Symbolication knows the layout of this structure.
    uint32_t flags;
    uint32_t version;
    const class_ro_t *ro;

    method_array_t methods;//方法列表
    property_array_t properties;//属性列表
    protocol_array_t protocols;//协议列表

    Class firstSubclass;
    Class nextSiblingClass;

    char *demangledName;
}

struct class_ro_t {
    uint32_t flags;
    uint32_t instanceStart;
    uint32_t instanceSize;//instance对象占用的内存空间
#ifdef __LP64__
    uint32_t reserved;
#endif

    const uint8_t * ivarLayout;
    
    const char * name;//类名
    method_list_t * baseMethodList;
    protocol_list_t * baseProtocols;
    const ivar_list_t * ivars;//成员变量列表

    const uint8_t * weakIvarLayout;
    property_list_t *baseProperties;
}

class_rw_t

class_rw_t里面的methods、properties、protocols是二维数组，是可读可写的，包含了类的初始内容、分类的内容
class_rw_t设计成二维数组的目的就是为了可以动态的往里面添加方法或者修改方法

method_array_t methods;//方法列表

class method_array_t : 
    public list_array_tt<method_t, method_list_t> 
{
    typedef list_array_tt<method_t, method_list_t> Super;
}
struct method_t {//method_t是对方法\函数的封装
    SEL name;//函数名
    const char *types;//编码
    MethodListIMP imp;//指向函数的指针
};

IMP代表函数的具体实现
typedef id _Nullable (*IMP)(id _Nonnull, SEL _Nonnull, ...);

SEL代表方法\函数名，一般叫做选择器，底层结构跟char *类似
可以通过@selector()和sel_registerName()获得
可以通过sel_getName()和NSStringFromSelector()转成字符串
不同类中相同名字的方法，所对应的方法选择器是相同的

typedef struct objc_selector *SEL;

class_ro_t

class_ro_t里面的baseMethodList、baseProtocols、ivars、baseProperties是一维数组，是只读的，包含了类的初始内容

方法缓存cache_t

Class内部结构中有个方法缓存（cache_t），用散列表（哈希表）来缓存曾经调用过的方法，可以提高方法的查找速度，通过空间换时间来达到效果

缓存查找
objc-cache.mm
bucket_t * cache_t::find(SEL s, id receiver)

struct cache_t {
    struct bucket_t *_buckets;//散列表
    mask_t _mask;//散列表的长度 - 1
    mask_t _occupied;//已经缓存的方法数量
}
bucket_t * cache_t::find(SEL s, id receiver)
{
    assert(s != 0);

    bucket_t *b = buckets();
    mask_t m = mask();
    mask_t begin = cache_hash(s, m);
    mask_t i = begin;
    do {
        if (b[i].sel() == 0  ||  b[i].sel() == s) {
            return &b[i];
        }
    } while ((i = cache_next(i, m)) != begin);

    // hack
    Class cls = (Class)((uintptr_t)this - offsetof(objc_class, cache));
    cache_t::bad_cache(receiver, (SEL)s, cls);
}

当我们第一次调用方法的时候，会通过实例对象的isa指针去类对象找对应的方法，并把当前的方法保存到cache_t这个数组里面，当下次再调用的时候就不需要通过isa指针一层一层去method_array_t遍历查找,这样就可以提高方法的查找速度

这里我们通过代码来验证一下

     CCGoodStudent *person = [[CCGoodStudent alloc] init];
     mj_objc_class *personClass = (__bridge mj_objc_class *)[CCGoodStudent class];
     [person personTest];
     [person studentTest];
     [person goodstudentTest];
     [person personTest];
     [person studentTest];
        
     cache_t cache_t = personClass->cache;
     bucket_t *buckets = personClass->cache._buckets;
     for (int i = 0; i <= cache_t._mask ; i++) {
         bucket_t bucket = buckets[i];
         NSLog(@"%s   %p", bucket._key,bucket._imp);
     }

2019-11-27 02:09:17.744425+0800 Runtime[5916:487678] (null) 0x0
2019-11-27 02:09:17.744519+0800 Runtime[5916:487678] goodstudentTest 0x100000bf0
2019-11-27 02:09:17.744546+0800 Runtime[5916:487678] personTest 0x100000c20
2019-11-27 02:09:17.744561+0800 Runtime[5916:487678] (null) 0x0
2019-11-27 02:09:17.744574+0800 Runtime[5916:487678] studentTest 0x100000c50
2019-11-27 02:09:17.744586+0800 Runtime[5916:487678] (null) 0x0
2019-11-27 02:09:17.744597+0800 Runtime[5916:487678] (null) 0x0
2019-11-27 02:09:17.744608+0800 Runtime[5916:487678] (null) 0x0

可以看到无论我们的相同的方法调用几次，最终cache_t里面只会出现三个方法