iOS runtime—看这一篇就够了

本文篇幅比较长，创作的目的为了自己日后温习知识所用，希望这篇文章能对你有所帮助。
如发现任何有误之处，肯请留言纠正，谢谢。

一、深入代码理解 instance、class object、metaclass

1、instance对象实例

我们经常使用id来声明一个对象，那id的本质又是什么呢？查看objc/objc.h文件

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

/// Represents an instance of a class.
struct objc_object {
    Class _Nonnull isa  OBJC_ISA_AVAILABILITY;
};

/// A pointer to an instance of a class.
typedef struct objc_object *id;

我们创建的一个对象或实例其实就是一个struct objc_object结构体，而我们常用的id也就是这个结构体的指针。

这个结构体只有一个成员变量，这是一个Class类型的变量isa，也是一个结构体指针，isa指针就指向对象所属的类。

一个 NSObject 对象占用多少内存空间？
一个NSObject实例对象只有一个isa指针，所以一个isa指针的大小，他在64位的环境下占8个字节，在32位环境上占4个字节。

 NSObject *obj = [[NSObject alloc] init];
 NSLog(@"class_getInstanceSize--%zd", class_getInstanceSize([NSObject class]));

输出结果：

class_getInstanceSize--8

2、class object（类对象）/metaclass（元类）

看结构体objc_class的定义

struct objc_class {
    Class isa  OBJC_ISA_AVAILABILITY;

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

} OBJC2_UNAVAILABLE;
/* Use `Class` instead of `struct objc_class *` */

• Class superclass;——用于获取父类，也就是元类对象，它也是一个Class类型
• cache_t cache;——是方法缓存
• class_data_bits_t bits;——用于获取类的具体信息，看到bits
• class_rw_t *data()函数，该函数的作用就是获取该类的可读写信息，通过class_data_bits_t的bits.data()方法获得，class_rw_t后面会介绍

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

该结构体的第一个成员变量也是isa指针，这就说明了Class本身其实也是一个对象，我们称之为类对象。类对象中的元数据存储的都是如何创建一个实例的相关信息，那么类对象和类方法应该从哪里创建呢？就是从isa指针指向的结构体创建，类对象的isa指针指向的我们称之为元类(metaclass)，元类中保存了创建类对象以及类方法所需的所有信息。

3、isa指针与superclass相关逻辑图

4、总结 + 代码校验

• 对象 的类(Superclass)是 类（对象） ；
• 类（对象） 的类(Superclass)是 元类，和类同名；
• 元类 的类(Superclass)是 根元类 NSObject；
• 根元类 的类(Superclass)是 自己 ,还是NSObject；
• 对象的isa指针指向类（对象） ；
• 类对象的isa指针指向元类，和类同名；
• 元类的isa指针指向跟根元类 NSObject；
• 根元类 NSObject的isa指针指向自己。

isa验证

    NSString *string = @"字符串";
    Class class1 = object_getClass(string);//NSString类对象
    Class metaClass = object_getClass(class1);//NSString元类
    Class rootMetaClass = object_getClass(metaClass);//根元类
    Class rootRootMetaClass = object_getClass(rootMetaClass);//根元类
    NSLog(@"%p 实例对象 ",string);
    NSLog(@"%p 类 %@",class1,NSStringFromClass(class1));
    NSLog(@"%p 元类 %@",metaClass,NSStringFromClass(metaClass));
    NSLog(@"%p 根元类 %@",rootMetaClass,NSStringFromClass(rootMetaClass));
    NSLog(@"%p 根根元类 %@",rootRootMetaClass,NSStringFromClass(rootRootMetaClass));

    Class rootMetaClass_superclass = rootMetaClass.superclass;//根元类的superclass
    NSLog(@"根根元类的superclass:%@",NSStringFromClass(rootMetaClass_superclass));

输出结果：

0x102d48078 实例对象 
0x1d80e3d10 类 __NSCFConstantString
0x1d80e3cc0 元类 __NSCFConstantString
0x1d80c66c0 根元类 NSObject
0x1d80c66c0 根根元类 NSObject
根根元类的superclass:NSObject

superclass验证

    NSString *string = @"字符串";
    Class class1 = object_getClass(string);//NSString类对象
    Class class2 = class1.superclass;
    NSLog(@"%@ 的superclass是 %@",NSStringFromClass(class1),NSStringFromClass(class2));
    Class class3 = class2.superclass;
    NSLog(@"%@ 的superclass是 %@",NSStringFromClass(class2),NSStringFromClass(class3));
    Class class4 = class3.superclass;
    NSLog(@"%@ 的superclass是 %@",NSStringFromClass(class3),NSStringFromClass(class4));
    Class class5 = class4.superclass;
    NSLog(@"%@ 的superclass是 %@",NSStringFromClass(class4),NSStringFromClass(class5));
    Class class6 = class5.superclass;
    NSLog(@"%@ 的superclass是 %@",NSStringFromClass(class5),NSStringFromClass(class6));

