runtime源码解析--基本数据结构

前言

从本篇文章开始,就进入runtime的正篇

什么是runtime?

OC是一门动态语言,与C++这种静态语言不同,静态语言的各种数据结构在编译期已经决定了,不能够被修改。而动态语言却可以使我们在程序运行期,动态的修改一个类的结构,如修改方法实现,绑定实例变量等。

OC作为动态语言,它总会想办法将静态语言在编译期决定的事情,推迟到运行期来做。所以,仅有编译器是不够的,它需要一个运行时系统(runtime system),这也就是OC的runtime系统的意义,它是OC运行框架的基石。

与runtime交互

我们的OC语言是离不开runtime的。我们会在三个层次上和runtime进行交互,分别是:OC源码,通过Foundation框架定义的NSObject方法,直接调用runtime提供的接口方法。

  • OC源码:大多数情况下,我们仅使用OC语言来编写代码,如NSObject,类属性,中括号的方法调用,协议,分类等。而这一切的背后,都是由runtime来支持的。我们平常所熟知的各种类型,背后都有runtime对应的C语言结构体,及C和汇编实现。
  • NSObject: Cocoa中大部分类均继承于NSObject,因此大多数类都继承了NSObject所提供的方法。在NSObject中,有若干方法是运行时动态决定结果的,这背后其实是runtime系统对应数据结构的支持。如isKindOfClassisMemberOfClass 检查类是否属于指定的Class的继承体系中;responderToSelector 检查对象是否能响应指定的消息;conformsToProtocol 检查对象是否遵循某个协议;methodForSelector返回指定方法实现的地址。
  • Runtime函数:Runtime 系统是一个由一系列函数和数据结构组成,具有公共接口的动态共享库。头文件存放于/usr/include/objc目录下。许多函数允许你用纯C代码来重复实现 Objc 中同样的功能。虽然有一些方法构成了NSObject类的基础,但是你在写 Objc 代码时一般不会直接用到这些函数的,除非是写一些 Objc 与其他语言的桥接或是底层的debug工作。在Objective-C Runtime Reference中有对 Runtime 函数的详细文档。

就如在我们在前传篇中提到的,所谓的runtime黑魔法,只是基于OC各种底层数据结构上的应用。

因此,要想了解runtime,就要先了解runtime中定义的各种数据结构。我们先从最基础的objc_object和objc_class开始。

objc_object

OC的底层实现是runtime,在runtime这一层,对象被定义为objc_object 结构体,类被定义为了objc_class 结构体。
我们先看objc_object

// jack.deng  对象的定义
struct objc_object {
private:
    isa_t isa; // isa联合体
public:
    // ISA() assumes this is NOT a tagged pointer object
    Class ISA();  // 获取类名
    // getIsa() allows this to be a tagged pointer object
    Class getIsa();
// 省略其余方法
}

可以看到,objc_object的定义很简单,仅包含一个isa_t 类型。

// jack.deng  isa的定义
union isa_t 
{
    isa_t() { }
    isa_t(uintptr_t value) : bits(value) { }

    Class cls;
    uintptr_t bits;

    // 省略其余
    。。。
}

isa_t 是一个联合,可以表示多种类型,但是我们这里仅关注Class cls ,它表明了对象属于哪个类。关于isa_t 可以表示的其他类型,我们会在其他章节中描述。

objc_class

isa_tClass 类型其实是 typedef struct objc_class *Class 一个指针,指向objc_class 结构体。

// jack.deng   Class的定义
//  typedef struct objc_class *Class;
struct objc_class : objc_object {
    // Class ISA;
    Class superclass; // 父类指针
    cache_t cache;             // formerly cache pointer and vtable // 缓存指针和虚表
    class_data_bits_t bits;    // class_rw_t * plus custom rr/alloc flags  
// class_rw_t *加上自定义的rr/alloc标志  
// rr/alloc标志是指含有这些方法:retain/release/autorelease/retainCount/alloc等。

    class_rw_t *data() { 
        return bits.data();
    }
    void setData(class_rw_t *newData) {
        bits.setData(newData);
    }
    // 省略其他方法
    。。。
}

可以看到,objc_class继承自objc_object , 即在runtime中,class也被看做一种对象。 在objc_class中,有三个数据成员:
Class superclass :同样是Class类型,表明当前类的父类。
cache_t cache :cache用于优化方法调用,其对应的数据结构如是:

