Runtime结构体以及原理

RunTime：指一个程序在运行（或者在被执行）的状态。也就是说，当你打开一个程序使它在电脑上运行的时候，那个程序就是处于运行时刻。在一些编程语言中，把某些可以重用的程序或者实例打包或者重建成为运行库。这些实例可以在它们运行的时候被连接或者被任何程序调用。
Objective-C中RunTime：是一套比较底层的纯C语言API，属于一个C语言库，包含了很多底层的C语言API。在我们平时编写的OC代码中，程序运行过程时，其实最终都是转成了RunTime的C语言代码。
Objective-C是基于C语言加入了面向对象特性和消息转发机制的动态语言，这意味着它不仅需要一个编译器，还需要Runtime系统来动态创建类和对象，进行消息发送和转发。下面通过分析Apple开源的Runtime代码(本次依版本objc4-723.tar为例)来深入理解Objective-C的Runtime机制。

Runtime应用场景

运行时修改内存中的数据
* 动态的在内存中创建一个类
* 给类增加一个属性
* 给类增加一个协议实现
* 给类增加一个方法实现IMP
* 遍历一个类的所有成员变量、属性和方法等
具体应用
* 拦截系统自带的方法调用（Method Swizzling黑魔法）
* 将某些OC代码转化为Runtime代码，探究底层。如block的实现原理
* 实现给分类增加属性
* 实现NSCoding的自动归档和接档
* 实现字典的模型和自动转换
* JSPatch替换已有的OC方法实行等

Runtime数据结构

在Objective-C中，使用[receiver message]语法并不会马上执行receiver对象的message方法的代码，而是向receiver发送一条message消息，这条消息可能由receiver来处理，也可能由转发给其他对象来处理，也有可能假装没有接收到这条消息而没有处理。其实[receiver message]被编译器转化为:

id objc_msgSend ( id self, SEL op, ... );

objc_msgSend

下面从两个数据结构id和SEL来逐步分析和理解Runtime有哪些重要的数据结构。

id

id是objc_msgSend第一个参数的数据类型，id是通用类型指针，能够表示任何对象。按下面路径打开objc.h文件可以查看到id数据结构如下：

id Data Structure

id其实就是一个指向objc_object结构体指针，它包含一个Class isa成员，根据isa指针就可以找到对象所属的类。

注意：根据Apple的官方文档Key-Value Observing Implementation Details提及，key-value observing是使用isa-swizzling的技术实现的，isa指针在运行时被修改，指向一个中间类而不是真正的类。所以，你不应该使用isa指针来确定类的关系，而是使用Class方法来确定实例对象的类。

SEL

SEL是函数objc_msgSend第二个参数的数据类型，表示方法选择器，按下面路径打开objc.h文件可以查看到SEL数据结构如下:

SEL Data Structure

其实它就是映射到方法的 C 字符串，你可以通过Objc编译器命令@selector()或者Runtime系统的sel_registerName函数来获取一个SEL类型的方法选择器。

如果你知道selector对应的方法名是什么，可以通过NSString* NSStringFromSelector(SEL aSelector)方法将SEL转化为字符串，再用NSLog打印。

使用举例：