输出结果：

 __NSCFConstantString 的superclass是 __NSCFString
 __NSCFString 的superclass是 NSMutableString
NSMutableString 的superclass是 NSString
NSString 的superclass是 NSObject
NSObject 的superclass是 (null)

如果你正在跳槽或者正准备跳槽不妨动动小手，添加一下咱们的交流群1012951431来获取一份详细的大厂面试资料为你的跳槽多添一份保障。

二、class_rw_t 与 class_ro_t

1、class_ro_t 一"码"当先：

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

• uint32_t instanceSize;——instance对象占用的内存空间
• const char * name;——类名
• const ivar_list_t * ivars;——类的成员变量列表

class_ro_t存储了当前类在编译期就已经确定的属性、方法以及遵循的协议，里面是没有分类的方法的。那些运行时添加的方法将会存储在运行时生成的class_rw_t中。
ro即表示read only，是无法进行修改的。

2、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; // 指向只读的结构体,存放类初始信息

    /*
     这三个都是二位数组，是可读可写的，包含了类的初始内容、分类的内容。
     这三个二位数组中的数据有一部分是从class_ro_t中合并过来的。
     */
    method_array_t methods; // 方法列表（类对象存放对象方法，元类对象存放类方法）
    property_array_t properties; // 属性列表
    protocol_array_t protocols; //协议列表

    Class firstSubclass;
    Class nextSiblingClass;

    //...
    }

3、class_rw_t生成时机

class_rw_t生成在运行时，在编译期间，class_ro_t结构体就已经确定，objc_class中的bits的data部分存放着该结构体的地址。在runtime运行之后，具体说来是在运行runtime的realizeClass 方法时，会生成class_rw_t结构体，该结构体包含了class_ro_t，并且更新data部分，换成class_rw_t结构体的地址。

类的realizeClass运行之前：

然后在加载 ObjC 运行时的过程中在 realizeClass 方法中：

• 从 class_data_bits_t 调用 data 方法，将结果从 class_rw_t 强制转换为 class_ro_t 指针
• 初始化一个 class_rw_t 结构体
• 设置结构体 ro 的值以及 flag
• 最后设置正确的 data。

const class_ro_t *ro = (const class_ro_t *)cls->data();
class_rw_t *rw = (class_rw_t *)calloc(sizeof(class_rw_t), 1);
rw->ro = ro;
rw->flags = RW_REALIZED|RW_REALIZING;
cls->setData(rw);

但是，在这段代码运行之后 class_rw_t 中的方法，属性以及协议列表均为空。这时需要 realizeClass 调用 methodizeClass 方法来将类自己实现的方法（包括分类）、属性和遵循的协议加载到 methods、 properties 和 protocols 列表中。

realizeClass 方法执行过后的类所占用内存的布局：

细看两个结构体的成员变量会发现很多相同的地方，他们都存放着当前类的属性、实例变量、方法、协议等等。区别在于：class_ro_t存放的是编译期间就确定的；而class_rw_t是在runtime时才确定，它会先将class_ro_t的内容拷贝过去，然后再将当前类的分类的这些属性、方法等拷贝到其中。所以可以说class_rw_t是class_ro_t的超集，当然实际访问类的方法、属性等也都是访问的class_rw_t中的内容。

4、method_t

上面我们剖析了class_rw_t、class_ro_t这两个重要部分的结构，并且主要关注了其中的方法列表部分，而从上面的分析，可发现里面最基本也是重要的单位是method_t，这个结构体包含了描述一个方法所需要的各种信息。

struct method_t {
    SEL name;
    const char *types;
    IMP imp;
};

变量介绍可以参考之前文章：iOS 代码注入—— hook 实践

三、Runtime 初始化函数

1、一"码"当先

/***********************************************************************
* _objc_init
* Bootstrap initialization. Registers our image notifier with dyld.
* Called by libSystem BEFORE library initialization time
**********************************************************************/

void _objc_init(void)
{
    static bool initialized = false;
    if (initialized) return;
    initialized = true;

    // fixme defer initialization until an objc-using image is found?
    environ_init();
    tls_init();
    static_init();
    lock_init();
    exception_init();

    _dyld_objc_notify_register(&map_images, load_images, unmap_image);
}

