Runtime(2)--对象和类

Runtime交互

我们的OC语言是离不开runtime的。

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

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

NSObject

在OC中，基本上所有的类的基类，都是NSObject。因此要深入了解OC中的类的结构，就要从NSObject这个类说起。

我们可以查看定义看到NSObject的实现

@interface NSObject <NSObject> {
    Class isa  OBJC_ISA_AVAILABILITY;
}

NSObject仅有一个实例变量Class isa：

/// An opaque type that represents an Objective-C class.
typedef struct objc_class *Class;

Class实质上是指向objc_class的指针。而objc_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 *data() const {
        return bits.data();
    }
    
    void setData(class_rw_t *newData) {
        bits.setData(newData);
    }

    void setInfo(uint32_t set) {
        ASSERT(isFuture()  ||  isRealized());
        data()->setFlags(set);
    }

    void clearInfo(uint32_t clear) {
        ASSERT(isFuture()  ||  isRealized());
        data()->clearFlags(clear);
    }
......省略其余方法

可以看到，objc_class继承自objc_object , 即在runtime中，class也被看做一种对象。 在objc_class中，有三个数据成员：

Class superclass ：同样是Class类型，表明当前类的父类。

cache_t cache：cache用于优化方法调用
class_data_bits_t bits：这是Class的核心，其本质是一个可以被Mask的指针类型。根据不同的Mask，可以取出不同的值。

• 我们看一下bits的数据结构

struct class_data_bits_t {
    friend objc_class;

    // Values are the FAST_ flags above.
    uintptr_t bits;
private:
    bool getBit(uintptr_t bit) const
    {
        return bits & bit;
    }

    // Atomically set the bits in `set` and clear the bits in `clear`.
    // set and clear must not overlap.
    void setAndClearBits(uintptr_t set, uintptr_t clear)
    {
        ASSERT((set & clear) == 0);
        uintptr_t oldBits;
        uintptr_t newBits;
        do {
            oldBits = LoadExclusive(&bits);
            newBits = (oldBits | set) & ~clear;
        } while (!StoreReleaseExclusive(&bits, oldBits, newBits));
    }

    void setBits(uintptr_t set) {
        __c11_atomic_fetch_or((_Atomic(uintptr_t) *)&bits, set, __ATOMIC_RELAXED);
    }

    void clearBits(uintptr_t clear) {
        __c11_atomic_fetch_and((_Atomic(uintptr_t) *)&bits, ~clear, __ATOMIC_RELAXED);
    }

public:

    class_rw_t* data() const {
        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;
    }

    // Get the class's ro data, even in the presence of concurrent realization.
    // fixme this isn't really safe without a compiler barrier at least
    // and probably a memory barrier when realizeClass changes the data field
    const class_ro_t *safe_ro() {
        class_rw_t *maybe_rw = data();
        if (maybe_rw->flags & RW_REALIZED) {
            // maybe_rw is rw
            return maybe_rw->ro;
        } else {
            // maybe_rw is actually ro
            return (class_ro_t *)maybe_rw;
        }
    }
......省略其他

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

例如，我们需要取出Classs的核心信息class_rw_t, 则需要调用方法(bits中包含的一个pulic方法)：

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

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

• 我们看一下Class的核心结构class_rw_t ：

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;         // 类不可修改的原始核心

    /* 下面三个array，method,property, protocol，可以被runtime    扩展，如Category。
       method_array_t、property_array_t、protocol_array_t这三个都是class类型不是struct。
      分别是继承于:
      public list_array_tt<method_t, method_list_t>、
      public list_array_tt<property_t, property_list_t> 、
      public list_array_tt<protocol_ref_t, protocol_list_t> 
*/
    method_array_t methods; 
    property_array_t properties;
    protocol_array_t protocols;

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

    // Class对应的 符号名称
    char *demangledName;
    
    // 以下方法省略
    ...
}

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：
这三个数组是可以被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_class的data()方法最初返回的是const class_ro_t *类型，也就是类的基本信息。因为在调用realizeClass方法前，Category定义的各种方法，属性还没有附加到class上，因此只能够返回类的基本信息。

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

141601453593_.pic_hd.jpg
得出结论，在class没有调用realizeClassWithoutSwift之前，不是真正完整的类。

• 看下具体的流程

  
  20200113171831172.jpg
  20200113171907746.jpg
  20200113171941833.png

objc_object

OC的底层实现是runtime，在runtime这一层，对象被定义为objc_object 结构体，类被定义为了objc_class 结构体。而objc_class 继承于objc_object， 因此，类可以看做是一类特殊的对象。

现在就来看objc_object是如何定义的：

struct objc_object {
private:
    isa_t isa;

public:

    // ISA() assumes this is NOT a tagged pointer object
    Class ISA();

    // rawISA() assumes this is NOT a tagged pointer object or a non pointer ISA
    Class rawISA();

    // getIsa() allows this to be a tagged pointer object
    Class getIsa();
    
    uintptr_t isaBits() const;

    // initIsa() should be used to init the isa of new objects only.
    // If this object already has an isa, use changeIsa() for correctness.
    // initInstanceIsa(): objects with no custom RR/AWZ
    // initClassIsa(): class objects
    // initProtocolIsa(): protocol objects
    // initIsa(): other objects
    void initIsa(Class cls /*nonpointer=false*/);
    void initClassIsa(Class cls /*nonpointer=maybe*/);
    void initProtocolIsa(Class cls /*nonpointer=maybe*/);
    void initInstanceIsa(Class cls, bool hasCxxDtor);
......省略其他

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

objc_object & objc_class

如果我们再回头看一下objc_object和objc_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 * 指针
   。。。
}

提一句
我们可以用id表示任意类型的类实例变量。在runtime中，id是这样定义的：
typedef struct objc_object *id;
其实是一个objc_object *，因为objc_object的isa存在，所有runtime是可以知道id类型对应的真正类型的。这个和C里面的void *还是有区别的。

总结

151601456375_.pic_hd.jpg