NSString *methodString = NSStringFromSelector(@selector(<#方法名#>:));
const char *methodStr = [methodString UTF8String];
SEL methodSEL = sel_registerName(methodStr);

Class

isa指针的数据类型是Class，Class表示对象所属的类，按图（Class Data Structure）路径打开objc.h文件可以查看到Class其实就是一个objc_class结构体指针，按图（objc_class Data Structure）路径在runtime.h才能找到objc_class结构体的定义。

Class Data Structure

objc_class Data Structure

注意：OBJC2_UNAVAILABLE是一个Apple对Objc系统运行版本进行约束的宏定义，为了兼容非Objective-C 2.0的遗留版本。

接下来让我们分析一下objc_class结构体成员变量表示什么意思和对应使用哪些数据结构。

struct objc_class {
    Class isa  OBJC_ISA_AVAILABILITY;

#if !__OBJC2__
    Class super_class;                     // 表示实例对象对应的父类
    const char *name;                      // 表示类名
    long version;                          // 类的版本信息，初始化默认为0，可以通过runtime函数class_setVersion和class_getVersion进行修改、读取
    long info;                             // 一些标识信息,如CLS_CLASS (0x1L) 表示该类为普通 class ，其中包含对象方法和成员变量;CLS_META (0x2L) 表示该类为 metaclass，其中包含类方法;
    long instance_size ;                   // 该类的实例变量大小(包括从父类继承下来的实例变量);
    struct objc_ivar_list *ivars;          // 用于存储每个成员变量的地址
    struct objc_method_list **methodLists; // 与 info 的一些标志位有关,如CLS_CLASS (0x1L),则存储对象方法，如CLS_META (0x2L)，则存储类方法;
    struct objc_cache *cache;              // 指向最近使用的方法的指针，用于提升效率；
    struct objc_protocol_list *protocols;  // 存储该类遵守的协议
#endif

• isa表示一个Class对象的Class，也就是Meta Class。在面向对象设计中，一切都是对象，Class在设计中本身也是一个对象。我们会在objc-runtime-new.h文件找到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
    ......
};

由此可见，结构体objc_class也是继承objc_object，说明Class在设计中本身也是一个对象。

其实Meta Class也是一个Class，那么它也跟其他Class一样有自己的isa和super_class指针，关系如下：

isa和super_class指针关系

上图实线是super_class指针，虚线是isa指针。有几个关键点需要解释以下:

1、Root class (class)其实就是NSObject，NSObject是没有超类的，所以Root class(class)的superclass指向nil。
2、每个Class都有一个isa指针指向唯一的Meta class
3、Root class(meta)的superclass指向Root class(class)，也就是NSObject，形成一个回路。
4、 每个Meta class的isa指针都指向Root class (meta)。

• super_class表示实例对象对应的父类

• name表示类名

• ivars表示多个成员变量，它指向objc_ivar_list结构体。在runtime.h可以看到它的定义：

objc_ivar_list 结构体

objc_ivar_list其实就是一个链表，存储多个objc_ivar，而objc_ivar结构体存储类的单个成员变量信息。

• methodLists表示方法列表，它指向objc_method_list结构体的二级指针，可以动态修改*methodLists的值来添加成员方法，也是Category实现原理，同样也解释Category不能添加实例变量的原因。在runtime.h可以看到它的定义：

objc_method_list 结构体

同样，objc_method_list也是一个链表，存储多个objc_method，而objc_method结构体存储类的某个方法的信息。

• cache用来缓存经常访问的方法，它指向objc_cache结构体，后面会重点讲到。

• protocols表示类遵循哪些协议

Method

Method表示类中的某个方法，在runtime.h文件中找到它的定义：

/// An opaque type that represents a method in a class definition.
typedef struct objc_method *Method;

struct objc_method {
    SEL _Nonnull method_name                                 OBJC2_UNAVAILABLE;
    char * _Nullable method_types                            OBJC2_UNAVAILABLE;
    IMP _Nonnull method_imp                                  OBJC2_UNAVAILABLE;
}                                                            OBJC2_UNAVAILABLE; 

其实Method就是一个指向objc_method结构体指针，它存储了方法名(method_name)、方法类型(method_types)和方法实现(method_imp)等信息。而method_imp的数据类型是IMP，它是一个函数指针，后面会重点提及。

Ivar

Ivar表示类中的实例变量，在runtime.h文件中找到它的定义：

/// An opaque type that represents an instance variable.
typedef struct objc_ivar *Ivar;

struct objc_ivar {
    char * _Nullable ivar_name                               OBJC2_UNAVAILABLE;
    char * _Nullable ivar_type                               OBJC2_UNAVAILABLE;
    int ivar_offset                                          OBJC2_UNAVAILABLE;
#ifdef __LP64__
    int space                                                OBJC2_UNAVAILABLE;
#endif
}                                                            OBJC2_UNAVAILABLE;

Ivar其实就是一个指向objc_ivar结构体指针，它包含了变量名(ivar_name)、变量类型(ivar_type)等信息。

IMP

在上面讲Method时就说过，IMP本质上就是一个函数指针，指向方法的实现，在objc.h找到它的定义：

/// A pointer to the function of a method implementation. 
#if !OBJC_OLD_DISPATCH_PROTOTYPES
typedef void (*IMP)(void /* id, SEL, ... */ ); 
#else
typedef id _Nullable (*IMP)(id _Nonnull, SEL _Nonnull, ...); 
#endif

当你向某个对象发送一条信息，可以由这个函数指针来指定方法的实现，它最终就会执行那段代码，这样可以绕开消息传递阶段而去执行另一个方法实现。

Cache

顾名思义，cache主要用来缓存，那它缓存什么呢？我们先在runtime.h文件看看它的定义：

typedef struct objc_cache *Cache                             OBJC2_UNAVAILABLE;

#define CACHE_BUCKET_NAME(B)  ((B)->method_name)
#define CACHE_BUCKET_IMP(B)   ((B)->method_imp)
#define CACHE_BUCKET_VALID(B) (B)
#ifndef __LP64__
#define CACHE_HASH(sel, mask) (((uintptr_t)(sel)>>2) & (mask))
#else
#define CACHE_HASH(sel, mask) (((unsigned int)((uintptr_t)(sel)>>3)) & (mask))
#endif
struct objc_cache {
    unsigned int mask /* total = mask + 1 */                 OBJC2_UNAVAILABLE;
    unsigned int occupied                                    OBJC2_UNAVAILABLE;
    Method _Nullable buckets[1]                              OBJC2_UNAVAILABLE;
};

cache其实就是一个存储Method的链表，主要是为了优化方法调用的性能。当对象receiver调用方法message时，首先根据对象receiver的isa指针查找到它对应的类，然后在类的methodLists中搜索方法，如果没有找到，就使用super_class指针到父类中的methodLists查找，一旦找到就调用方法。如果没有找到，有可能消息转发，也可能忽略它。但这样查找方式效率太低，因为往往一个类大概只有20%的方法经常被调用，占总调用次数的80%。所以使用cache来缓存经常调用的方法，当调用方法时，优先在cache查找，如果没有找到，再到methodLists查找。

消息发送

前面从objc_msgSend作为入口，逐步深入分析Runtime的数据结构，了解每个数据结构的作用和它们之间关系后，我们正式转入消息发送这个正题。

objc_msgSend函数

在前面已经提过，当某个对象使用语法[receiver message]来调用某个方法时，其实[receiver message]被编译器转化为:

id objc_msgSend ( id self, SEL op, ... );

现在让我们看一下objc_msgSend它具体是如何发送消息:

1. 首先根据receiver对象的isa指针获取它对应的class
2. 优先在class的cache查找message方法，如果找不到，再到methodLists查找
3. 如果没有在class找到，再到super_class查找
4. 一旦找到message这个方法，就执行它实现的IMP。

Objc Message

self与super

为了让大家更好地理解self和super，借用sunnyxx博客的ios程序员6级考试一道题目：下面的代码分别输出什么？

@implementation Son : Father
- (id)init {
    self = [super init];
    if (self) {
        NSLog(@"%@", NSStringFromClass([self class]));
        NSLog(@"%@", NSStringFromClass([super class]));
    }
    return self;
}
@end

self表示当前这个类的对象，而super是一个编译器标示符，和self指向同一个消息接受者。在本例中，无论是[self class]还是[super class]，接受消息者都是Son对象，但super与self不同的是，self调用class方法时，是在子类Son中查找方法，而super调用class方法时，是在父类Father中查找方法。

当调用[self class]方法时，会转化为objc_msgSend函数，这个函数定义如下：

id objc_msgSend(id self, SEL op, ...)

这时会从当前Son类的方法列表中查找，如果没有，就到Father类查找，还是没有，最后在NSObject类查找到。我们可以从NSObject.mm文件中看到- (Class)class的实现：

- (Class)class {
    return object_getClass(self);
}

所以NSLog(@"%@", NSStringFromClass([self class]));会输出Son。

当调用[super class]方法时，会转化为objc_msgSendSuper，这个函数定义如下：

id objc_msgSendSuper(struct objc_super *super, SEL op, ...)

objc_msgSendSuper函数第一个参数super的数据类型是一个指向objc_super的结构体，从message.h文件中查看它的定义：

/// Specifies the superclass of an instance. 
struct objc_super {
    /// Specifies an instance of a class.
    __unsafe_unretained id receiver;

    /// Specifies the particular superclass of the instance to message. 
#if !defined(__cplusplus)  &&  !__OBJC2__
    /* For compatibility with old objc-runtime.h header */
    __unsafe_unretained Class class;
#else
    __unsafe_unretained Class super_class;
#endif
    /* super_class is the first class to search */
};
#endif

结构体包含两个成员，第一个是receiver，表示某个类的实例。第二个是super_class表示当前类的父类。

这时首先会构造出objc_super结构体，这个结构体第一个成员是self，第二个成员是(id)class_getSuperclass(objc_getClass("Son"))，实际上该函数会输出Father。然后在Father类查找class方法，查找不到，最后在NSObject查到。此时，内部使用objc_msgSend(objc_super->receiver, @selector(class))去调用，与[self class]调用相同，所以结果还是Son。

隐藏参数self和_cmd

当[receiver message]调用方法时，系统会在运行时偷偷地动态传入两个隐藏参数self和_cmd，之所以称它们为隐藏参数，是因为在源代码中没有声明和定义这两个参数。至于对于self的描述，上面已经解释非常清楚了，下面我们重点讲解_cmd。

_cmd表示当前调用方法，其实它就是一个方法选择器SEL。一般用于判断方法名或在Associated Objects中唯一标识键名，后面在Associated Objects会讲到。

方法解析与消息转发

[receiver message]调用方法时，如果在message方法在receiver对象的类继承体系中没有找到方法，那怎么办？一般情况下，程序在运行时就会Crash掉，抛出unrecognized selector sent to …类似这样的异常信息。但在抛出异常之前，还有三次机会按以下顺序让你拯救程序。

1. Method Resolution

2. Fast Forwarding

3. Normal Forwarding

消息响应流程

Method Resolution

首先Objective-C在运行时调用+ resolveInstanceMethod:或+ resolveClassMethod:方法，让你添加方法的实现。如果你添加方法并返回YES，那系统在运行时就会重新启动一次消息发送的过程。

举一个简单例子，定义一个类ZQMessage，它主要定义一个方法sendMessage，下面就是它的设计与实现：

@interface ZQMessage : NSObject

- (void)sendMessage:(NSString *)word;

@end

@implementation ZQMessage

- (void)sendMessage:(NSString *)word {
    NSLog(@"normal way : send message = %@", word);
}
@end

如果我在viewDidLoad方法中创建ZQMessage对象并调用sendMessage方法：

- (void)viewDidLoad {
    [super viewDidLoad];

    ZQMessage *message = [ZQMessage alloc] init];
    [message sendMessage:@"发送消息"];
}

控制台会打印以下信息:

normal way : send message = 发送消息

但现在我将原来sendMessage方法实现给注释掉，覆盖resolveInstanceMethod方法：

#pragma mark - Method Resolution

/// override resolveInstanceMethod or resolveClassMethod for changing sendMessage method implementation
+ (BOOL)resolveInstanceMethod:(SEL)sel {
    if (sel == @selector(sendMessage:)) {
        class_addMethod([self class], sel, imp_implementationWithBlock(^(id self, NSString *word) {
            NSLog(@"method resolution way : send message = %@", word);
        }), "v@*");
    }
    return YES;
}

控制台就会打印以下信息：

 method resolution way : send message = 发送消息

注意到上面代码有这样一个字符串"v@*，它表示方法的参数和返回值，详情请参考Type Encodings

如果resolveInstanceMethod方法返回NO，运行时就跳转到下一步：消息转发(ZQMessage Forwarding)

Fast Forwarding

如果目标对象实现- forwardingTargetForSelector:方法，系统就会在运行时调用这个方法，只要这个方法返回的不是nil或self，也会重启消息发送的过程，把这消息转发给其他对象来处理。否则，就会继续Normal Fowarding。

继续上面ZQMessage类的例子，将sendMessage和resolveInstanceMethod方法注释掉，然后添加forwardingTargetForSelector方法的实现：

#pragma mark - Fast Forwarding
- (id)forwardingTargetForSelector:(SEL)aSelector {
    if (aSelector == @selector(sendMessage:)) {
        return [ZQMessageForwarding alloc] init];
    }
    return nil;
}