_dyld_objc_notify_register(&map_images, load_images, unmap_image)。这个函数里面的三个参数分别是另外三个函数：

• map_images -- Process the given images which are being mapped in by dyld.(处理那些正在被dyld映射的镜像文件)
• load_images -- Process +load in the given images which are being mapped in by dyld.（处理那些正在被dyld映射的镜像文件中的+load方法）
• unmap_image -- Process the given image which is about to be unmapped by dyld.(处理那些将要被dyld进行去映射操作的镜像文件)

我们查看一下map_images方法，点进去：

/***********************************************************************
* map_images
* Process the given images which are being mapped in by dyld.
* Calls ABI-agnostic code after taking ABI-specific locks.
*
* Locking: write-locks runtimeLock
**********************************************************************/
void
map_images(unsigned count, const char * const paths[],
           const struct mach_header * const mhdrs[])
{
    mutex_locker_t lock(runtimeLock);
    return map_images_nolock(count, paths, mhdrs);
}

四、分类底层原理

根据map_images函数，继续点进去看，可以看到如下代码：

// Discover categories. 
    for (EACH_HEADER) {
        category_t **catlist = 
            _getObjc2CategoryList(hi, &count);
        bool hasClassProperties = hi->info()->hasCategoryClassProperties();

        for (i = 0; i < count; i++) {
            category_t *cat = catlist[i];
            Class cls = remapClass(cat->cls);

            if (!cls) {
                // Category's target class is missing (probably weak-linked).
                // Disavow any knowledge of this category.
                catlist[i] = nil;
                if (PrintConnecting) {
                    _objc_inform("CLASS: IGNORING category \?\?\?(%s) %p with "
                                 "missing weak-linked target class", 
                                 cat->name, cat);
                }
                continue;
            }

            // Process this category. 
            // First, register the category with its target class. 
            // Then, rebuild the class's method lists (etc) if 
            // the class is realized. 
            bool classExists = NO;
            if (cat->instanceMethods ||  cat->protocols  
                ||  cat->instanceProperties) 
            {
                addUnattachedCategoryForClass(cat, cls, hi);
                if (cls->isRealized()) {
                    remethodizeClass(cls);
                    classExists = YES;
                }
                if (PrintConnecting) {
                    _objc_inform("CLASS: found category -%s(%s) %s", 
                                 cls->nameForLogging(), cat->name, 
                                 classExists ? "on existing class" : "");
                }
            }

            if (cat->classMethods  ||  cat->protocols  
                ||  (hasClassProperties && cat->_classProperties)) 
            {
                addUnattachedCategoryForClass(cat, cls->ISA(), hi);
                if (cls->ISA()->isRealized()) {
                    remethodizeClass(cls->ISA());
                }
                if (PrintConnecting) {
                    _objc_inform("CLASS: found category +%s(%s)", 
                                 cls->nameForLogging(), cat->name);
                }
            }
        }
    }

根据代码：

category_t *cat = catlist[i];

一开始的那个catlist是一个二维数组，里面的成员也是一个一个的数组，也就是代码里面的cat所指向的数组，它的类型是category_t *，说明cat数组里面装的就是category_t，一个cat里面装的就是某个class所对应的所有category。

那么什么决定了这些category_t在cat数组中的顺序呢？
答案是category文件的编译顺序决定的。先参与编译的，就放在数组的前面，后参与编译的，就放在数组后面。我们可以在xcode-->target-->Build Phases-->Compile Sources列表查看和调整category文件的编译顺序

加载分类的最后，执行方法:remethodizeClass(cls->ISA());

static void remethodizeClass(Class cls)
{
    category_list *cats;
    bool isMeta;

    runtimeLock.assertLocked();

    isMeta = cls->isMetaClass();

    // Re-methodizing: check for more categories
    if ((cats = unattachedCategoriesForClass(cls, false/*not realizing*/))) {
        if (PrintConnecting) {
            _objc_inform("CLASS: attaching categories to class '%s' %s", 
                         cls->nameForLogging(), isMeta ? "(meta)" : "");
        }

        attachCategories(cls, cats, true /*flush caches*/);        
        free(cats);
    }
}

然后在这里面找到一个方法attachCategories，看名字就知道，附着分类，也就是把分类的内容添加/合并到class里面，感兴趣的可以自己查看一下这个方法，这个理就不做解释了。

五、方法缓存

1、数据结构

它的底层是通过散列表（哈希表）的数据结构来实现的，用于缓存曾经调用过的方法，可以提高方法的查找速度。
首先，回顾一下正常情况下方法调用的流程。假设我们调用一个实例方法[obj XXXX];