struct cache_t {
    struct bucket_t *_buckets;
    mask_t _mask;
    mask_t _occupied;

    // 省略其余方法
    。。。   
}

typedef uintptr_t cache_key_t;

struct bucket_t {
private:
    cache_key_t _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);
};

cache的核心是有一个类型为bucket_t的指针,它指向了一个以_keyIMP对应的缓存节点。

runtime方法调用的流程是,当要调用一个方法时,先不去Class的方法列表中查找,而是先去找cache_t cache 。当系统调用过一个方法后,会将其实现IMPkey存放到cache中,因为理论上一个方法调用过后,被再次调用的概率很大。关于方法调用,我们将会在别的章节描述。

class_data_bits_t bits:这是Class的核心,其本质是一个可以被Mask的指针类型。根据不同的Mask,可以取出不同的值。

struct class_data_bits_t {

    // Values are the FAST_ flags above.
    uintptr_t bits;

    public:
    class_rw_t* data() {
        return (class_rw_t *)(bits & FAST_DATA_MASK);
    }
    void setData(class_rw_t *newData)
    {
        assert(!data()  ||  (newData->flags & (RW_REALIZING | RW_FUTURE)));
        // Set during realization or construction only. No locking needed.
        // Use a store-release fence because there may be concurrent
        // readers of data and data's contents.
        uintptr_t newBits = (bits & ~FAST_DATA_MASK) | (uintptr_t)newData;
        atomic_thread_fence(memory_order_release);
        bits = newBits;
    }
    // 省略其余方法
}

class_data_bits_t bits 仅含有一个成员uintptr_t bits, 可以理解为一个‘复合指针’。什么意思呢,就是bits不仅包含了指针,同时包含了Class的各种异或flag,来说明Class的属性。把这些信息复合在一起,仅用一个uint指针bits来表示。当需要取出这些信息时,需要用对应的以FAST_前缀开头的flag掩码对bits做按位与操作。

例如,我们需要取出Classs的核心信息class_rw_t, 则需要调用方法:

class_rw_t* data() {
        return (class_rw_t *)(bits & FAST_DATA_MASK);
    }

该方法返回一个class_rw_t*,需要对bits进行FAST_DATA_MASK 的与操作。

bits在内存中有三种位排列方式:

32位

0 1 2-31
FAST_IS_SWIFT FAST_HAS_DEFAULT_RR FAST_DATA_MASK

64位兼容版

0 1 2 3-46 47-63
FAST_IS_SWIFT FAST_HAS_DEFAULT_RR FAST_REQUIRES_RAW_ISA FAST_DATA_MASK 空闲

64位不兼容版

0 1 2 3-46 47 48 49 50 51 52-63
FAST_IS_SWIFT FAST_REQUIRES_RAW_ISA FAST_HAS_CXX_DTOR FAST_DATA_MASK FAST_HAS_CXX_CTOR FAST_HAS_DEFAULT_AWZ FAST_HAS_DEFAULT_RR FAST_ALLOC FAST_SHIFTED_SIZE_SHIFT 空闲

不兼容版本的宏定义如下:

// class is a Swift class
#define FAST_IS_SWIFT           (1UL<<0)
// class's instances requires raw isa
#define FAST_REQUIRES_RAW_ISA   (1UL<<1)
// class or superclass has .cxx_destruct implementation
//   This bit is aligned with isa_t->hasCxxDtor to save an instruction.
#define FAST_HAS_CXX_DTOR       (1UL<<2)
// data pointer
#define FAST_DATA_MASK          0x00007ffffffffff8UL
// class or superclass has .cxx_construct implementation
#define FAST_HAS_CXX_CTOR       (1UL<<47)
// class or superclass has default alloc/allocWithZone: implementation
// Note this is is stored in the metaclass.
#define FAST_HAS_DEFAULT_AWZ    (1UL<<48)
// class or superclass has default retain/release/autorelease/retainCount/
//   _tryRetain/_isDeallocating/retainWeakReference/allowsWeakReference
#define FAST_HAS_DEFAULT_RR     (1UL<<49)
// summary bit for fast alloc path: !hasCxxCtor and 
//   !instancesRequireRawIsa and instanceSize fits into shiftedSize
#define FAST_ALLOC              (1UL<<50)
// instance size in units of 16 bytes
//   or 0 if the instance size is too big in this field
//   This field must be LAST
#define FAST_SHIFTED_SIZE_SHIFT 51