此时还缺一个转发消息的类ZQMessageForwarding，这个类的设计与实现如下：

@interface ZQMessageForwarding : NSObject

- (void)sendMessage:(NSString *)word;

@end

@implementation ZQMessageForwarding

- (void)sendMessage:(NSString *)word {
    NSLog(@"fast forwarding way : send message = %@", word);
}

@end

此时，控制台会打印以下信息：

fast forwarding way : send message = 发送消息

这里叫Fast，是因为这一步不会创建NSInvocation对象，但Normal Forwarding会创建它，所以相对于更快点。

Normal Forwarding

如果没有使用Fast Forwarding来消息转发，最后只有使用Normal Forwarding来进行消息转发。它首先调用methodSignatureForSelector:方法来获取函数的参数和返回值，如果返回为nil，程序会Crash掉，并抛出unrecognized selector sent to instance异常信息。如果返回一个函数签名，系统就会创建一个NSInvocation对象并调用-forwardInvocation:方法。

继续前面的例子，将forwardingTargetForSelector方法注释掉，添加methodSignatureForSelector和forwardInvocation方法的实现：

#pragma mark - Normal Forwarding
- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector {
    NSMethodSignature *methodSignature = [super methodSignatureForSelector:aSelector];

    if (!methodSignature) {
        methodSignature = [NSMethodSignature signatureWithObjCTypes:"v@:*"];
    }
    return methodSignature;
}

