Runtime 学习：消息传递
Objective-C 扩展了 C 语言，并加入了面向对象特性和消息传递机制。而这个扩展的核心就是 Runtime 库。它是 Objective-C 面向对象和动态机制的基石。html
基于我对 Runtime 的理解，我认为它的核心知识基本都围绕两个中心：数组
- 消息传递
- 类的动态配置
Runtime 的知识点比较多，计划用三篇文章来记录下本身的学习过程：缓存
- 消息传递探究
- 类的动态配置
- 实际应用
下面就根据这两个中心咱们慢慢来学习 Runtime。首先咱们须要对类的本质进行了解。bash
预备知识
类对象(objc_class)
Objective-C 类是由 Class 类型来表示的，它其实是一个指向 objc_class 结构体的指针。数据结构
typedef struct objc_class *Class;
复制代码
查看 objc/runtime.h 中 objc_class 结构体的定义以下：app
//runtime.h
struct objc_class {
// isa指针，指向元类（metaClass）
Class _Nonnull isa OBJC_ISA_AVAILABILITY;
#if !__OBJC2__
// 父类
Class _Nullable super_class OBJC2_UNAVAILABLE;
// 类名
const char * _Nonnull name OBJC2_UNAVAILABLE;
// 类的版本信息，默认为0
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;
复制代码
在 objc_class 的定义中，有几个咱们比较感兴趣的对象：ide
isa 在 Objective-C 中，类自身也是一个对象，它的 isa 指针指向其 metaClass（元类）。函数
super_class 指向该类的父类，若是该类已是最顶层的根类（如 NSObject），则super_class 为 NULL。学习
objc_method_list 该类中的全部实例方法链表。ui
objc_cache 实例调用过的方法缓存。
类缓存(objc_cache)
struct objc_cache {
unsigned int mask /* total = mask + 1 */ OBJC2_UNAVAILABLE;
unsigned int occupied OBJC2_UNAVAILABLE;
Method _Nullable buckets[1] OBJC2_UNAVAILABLE;
};
复制代码
它包含了下面三个变量：
-
mask： 指定分配的缓存 bucket 的总数。，因此缓存的 size（total）是 mask+1。
-
occupied： 指定实际占用的缓存bucket的总数。
-
buckets： 指向 Method 数据结构指针的数组。
为了加速消息分发， 系统会对方法和对应的地址进行缓存，就放在 objc_cache 中，因此在实际运行中，大部分经常使用的方法都是会被缓存起来的。
Method(objc_method)
struct objc_method_list {
struct objc_method_list * _Nullable obsolete OBJC2_UNAVAILABLE;
int method_count OBJC2_UNAVAILABLE;
#ifdef __LP64__
int space OBJC2_UNAVAILABLE;
#endif
/* variable length structure */
struct objc_method method_list[1] OBJC2_UNAVAILABLE;
}
复制代码
由结构定义能够看出 objc_method_list 是一个链表。
struct objc_method {
SEL _Nonnull method_name OBJC2_UNAVAILABLE;
char * _Nullable method_types OBJC2_UNAVAILABLE;
IMP _Nonnull method_imp OBJC2_UNAVAILABLE;
}
复制代码
- method_name 方法名
- method_types 方法类型
- method_imp 方法实现
关于方法类型，能够查看官方文档中的定义。
SEL(objc_selector)
方法选择器。是表示一个方法的 selector 的指针。
/// An opaque type that represents a method selector.
typedef struct objc_selector *SEL;
复制代码
方法的 selector 用于表示运行时方法的名字。Objective-C 在编译时，会依据每个方法的名字、参数序列，生成一个惟一的整型标识(Int类型的地址)，这个标识就是SEL。
两个类之间，无论它们是父类与子类的关系，仍是之间没有这种关系，只要方法名相同，那么方法的SEL就是同样的。每个方法都对应着一个 SEL。因此在 Objective-C 同一个类(及类的继承体系)中，不能存在两个同名的方法，即便参数类型不一样也不行。
举例：
- (void)addNum:(int)num;
- (void)addNum:(CGFloat)num;
复制代码
这样的定义会致使编译错误，由于这样的 SEL 是相同的，并不能区分。须要改为下方的：
- (void)addIntNum:(int)num;
- (void)addCGFloadNum:(CGFloat)num;
复制代码
固然，不一样的类能够拥有相同的 selector，这个没有问题。不一样类的实例对象执行相同的 selector 时，会在各自的方法列表中去根据 selector 去寻找本身对应的 IMP。
IMP
是一个函数指针，指向方法的实现。
/// 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
复制代码
第一个参数是指向 self 的指针(若是是实例方法，则是类实例的内存地址；若是是类方法，则是指向元类的指针)，第二个参数是方法选择器(selector)，接下来是方法的实际参数列表。
上面介绍的 SEL 就是为了查找方法的最终实现 IMP 的。因为每一个方法对应惟一的 SEL，所以咱们能够经过 SEL 方便快速准确地得到它所对应的 IMP。
实例（objc_object）
查看 objc/objc.h 中 objc_object 结构体的定义以下：
/// 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;
复制代码
能够看到，实例的定义中只有一个 isa 指针字段，它是指向本类的指针。根据 objc_class 定义能够得知关于这个对象的全部基本信息都存储在 objc_class 中。因此，objc_object 须要的就是一个指向其类对象的 isa 指针。这样当咱们向一个 Objective-C 对象发送消息时，Runtime 会根据实例对象的 isa 指针找到这个实例对象所属的类。
元类(Meta Class)
当咱们调用对象方法时（即给实例对象发送消息），是根据 isa 指针寻找到这个对象（objc_object）的类（objc_class），再寻找到对应的方法实现。对应的咱们调用类方法时（即给类对象发送消息），也须要根据 isa 指针寻找到一个包含这些类方法的一个 objc_class 结构体。这就引出了 meta-class 的概念，元类中保存了建立类对象以及类方法所需的全部信息。
简单来讲——元类是类对象的类。
元类，就像以前的类同样，它也是一个对象。你也能够调用它的方法。天然的，这就意味着他必须也有一个类。
任何 NSObject 继承体系下的 meta-class 都使用 NSObject 的 meta-class 做为本身的所属类，而基类的 meta-class 的 isa 指针是指向它本身。
方法传递
这里咱们从实际的代码调用中来学习方法传递的所有过程。
简单的 Objective-C 代码调用：
[test testMethod];
复制代码
利用 clang -rewrite-objc filename 代码转换为：
((void (*)(id, SEL))(void *)objc_msgSend)((id)test, sel_registerName("testMethod"));
复制代码
能够看出
[test testMethod];
复制代码
实质上就是
objc_msgSend((id)test, sel_registerName("testMethod"))
复制代码
而后，咱们能够在源码中查看 objc_msgSend 的执行步骤。因为源码是用汇编写的，这里就不贴出来了（主要是本身也看不懂汇编）。若是有兴趣的话，能够去下载官方源码在 objc_msg-xxx 文件中查看。
虽然，源码是用汇编写的，可是从注释中咱们基本能够看出具体的执行步骤。
- 进入消息发送阶段，判断消息接受者是否为 nil。
- 利用 isa 指针找到本身的类对象。
- 在类对象的 objc_cache（方法缓存）中查找是否有方法，有则直接取出 Method（方法）中 IMP（实现）。无则继续。
- 在类对象的 objc_method_list 中查找方法。有则直接取出，无则继续。
- 找到类对象的 super_class ，继续在其父类中重复上面两个步骤进行查找。
- 若一直往上都没有找到方法的实现，那么消息发送阶段结束，接着会进入动态解析阶段，在这个阶段，若解析到方法，则结束。不然继续。
- 最后会进入消息转发阶段，在这里能够指定别的类为本身实现这个方法。
- 若上方步骤都没有找到方法的实现，则会报方法找不到的错误，没法识别消息，unrecognzied selector sent to instance。
上面8个步骤，能够看到消息传递的过程分为了如下三个阶段：
- 消息发送阶段
- 动态解析阶段
- 消息转发阶段
消息发送阶段
从上方的分析能够获得： 方法查找的核心函数就是 _class_lookupMethodAndLoadCache3 函数，接下来重点分析 _class_lookupMethodAndLoadCache3 函数内的源码。
IMP _class_lookupMethodAndLoadCache3(id obj, SEL sel, Class cls)
{
return lookUpImpOrForward(cls, sel, obj,
YES/*initialize*/, NO/*cache*/, YES/*resolver*/);
}
复制代码
lookUpImpOrForward 函数
IMP lookUpImpOrForward(Class cls, SEL sel, id inst,
bool initialize, bool cache, bool resolver)
{
// initialize = YES , cache = NO , resolver = YES
IMP imp = nil;
bool triedResolver = NO;
runtimeLock.assertUnlocked();
// 缓存查找, 由于cache传入的为NO, 这里不会进行缓存查找, 由于在汇编语言中CacheLookup已经查找过
// Optimistic cache lookup
if (cache) {
imp = cache_getImp(cls, sel);
if (imp) return imp;
}
// runtimeLock is held during isRealized and isInitialized checking
// to prevent races against concurrent realization.
// runtimeLock is held during method search to make
// method-lookup + cache-fill atomic with respect to method addition.
// Otherwise, a category could be added but ignored indefinitely because
// the cache was re-filled with the old value after the cache flush on
// behalf of the category.
runtimeLock.lock();
checkIsKnownClass(cls);
if (!cls->isRealized()) {
realizeClass(cls);
}
if (initialize && !cls->isInitialized()) {
runtimeLock.unlock();
_class_initialize (_class_getNonMetaClass(cls, inst));
runtimeLock.lock();
// If sel == initialize, _class_initialize will send +initialize and
// then the messenger will send +initialize again after this
// procedure finishes. Of course, if this is not being called
// from the messenger then it won't happen. 2778172 } retry: runtimeLock.assertLocked(); // Try this class's cache.
// 防止动态添加方法，缓存会变化，再次查找缓存。
imp = cache_getImp(cls, sel);
// 若是查找到imp, 直接调用done, 返回方法地址
if (imp) goto done;
// 查找方法列表, 传入类对象和方法名
// Try this class's method lists. { // 根据sel去类对象里面查找方法 Method meth = getMethodNoSuper_nolock(cls, sel); if (meth) { // 若是方法存在，则缓存方法 log_and_fill_cache(cls, meth->imp, sel, inst, cls); // 方法缓存以后, 取出imp, 调用done返回imp imp = meth->imp; goto done; } } // 若是类方法列表中没有找到, 则去父类的缓存中或方法列表中查找方法 // Try superclass caches and method lists. { unsigned attempts = unreasonableClassCount(); for (Class curClass = cls->superclass; curClass != nil; curClass = curClass->superclass) { // Halt if there is a cycle in the superclass chain. if (--attempts == 0) { _objc_fatal("Memory corruption in class list."); } // 查找父类的缓存 // Superclass cache. imp = cache_getImp(curClass, sel); if (imp) { if (imp != (IMP)_objc_msgForward_impcache) { // 在父类中找到方法, 在本类中缓存方法, 注意这里传入的是cls, 将方法缓存在本类缓存列表中, 而非父类中 // Found the method in a superclass. Cache it in this class. log_and_fill_cache(cls, imp, sel, inst, curClass); goto done; } else { // Found a forward:: entry in a superclass. // Stop searching, but don't cache yet; call method
// resolver for this class first.
break;
}
}
// 查找父类的方法列表
// Superclass method list.
Method meth = getMethodNoSuper_nolock(curClass, sel);
if (meth) {
// 一样拿到方法, 在本类进行缓存
log_and_fill_cache(cls, meth->imp, sel, inst, curClass);
imp = meth->imp;
goto done;
}
}
}
// ---------------- 消息发送阶段完成 ---------------------
// ---------------- 进入动态解析阶段 ---------------------
// 上述列表中都没有找到方法实现, 则尝试解析方法
// No implementation found. Try method resolver once.
if (resolver && !triedResolver) {
runtimeLock.unlock();
_class_resolveMethod(cls, sel, inst);
runtimeLock.lock();
// Don't cache the result; we don't hold the lock so it may have
// changed already. Re-do the search from scratch instead.
triedResolver = YES;
goto retry;
}
// ---------------- 动态解析阶段完成 ---------------------
// ---------------- 进入消息转发阶段 ---------------------
// No implementation found, and method resolver didn't help. // Use forwarding. imp = (IMP)_objc_msgForward_impcache; cache_fill(cls, sel, imp, inst); done: runtimeLock.unlock(); return imp; } 复制代码
根据上方源码的解析，获得消息发送阶段的流程如图：
动态解析阶段
当消息发送阶段没有找到方法实现的时候，就会进入动态方法解析阶段。咱们来看一下动态解析阶段源码。
if (resolver && !triedResolver) {
runtimeLock.unlock();
_class_resolveMethod(cls, sel, inst);
runtimeLock.lock();
// Don't cache the result; we don't hold the lock so it may have
// changed already. Re-do the search from scratch instead.
triedResolver = YES;
goto retry;
}
void _class_resolveMethod(Class cls, SEL sel, id inst)
{
if (! cls->isMetaClass()) {
// try [cls resolveInstanceMethod:sel]
_class_resolveInstanceMethod(cls, sel, inst);
}
else {
// try [nonMetaClass resolveClassMethod:sel]
// and [cls resolveInstanceMethod:sel]
_class_resolveClassMethod(cls, sel, inst);
if (!lookUpImpOrNil(cls, sel, inst,
NO/*initialize*/, YES/*cache*/, NO/*resolver*/))
{
_class_resolveInstanceMethod(cls, sel, inst);
}
}
}
复制代码
上述代码中能够发现，动态解析方法以后，会将triedResolver = YES;那么下次就不会在进行动态解析阶段了，以后会从新执行retry，会从新对方法查找一遍。也就是说不管咱们是否实现动态解析方法，不管动态解析方法是否成功，retry以后都不会在进行动态的解析方法了。
- 对象方法
动态解析对象方法时，会调用 _class_resolveInstanceMethod(cls, sel, inst) 方法。对应的 Objective-C 的方法是 +(BOOL)resolveInstanceMethod:(SEL)sel。
- (void)viewDidLoad {
[super viewDidLoad];
// Do any additional setup after loading the view, typically from a nib.
//执行foo函数
[self performSelector:@selector(foo:)];
}
+ (BOOL)resolveInstanceMethod:(SEL)sel {
if (sel == @selector(foo:)) {//若是是执行foo函数，就动态解析，指定新的IMP
class_addMethod([self class], sel, (IMP)fooMethod, "v@:");
return YES;
}
return [super resolveInstanceMethod:sel];
}
void fooMethod(id obj, SEL _cmd) {
NSLog(@"Doing foo");//新的foo函数
}
复制代码
- 类方法
动态解析类方法时，会调用 _class_resolveClassMethod(cls, sel, inst) 方法，对应的 Objective-C 的方法是 +(BOOL)resolveClassMethod:(SEL)sel。
@implementation Person
- (void)viewDidLoad {
[super viewDidLoad];
// Do any additional setup after loading the view, typically from a nib.
//执行foo函数
[Person foo];
}
+ (BOOL)resolveClassMethod:(SEL)sel
{
if (sel == @selector(foo)) {
// 第一个参数是object_getClass(self)，传入元类对象。
class_addMethod(object_getClass(self), sel, (IMP)fooMethod, "v16@0:8");
return YES;
}
return [super resolveClassMethod:sel];
}
void fooMethod(id obj, SEL _cmd) {
NSLog(@"Doing foo");//新的foo函数
}
复制代码
上面的代码中，当动态解析方法时，咱们动态的添加了方法的实现，这里引入了一个函数 class_addMethod，这个函数就是动态配置类时的关键函数之一。
咱们看一下这个函数的声明：
BOOL class_addMethod(Class cls, SEL name, IMP imp, const char *types);
复制代码
cls： 给哪一个类添加方法。
name： 须要添加的方法名。 Objective-C 中能够直接使用 @selector(methodName) 获得方法名， Swift 中使用 #Selector(methodName)。
imp： 方法的实现，函数入口，函数名可与方法名不一样（建议与方法名相同）。函数必须至少两个参数—— self 和 _cmd。
types： 参数以及返回值类型的字符串，须要用特定符号，参考官方文档Type encodings。
咱们从整个动态解析的过程能够看到，不管咱们是否实现了动态解析的方法，系统内部都会执行 retry 对方法再次进行查找。那么若是咱们实现了动态解析方法，此时就会顺利查找到方法，进而返回 imp 对方法进行调用。若是咱们没有实现动态解析方法。就会进行消息转发。
消息转发阶段
当本类没有实现方法，而且没有动态解析方法，Runtime 这时就会调用 forwardingTargetForSelector 函数，进行消息转发，咱们能够实现forwardingTargetForSelector 函数，在其内部将消息转发给能够实现此方法的对象。
实现一个完整转发的例子以下：
#import "Car.h"
@implementation Car
- (void) driving
{
NSLog(@"car driving");
}
@end
--------------
#import "Person.h"
#import <objc/runtime.h>
#import "Car.h"
@implementation Person
+ (BOOL)resolveInstanceMethod:(SEL)sel {
return YES;//返回YES，进入下一步转发
}
- (id)forwardingTargetForSelector:(SEL)aSelector
{
// 返回可以处理消息的对象
if (aSelector == @selector(driving)) {
return [[Car alloc] init];
}
return [super forwardingTargetForSelector:aSelector];
}
@end
--------------
#import<Foundation/Foundation.h>
#import "Person.h"
int main(int argc, const char * argv[]) {
@autoreleasepool {
Person *person = [[Person alloc] init];
[person driving];
}
return 0;
}
// 打印内容
// 消息转发 car driving
复制代码
若是 forwardingTargetForSelector 函数返回为 nil 或者没有实现的话，就会调用methodSignatureForSelector方法，用来返回一个方法签名，这也是咱们正确跳转方法的最后机会。
若是 methodSignatureForSelector 方法返回正确的方法签名就会调用 forwardInvocation 方法，forwardInvocation 方法内提供一个 NSInvocation 类型的参数，NSInvocation 封装了一个方法的调用，包括方法的调用者，方法名，以及方法的参数。在 forwardInvocation 函数内修改方法调用对象便可。
若是 methodSignatureForSelector 返回的为 nil，就会来到 doseNotRecognizeSelector: 方法内部，程序 crash 提示没法识别选择器 unrecognized selector sent to instance。
代码验证：
#import "Car.h"
@implementation Car
- (void) driving
{
NSLog(@"car driving");
}
@end
--------------
#import<Foundation/Foundation.h>
#import "Person.h"
int main(int argc, const char * argv[]) {
@autoreleasepool {
Person *person = [[Person alloc] init];
[person driving];
}
return 0;
}
--------------
#import "Person.h"
#import <objc/runtime.h>
#import "Car.h"
@implementation Person
+ (BOOL)resolveInstanceMethod:(SEL)sel {
return YES;//返回YES，进入下一步转发
}
- (id)forwardingTargetForSelector:(SEL)aSelector
{
// 返回可以处理消息的对象
if (aSelector == @selector(driving)) {
// 返回nil则会调用methodSignatureForSelector方法
return nil;
// return [[Car alloc] init];
}
return [super forwardingTargetForSelector:aSelector];
}
// 方法签名：返回值类型、参数类型
- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector
{
if (aSelector == @selector(driving)) {
// 经过调用Car的methodSignatureForSelector方法获得方法签名，这种方式须要car对象有aSelector方法
return [[[Car alloc] init] methodSignatureForSelector: aSelector];
}
return [super methodSignatureForSelector:aSelector];
}
/*
* NSInvocation 封装了一个方法调用，包括：方法调用者，方法，方法的参数
* anInvocation.target 方法调用者
* anInvocation.selector 方法名
* [anInvocation getArgument: NULL atIndex: 0]; 得到参数
*/
- (void)forwardInvocation:(NSInvocation *)anInvocation
{
// anInvocation中封装了methodSignatureForSelector函数中返回的方法。
// 此时anInvocation.target 仍是person对象，咱们须要修改target为能够执行方法的方法调用者。
// anInvocation.target = [[Car alloc] init];
// [anInvocation invoke];
[anInvocation invokeWithTarget: [[Car alloc] init]];
}
@end
// 打印内容
// 消息转发 car driving
复制代码
类方法消息转发同对象方法同样，一样须要通过消息发送，动态方法解析以后才会进行消息转发机制。须要注意的是类方法的接受者为类对象。其余同对象方法消息转发模式相同。
当类对象进行消息转发时，对调用相应的 + 号的 forwardingTargetForSelector、methodSignatureForSelector、forwardInvocation 方法。
- 1. OC学习Runtime之消息传递,消息转发机制
- 2. ucos-iii学习之消息传递
- 3. IFrame消息传递
- 4. UCOSIII消息传递
- 5. windows的消息传递--消息盒子
- 6. runtime学习笔记:（一）发送消息
- 7. 异步消息的传递
- 8. Redis应用----消息传递
- 9. luogu P2018 消息传递
- 10. 【skynet】消息传递过程
- 更多相关文章...
- • HTTP 消息结构 - HTTP 教程
- • 您已经学习了 XML Schema，下一步学习什么呢？ - XML Schema 教程
- • Tomcat学习笔记（史上最全tomcat学习笔记）
- • 适用于PHP初学者的学习线路和建议
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. OC学习Runtime之消息传递,消息转发机制
- 2. ucos-iii学习之消息传递
- 3. IFrame消息传递
- 4. UCOSIII消息传递
- 5. windows的消息传递--消息盒子
- 6. runtime学习笔记:（一）发送消息
- 7. 异步消息的传递
- 8. Redis应用----消息传递
- 9. luogu P2018 消息传递
- 10. 【skynet】消息传递过程