定义

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

isa详解

  • 学习Runtime，首先了解底层的常用数据结构，比如iso指针
  • 在arm64架构之前，isa就是一个普通的指针，存储着Class，Meta-Class对象的内存地址
  • 从arm64架构开始，对isa进行了优化，变成了一个共用体（union）结构，还使用位域来存储更多的信息
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
union isa_t {
    Class cls;
    uintptr_t bits;
    struct {
        uintptr_t nonpointer                : 1;
        uintptr_t has_assoc                 : 1;
        uintptr_t has_cxx_dtor              : 1;
        uintptr_t shiftcls                  : 33;
        uintptr_t magic                     : 6;
        uintptr_t weakly_referenced         : 1;
        uintptr_t deallocating              : 1;
        uintptr_t has_sidetable_rc          : 1;
        uintptr_t extra_rc                  : 19;
    }
}

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的结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
struct objc_object {
private:
    isa_t isa;
public:
    .
    .
    .
}
struct objc_class : objc_object {
    // Class ISA;
    Class superclass;
    cache_t cache;            // 方法缓存
    class_data_bits_t bits;  // 用于获取具体的类信息  &FAST_DATA_MASK
};

bits &FAST_DATA_MASK，可以得到class_rw_t

1
2
3
4
5
6
7
8
9
10
11
struct class_rw_t {
    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;
};

class_ro_t的内容如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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;
    method_list_t *baseMethods() const {
        return baseMethodList;
    }
};

class_rw_t

class_rw_t里面的methos, properties, protocols是二维数组，是可读可写的，包含了类的初始内容、分类的内容

  • methods里面包含多个method_list_t
  • method_list_t里面包含多个method_t
1
method_array_t methods; -> method_list_t -> method_t

class_ro_t

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

  • baseMethodList里面包含多个method_t
1
method_list_t * baseMethodList; -> method_t

method_t

method_t是对方法/函数的封装

1
2
3
4
5
struct method_t {
    SEL name;   //函数名
    const char *types;  //编码（返回值类型、参数类型）
    IMP imp;    //指向函数的指针（函数地址）
}

IMP代表函数的具体表现

1
typedef id _Nullable (*IMP)(id _Nonnull, SEL _Nonnull, ...);

SEL代表方法/函数名，一般叫做选择器，底层结构跟char*类似

  • 可以通过@selector()和sel_registerName()获得
  • 可以通过sel_getName()和NSStringFromSelector()转成字符串
  • 不同类中相同名字的方法，所对应的方法选择器是相同的
1
typedef struct objc_selector *SEL;

types包含了函数返回值、参数编码的字符串

cache_t - 方法缓存

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

1
2
3
4
5
6
7
8
9
10
11
12
struct cache_t {
    struct bucket_t *_buckets;//散列表
    mask_t _mask;//散列表的长度 -1
    mask_t _occupied;//已经缓存的方法数量

public:
    struct bucket_t *buckets();
    mask_t mask();
    .
    .
    .
};

_buckets里面存放着许多bucket_t，bucket_t结构如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
struct bucket_t {
private:
    cache_key_t _key;// SEL作为key
    IMP _imp;//函数的内存地址

public:
    inline cache_key_t key() const { return _key; }
    inline IMP imp() const { return (IMP)_imp; }
    inline void setKey(cache_key_t newKey) { _key = newKey; }
    inline void setImp(IMP newImp) { _imp = newImp; }

    void set(cache_key_t newKey, IMP newImp);
};

缓存查找，利用空间换时间的缓存机制
objc-cache.mm文件
bucket_t * cache_t::find(cache_key_t k, id receiver)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
bucket_t * cache_t::find(cache_key_t k, id receiver)
{
    assert(k != 0);

    bucket_t *b = buckets();
    mask_t m = mask();
    mask_t begin = cache_hash(k, m);
    mask_t i = begin;
    do {
        if (b[i].key() == 0  ||  b[i].key() == k) {
            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)k, cls);
}

参考