- (void)forwardInvocation:(NSInvocation *)anInvocation {
    ZQMessageForwarding *messageForwarding = [ZQMessageForwarding alloc] init];

    if ([messageForwarding respondsToSelector:anInvocation.selector]) {
        [anInvocation invokeWithTarget:messageForwarding];
    }
}

三种方法的选择

Runtime提供三种方式来将原来的方法实现代替掉，那该怎样选择它们呢？

• Method Resolution：由于Method Resolution不能像消息转发那样可以交给其他对象来处理，所以只适用于在原来的类中代替掉。

• Fast Forwarding：它可以将消息处理转发给其他对象，使用范围更广，不只是限于原来的对象。

• Normal Forwarding：它跟Fast Forwarding一样可以消息转发，但它能通过NSInvocation对象获取更多消息发送的信息，例如：target、selector、arguments和返回值等信息。

Associated Objects

当想使用Category对已存在的类进行扩展时，一般只能添加实例方法或类方法，而不适合添加额外的属性。虽然可以在Category头文件中声明property属性，但在实现文件中编译器是无法synthesize任何实例变量和属性访问方法。这时需要自定义属性访问方法并且使用Associated Objects来给已存在的类Category添加自定义的属性。Programming with Objective-C
Associated Objects提供三个API来向对象添加、获取和删除关联值：