• obj -> isa -> obj的Class对象 -> method_array_t methods -> 对该表进行遍历查找，找到就调用，没找到继续往下走
• obj -> superclass -> obj的父类 -> isa -> method_array_t methods -> 对父类的方法列表进行遍历查找，找到就调用，没找到就重复本步骤
• 直到NSObject -> isa -> NSObject的Class对象 -> method_array_t，如果还是没有找到就会crash

如果XXXX方法在程序内会被频繁的调用，那么这种逐层便利查找的方式肯定是效率低下的，因此苹果设计了cache_t cache，当XXXX第一次被调用的时候，会按照常规流程查找，找到之后，就会被加入到cache_t cache中，当再次被调用的时候，系统就会直接现到cache_t cache来查找，找到就直接调用，这样便大大提升了查找的效率。

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

• struct bucket_t *_buckets; —— 用来缓存方法的散列/哈希表
• mask_t _mask; —— 这个值 = 散列表长度 - 1
• mask_t _occupied; —— 表示已经缓存的方法的数量

_buckets散列表里面的存储单元是bucket_t，

struct bucket_t {
private:
    cache_key_t _key;
    IMP _imp;
}

• cache_key_t _key; —— 这个key实际上就是方法的SEL，也就是方法名
• IMP _imp; —— 这个就是方法对应的函数的内存地址

2、缓存逻辑

• (1) 当一个对象接收到消息时[obj message];，首先根据obj的isa指针进入它的类对象class里面。
• (2) 在obj的class里面，首先到缓存cache_t里面查询方法message的函数实现，如果找到，就直接调用该函数。
• (3) 如果上一步没有找到对应函数，在对该class的方法列表进行二分/遍历查找，如果找到了对应函数，首先会将该方法缓存到obj的类对象class的cache_t里面，然后对函数进行调用。
• (4) 在每次进行缓存操作之前，首先需要检查缓存容量，如果缓存内的方法数量超过规定的临界值(设定容量的3/4)，需要先对缓存进行2倍扩容，原先缓存过的方法全部丢弃，然后将当前方法存入扩容后的新缓存内。
• (5) 如果在obj的class对象里面，发现缓存和方法列表都找不到mssage方法，则通过class的superclass指针进入它的父类对象father_class里面
• (6) 进入father_class后，首先在它的cache_t里面查找mssage，如果找到了该方法，那么会首先将方法缓存到消息接受者obj的类对象class的cache_t里面，然后调用方法对应的函数。
• (7) 如果上一步没有找到方法，将会对father_class的方法列表进行遍历二分/遍历查找，如果找到了mssage方法，那么同样，会首先将方法缓存到消息接受者obj的类对象class的cache_t里面，然后调用方法对应的函数。需要注意的是，这里并不会将方法缓存到当前父类对象father_class的cache_t里面。
• (8) 如果还没找到方法，则会通过father_class的superclass进入更上层的父类对象里面，按照(6)->(7)->(8)步骤流程重复。如果此时已经到了基类对象NSObject，仍没有找到mssage，则进入步骤(9)

如果你正在跳槽或者正准备跳槽不妨动动小手，添加一下咱们的交流群1012951431来获取一份详细的大厂面试资料为你的跳槽多添一份保障。

六、消息转发

第一步：Method resolution 方法解析处理阶段
如果调用了对象方法首先会进行+(BOOL)resolveInstanceMethod:(SEL)sel判断
如果调用了类方法 首先会进行 +(BOOL)resolveClassMethod:(SEL)sel判断
两个方法都为类方法；

+ (BOOL)resolveClassMethod:(SEL)sel {
    ///这里动态添加方法
    return YES;
}
+ (BOOL)resolveInstanceMethod:(SEL)sel {
    ///这里动态添加方法
    return YES;
}

_class_resolveInstanceMethod源码解析

/***********************************************************************
* _class_resolveInstanceMethod
* Call +resolveInstanceMethod, looking for a method to be added to class cls.
* cls may be a metaclass or a non-meta class.
* Does not check if the method already exists.
**********************************************************************/
static void _class_resolveInstanceMethod(id inst, SEL sel, Class cls)
{
    SEL resolve_sel = @selector(resolveInstanceMethod:);

    if (! lookUpImpOrNilTryCache(cls, resolve_sel, cls->ISA())) {
        // Resolver not implemented.
        return;
    }

    BOOL (*msg)(Class, SEL, SEL) = (typeof(msg))objc_msgSend;
    bool resolved = msg(cls, resolve_sel, sel);

    // Cache the result (good or bad) so the resolver doesn't fire next time.
    // +resolveInstanceMethod adds to self a.k.a. cls
    IMP imp = lookUpImpOrNilTryCache(inst, sel, cls);

    if (resolved  &&  PrintResolving) {
        if (imp) {
            _objc_inform("RESOLVE: method %c[%s %s] "
                         "dynamically resolved to %p", 
                         cls->isMetaClass() ? '+' : '-', 
                         cls->nameForLogging(), sel_getName(sel), imp);
        }
        else {
            // Method resolver didn't add anything?
            _objc_inform("RESOLVE: +[%s resolveInstanceMethod:%s] returned YES"
                         ", but no new implementation of %c[%s %s] was found",
                         cls->nameForLogging(), sel_getName(sel), 
                         cls->isMetaClass() ? '+' : '-', 
                         cls->nameForLogging(), sel_getName(sel));
        }
    }
}

