Runtime源码理解cache_t(方法缓存)

Class内部结构中有个方法缓存（catch_t），用散列表来缓存曾经调用过的方法，可以提高方法的查找速度。

struct objc_class : objc_object {
   Class isa;
    Class superclass;
    cache_t cache;             // 方法缓存
    class_data_bits_t bits;    // 使用共用体存储类的信息  &FAST_DATA_MASK 获得class_rw_t结构
}

class_ro_t和class_rw_t的区别

class_ro_t存储了当前类在编译期就已经确定的属性、方法以及遵循的协议，里面是没有分类的方法的,是只读的不能修改。

struct class_ro_t {
    method_list_t * baseMethodList; //方法列表（一维数组）
    protocol_list_t * baseProtocols;//协议列表（一维数组）
    const ivar_list_t * ivars; //成员变量列表
    property_list_t *baseProperties; // 属性列表（一维数组）
};

class_rw_t是在runtime时才确定，它会先将class_ro_t的内容拷贝过去，然后再将当前类的分类的这些属性、方法等拷贝到其，所以可以说class_rw_t是class_ro_t的超集。

struct class_rw_t {
//指向只读的结构体，存放类初始信息
   const class_ro_t *ro;

/*
这三个都是二维数组，是可读可写的，包含了类的初始信息、分类的信息
methods数组中存储着method_list_t 数组
method_list_t数组 中存储着method_t
runtime会将class_ro_t 中的类初始信息合并到这三个数组中
*/
    method_array_t methods; //方法列表（二维数组）
    property_array_t properties;;//属性列表（二维数组）
    protocol_array_t protocols;// 协议列表（二维数组）
}

method_t是对方法/函数的封装。

struct method_t {
    SEL name; //函数名   不同类中相同名字的方法，所对应的方法选择器是相同的。
    const char *types; //编码（包括返回值类型,参数类型）
    IMP imp; //指向函数的指针
};

cache_t 方法缓存

struct cache_t {
    struct bucket_t *_buckets;   //散列表
    mask_t _mask;  //散列表的长度 - 1   作用：和SEL进行&操作，得到散列表的下标，存储方法
    mask_t _occupied; //已经缓存的方法数量   作用： 用于cache_t扩容的判断
}

struct bucket_t {
    cache_key_t _key;    //SEL做为key
    IMP _imp;  //函数的内存地址
}

查看缓存
编写Object的底层C++结构体代码

#import <Foundation/Foundation.h>

#ifndef ClassInfo_h
#define ClassInfo_h

# if __arm64__
#   define ISA_MASK        0x0000000ffffffff8ULL    //用于取出isa所表示class 、meta_class 的地址
# elif __x86_64__   //模拟器或Mac电脑
#   define ISA_MASK        0x00007ffffffffff8ULL     
# endif

#if __LP64__
typedef uint32_t mask_t;
#else
typedef uint16_t mask_t;
#endif
typedef uintptr_t cache_key_t;

#if __arm__  ||  __x86_64__  ||  __i386__
#define CACHE_END_MARKER 1
static inline mask_t cache_next(mask_t i, mask_t mask) {
    return (i+1) & mask;
}

#elif __arm64__
#define CACHE_END_MARKER 0
static inline mask_t cache_next(mask_t i, mask_t mask) {
    return i ? i-1 : mask;
}

#else
#error unknown architecture
#endif

//散列表中缓存的方法信息
struct bucket_t {
    cache_key_t _key;
    IMP _imp;
};

//缓存方法的底层结构
struct cache_t {
    bucket_t *_buckets;
    mask_t _mask;
    mask_t _occupied;
    
    IMP imp(SEL selector)
    {
        mask_t begin = _mask & (long long)selector;
        mask_t i = begin;
        do {
            if (_buckets[i]._key == 0  ||  _buckets[i]._key == (long long)selector) {
                return _buckets[i]._imp;
            }
        } while ((i = cache_next(i, _mask)) != begin);
        return NULL;
    }
};

struct entsize_list_tt {
    uint32_t entsizeAndFlags;
    uint32_t count;
};

// 方法的底层结构
struct method_t {
    SEL name;
    const char *types;
    IMP imp;
};

struct method_list_t : entsize_list_tt {
    method_t first;
};

struct ivar_t {
    int32_t *offset;
    const char *name;
    const char *type;
    uint32_t alignment_raw;
    uint32_t size;
};

struct ivar_list_t : entsize_list_tt {
    ivar_t first;
};

struct property_t {
    const char *name;
    const char *attributes;
};

struct property_list_t : entsize_list_tt {
    property_t first;
};

struct chained_property_list {
    chained_property_list *next;
    uint32_t count;
    property_t list[0];
};

typedef uintptr_t protocol_ref_t;
struct protocol_list_t {
    uintptr_t count;
    protocol_ref_t list[0];
};

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;
};

struct class_rw_t {
    uint32_t flags;
    uint32_t version;
    const class_ro_t *ro;
    method_list_t * methods;    // 方法列表
    property_list_t *properties;    // 属性列表
    const protocol_list_t * protocols;  // 协议列表
    Class firstSubclass;
    Class nextSiblingClass;
    char *demangledName;
};

#define FAST_DATA_MASK          0x00007ffffffffff8UL
struct class_data_bits_t {
    uintptr_t bits;
public:
    class_rw_t* data() {
        return (class_rw_t *)(bits & FAST_DATA_MASK);
    }
};

/* OC对象 */
struct lc_objc_object {
    void *isa;
};

/* 类对象 */
struct lc_objc_class : lc_objc_object {
    Class superclass;
    cache_t cache;
    class_data_bits_t bits;
public:
    class_rw_t* data() {
        return bits.data();
    }
    
    lc_objc_class* metaClass() {
        return (lc_objc_class *)((long long)isa & ISA_MASK);
    }
};

#endif /* ClassInfo_h */

创建项目并把Object的C++代码导入项目。

#import <Foundation/Foundation.h>
#import "ClassInfo.h"
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Person *person = [[Person alloc] init];
       lc_objc_class *personClass = (__bridge lc_objc_class *)[Person class];

        [person personTest];
         cache_t cache = personClass->cache;
        bucket_t *buckets = cache._buckets;
        NSLog(@"%d  %d",cache._mask,cache._occupied);
        for (int i = 0; i <= cache._mask; i++) {
            bucket_t bucket = buckets[i];
              NSLog(@"%s %p", bucket._key, bucket._imp);
        }
        NSLog(@"-----------");
    }
    return 0;
}
打印如下
2021-09-26 20:27:15.416361+0800 Interview01-cache[35703:1646916] init 0x7ffe2041bc45
2021-09-26 20:27:29.823632+0800 Interview01-cache[35703:1646916] personTest 0x7e78

在控制台中就可以看到缓存列表中缓存的方法，在调用personTest前，方法缓存列表中只有init方法，在调用personTest后，personTest方法就会存储到方法列表中，方便下次快速调用。