/** 
 * 用给定的key和关联策略为object设置关联value。
 * 
 * @param object 关联的源对象
 * @param key 关联key
 * @param value 关联value
 * @param policy 关联策略
 * 
 * @see objc_setAssociatedObject
 * @see objc_removeAssociatedObjects
 */
void objc_setAssociatedObject (id object, const void *key, id value, objc_AssociationPolicy policy)

/** 
 * 返回给定键与给定对象关联的值
 * 
 * @param object 关联的源对象
 * @param key 关联key
 * 
 * @return The value associated with the key \e key for \e object.
 * 
 * @see objc_setAssociatedObject
 */
id objc_getAssociatedObject (id object, const void *key)

/** 
 * 移除给定对象的所有关联
 * 
 * @param object 关联的源对象
 * 
 * @see objc_setAssociatedObject
 * @see objc_getAssociatedObject
 */
void objc_removeAssociatedObjects (id object )

断开关联
使用objc_setAssociatedObject函数，传入nil值即可。
使用objc_removeAssociatedObjects函数，可以断开所有关联。
其中objc_AssociationPolicy标识关联策略是个枚举类型，它可以指定Objc内存管理的引用计数机制。

typedef OBJC_ENUM(uintptr_t, objc_AssociationPolicy) {
    OBJC_ASSOCIATION_ASSIGN = 0,          //assign
    OBJC_ASSOCIATION_RETAIN_NONATOMIC = 1,//nonatomic, strong
    OBJC_ASSOCIATION_COPY_NONATOMIC = 3,  //nonatomic, copy
    OBJC_ASSOCIATION_RETAIN = 01401,      //atomic, strong
    OBJC_ASSOCIATION_COPY = 01403         //atomic, copy
};