让我们再看一下Class的核心结构class_rw_t

// jack.deng  class_rw_t结构体的定义
// rw应该是readwrite的意思
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;         // 类不可修改的原始核心
   // rw跟ro很像,它拥有一个ro
    // class_ro_t存放在编译期就确定的信息, class_rw_t用来存放在运行期添加的信息
    // 下面三个array,method,property, protocol,可以被runtime 扩展,如Category
    method_array_t methods;
    property_array_t properties;
    protocol_array_t protocols;

    // 和继承相关的东西
    Class firstSubclass;
    Class nextSiblingClass;

    // Class对应的 符号名称
    char *demangledName;

    // 以下方法省略
    ...
}
// jack.deng    class_ro_t结构体的定义
// ro应该是readonly的意思
struct class_ro_t {
    uint32_t flags;
    uint32_t instanceStart;
    uint32_t instanceSize;
#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_ro_t 中包含了类的名称,以及method_list_t, protocol_list_t, ivar_list_t, property_list_t 这些类的基本信息。 在class_ro_t 的信息是不可修改和扩展的。

而在更外一层 class_rw_t 中,有三个数组method_array_t, property_array_t, protocol_array_t

struct class_rw_t {

    ...
    const class_ro_t *ro;         // 类不可修改的原始核心

    // 下面三个array,method,property, protocol,可以被runtime 扩展,如Category
    method_array_t methods;
    property_array_t properties;
    protocol_array_t protocols;
    ...
}

这三个数组是可以被runtime动态扩展的。
objc_class 中包含class_data_bits_t, class_data_bits_t 中通过FAST_DATA_MASK获取指向class_rw_t类型的指针,而在class_rw_t中包含class_ro_t,类的核心const信息。

realizeClass

objc_classdata()方法最初返回的是const class_ro_t * 类型,也就是类的基本信息。因为在调用realizeClass方法前,Category定义的各种方法,属性还没有附加到class上,因此只能够返回类的基本信息。

而当我们调用realizeClass时,会在函数内部将Category中定义的各种扩展附加到class上,同时改写data()的返回值为class_rw_t *类型,核心代码如下:

const class_ro_t *ro;
    class_rw_t *rw;
    ro = (const class_ro_t *)cls->data();
    if (ro->flags & RO_FUTURE) {
        // This was a future class. rw data is already allocated.
        rw = cls->data();
        ro = cls->data()->ro;
        cls->changeInfo(RW_REALIZED|RW_REALIZING, RW_FUTURE);
    } else {
        // Normal class. Allocate writeable class data.
        rw = (class_rw_t *)calloc(sizeof(class_rw_t), 1);
        rw->ro = ro;
        rw->flags = RW_REALIZED|RW_REALIZING;
        cls->setData(rw);
    }

得出结论,在class没有调用realizeClass之前,不是真正完整的类。

objc_object & objc_class

如果我们再回头看一下objc_objectobjc_class的定义,可以发现object和class是你中有我,我中有你的:

struct objc_object {
private:
    isa_t isa; // unit联合,可以表示Class类型,表明Object所属的类
    。。。
}

struct objc_class : objc_object { // objc_class继承自objc_object,表明objc_class也是一个objc_object
   Class superclass; // super class 是一个objc_class * 指针
   。。。
}

如果用UML图表示的话:


runtime源码解析--基本数据结构_第1张图片

可以看到,objc_class也是一个objc_object类型,这意味着,objc_class中也有一个属性isa,而这个isa,可以表示当前类属于(注意不是继承)哪个类。而这种说明类是属于哪个类的类,我们称之为元类meta-class)。

这里再重申一遍,元类不是类的父类。至于元类的用途,我们将会在OC的消息转发中详细讲解。现在只需要知道,每一个类都有一个与其对应的元类。

id

我们可以用id表示任意类型的类实例变量。在runtime中,id是这样定义的:

typedef struct objc_object *id;

其实是一个objc_object *,因为objc_objectisa存在,所有runtime是可以知道id类型对应的真正类型的。这个和C里面的void *还是有区别的。

你可能感兴趣的:(runtime源码解析--基本数据结构)