前言

从本篇文章开始，就进入runtime的正篇。关于runtime的源码，大家可以在github中下载：

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系统对应数据结构的支持。如
isKindOfClass
和
isMemberOfClass
检查类是否属于指定的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开始。

从NSObject说起

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

在XCode中，我们可以通过查看定义来了解
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
的定义又是如何呢，在XCode中，我们继续查看定义：

struct objc_class {
    Class _Nonnull isa  OBJC_ISA_AVAILABILITY;

#if !__OBJC2__
    Class _Nullable super_class                              OBJC2_UNAVAILABLE;
    const char * _Nonnull name                               OBJC2_UNAVAILABLE;
    long version                                             OBJC2_UNAVAILABLE;
    long info                                                OBJC2_UNAVAILABLE;
    long instance_size                                       OBJC2_UNAVAILABLE;
    struct objc_ivar_list * _Nullable ivars                  OBJC2_UNAVAILABLE;
    struct objc_method_list * _Nullable * _Nullable methodLists                    OBJC2_UNAVAILABLE;
    struct objc_cache * _Nonnull cache                       OBJC2_UNAVAILABLE;
    struct objc_protocol_list * _Nullable protocols          OBJC2_UNAVAILABLE;
#endif

} OBJC2_UNAVAILABLE;

OK，到这里，对OC中类的结构的探索，我们先暂停一下。网上可以搜到很多博客，都是按照上面
objc_class
的定义来继续讲解的。

BUT！！！

难道都没有看到
OBJC2_UNAVAILABLE
这个提示吗？？？在OC 2.0中，这种关于
objc_class
的定义已经废弃掉了啊！许多博客都是在根本没有深入了解的情况下，就开始人云亦云，其实自己未必知道自己在说什么。这样做是很不负责任的，结果往往是误人子弟，自己不明白，还把别人带到了坑里。

吐槽完毕，我们继续来探索OC类的定义。前面说到，关于
objc_class
的定义，我们在XCode里面是看不到其真实的定义了，那么到哪里继续深入呢？看runtime源码。

在runtime源码的
objc-runtime-new.h
中，可以看到
objc_class
在OC 2.0中的定义。

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() { 
        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
的指针，它指向了一个以
_key
和
IMP
对应的缓存节点。

这里我们第一次遇到
uintptr_t
类型（
_key
）。在runtime中，
uintptr_t
定义为

#ifndef _UINTPTR_T
#define _UINTPTR_T
typedef unsigned long		uintptr_t;
#endif /* _UINTPTR_T */

可以理解为
void *
。

runtime方法调用的流程是，当要调用一个方法时，先不去Class的方法列表中查找，而是先去找
cache_t cache
。当系统调用过一个方法后，会将其实现
IMP
和
key
存放到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
：

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 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
：

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_class
的
data()
方法最初返回的是
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

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();

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

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

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

union isa_t 
{
    isa_t() { }
    isa_t(uintptr_t value) : bits(value) { }

    Class cls;
    uintptr_t bits;
	
	// 省略其余
	。。。
}

isa_t
是一个联合，可以表示Class cls或uintptr_t bits类型。实际上在OC 2.0里面，多数时间用的是uintptr_t bits。bits是一个64位的数据，每一位或几位都表示了关于当前对象的信息。具体的细节，我们将会在

Objective-C runtime机制(5)——iOS 内存管理

中作出描述。在这里我们先了解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 * 指针
   。。。
}

如果用UML图表示的话：

这里写图片描述

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

元类

（
meta-class
）。

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

id

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

typedef struct objc_object *id;

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

总结

在本章中，我们从
NSObject
的定义出发，了解了OC中类和对象所对应的数据结构
objc_class
和
objc_object
。关于
NSObject
，
objc_class
和
objc_object
三者之间的关系，我们可以用下面的图来更清晰的了解：

在这里插入图片描述

原文链接：https://blog.csdn.net/u013378438/article/details/80493158

前言