下面有个关于NSObject+AssociatedObject Category 添加属性：

NSObject+AssociatedObject.h

@interface NSObject (AssociatedObject)

@property (strong, nonatomic) id associatedObject;

@end

NSObject+AssociatedObject.m

@implementation NSObject (AssociatedObject)

- (void)setAssociatedObject:(id)associatedObject {
    objc_setAssociatedObject(self, @selector(associatedObject), associatedObject, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}

- (id)associatedObject {
    return objc_getAssociatedObject(self, _cmd);
}

@end

Associated Objects的key要求是唯一并且是常量，而SEL是满足这个要求的，所以上面的采用隐藏参数_cmd作为key。

Method Swizzling

Method Swizzling就是在运行时将一个方法的实现代替为另一个方法的实现。如果能够利用好这个技巧，可以写出简洁、有效且维护性更好的代码。可以参考两篇关于Method Swizzling技巧的文章：

• nshipster Method Swizzling

• Method Swizzling 和 AOP 实践

Aspect-Oriented Programming(AOP)

类似记录日志、身份验证、缓存等事务非常琐碎，与业务逻辑无关，很多地方都有，又很难抽象出一个模块，这种程序设计问题，业界给它们起了一个名字叫横向关注点(Cross-cutting concern)，AOP作用就是分离横向关注点(Cross-cutting concern)来提高模块复用性，它可以在既有的代码添加一些额外的行为(记录日志、身份验证、缓存)而无需修改代码。

危险性

Method Swizzling就像一把瑞士小刀，如果使用得当，它会有效地解决问题。但使用不当，将带来很多麻烦。在stackoverflow上有人已经提出这样一个问题：What are the Dangers of Method Swizzling in Objective C?，它的危险性主要体现以下几个方面：

• Method swizzling is not atomic

• Changes behavior of un-owned code

• Possible naming conflicts

• Swizzling changes the method's arguments

• The order of swizzles matters

• Difficult to understand (looks recursive)

• Difficult to debug

总结

虽然在平时项目不是经常用到Objective-C的Runtime特性，但当你阅读一些iOS开源项目时，你就会发现很多时候都会用到。所以深入理解Objective-C的Runtime数据结构、消息转发机制有助于你更容易地阅读和学习开源项目。

部分场景举例说明

举例说明

扩展阅读

玉令天下博客的Objective-C Runtime
顾鹏博客的Objective-C Runtime
Associated Objects
Method Swizzling
Method Swizzling 和 AOP 实践
Objective-C Runtime Reference
What are the Dangers of Method Swizzling in Objective-C?
iOS程序员6级考试（答案和解释）
Objective-C类方法load和initialize的区别