从runtime的源码，resolveInstanceMethod的返回值对于消息转发流程没有任何意义，这个返回值只和debug的信息相关。
这两个方法是最先走到的方法，可以在这两个方法中动态的添加方法，进行消息转发。这里有一个需要特别注意的地方，类方法需要添加到元类里面，原因这里就不赘述了。

**第二步:Fast forwarding 快速转发阶段 **

- (id)forwardingTargetForSelector:(SEL)aSelector {
    return [xxx new];
}

这个里可以快速重定向成其他对象，已经让备用的对象去响应了该对象本身无法响应的一个SEL

第三步：Normal forwarding 常规转发阶段

//返回方法签名
-(NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector{
    if ([NSStringFromSelector(aSelector) isEqualToString:@"xxx"]) {
        return [[xxx new] methodSignatureForSelector:aSelector];
    }
    return [super methodSignatureForSelector:aSelector];
}

//处理返回的方法签名
-(void)forwardInvocation:(NSInvocation *)anInvocation{
    if ([NSStringFromSelector(anInvocation.selector) isEqualToString:@"xxx"]) {
        [anInvocation invokeWithTarget:[xxx new]];
    }else{
        [super forwardInvocation:anInvocation];
    }
}

自动签名

-(NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector{
    //如果返回为nil则进行自动签名
   if ([super methodSignatureForSelector:aSelector]==nil) {
        NSMethodSignature * sign = [NSMethodSignature signatureWithObjCTypes:"v@:"];
        return sign;
    }
    return [super methodSignatureForSelector:aSelector];
}

-(void)forwardInvocation:(NSInvocation *)anInvocation{
    //创建备用对象
    xxx * backUp = [xxx new];
    SEL sel = anInvocation.selector;
    //判断备用对象是否可以响应传递进来等待响应的SEL
    if ([backUp respondsToSelector:sel]) {
        [anInvocation invokeWithTarget:backUp];
    }else{
       // 如果备用对象不能响应 则抛出异常
        [self doesNotRecognizeSelector:sel];
    }
}

////触发崩溃
- (void)doesNotRecognizeSelector:(SEL)aSelector {

}

七、super的本质

1、定义

• super—— 是一个指向结构体指针struct objc_super *，它里面的内容是{消息接受者 recv， 消息接受者的父类类对象 [[recv superclass] class]}，objc_msgSendSuper会将消息接受者的父类类对象作为消息查找的起点。

2、流程
[obj message] -> 在obj的类对象cls查找方法 -> 在cls的父类对象[cls superclass]查找方法 -> 在更上层的父类对象查找方法 -> ... -> 在根类类对象 NSObject里查找方法

[super message] -> 在obj的类对象cls查找方法(跳过此步骤) -> (直接从这一步开始)在cls的父类对象[cls superclass]查找方法 -> 在更上层的父类对象查找方法 -> ... -> 在根类类对象 NSObject里查找方法

3、实例

 NSLog(@"[self class] = %@",[self class]);

• 接受者 当前class实例对象
• 最终调用的方法：基类NSObject的-(Class)class方法

 NSLog(@"[super class] = %@",[super class]);

• 接受者 当前class实例对象
• 最终调用的方法：基类NSObject的-(Class)class方法

 NSLog(@"[self superclass] = %@",[self superclass]);

• 接受者 当前class实例对象
• 最终调用的方法：基类NSObject的-(Class) superclass方法

 NSLog(@"[super superclass] = %@",[super superclass]);

• 接受者 当前class实例对象
• 最终调用的方法：基类NSObject的-(Class) superclass方法

因此 [self class] [super class] [self superclass] [super superclass] 的值都相等

至此，runtime相关的知识点全部总结完毕，该文章将会持续更新迭代！！
看到就是缘分😁，如发现任何有误之处，肯请留言纠正，谢谢。