Runtime 系列 1-- 从一个崩溃谈起

本文从一个崩溃问题谈起,然后逐步深入,探讨下runtime的细节和使用,主要涉及到的知识点如下:

  1. objc_msgSend的实现原理
  2. isa指针
  3. 类和元类
  4. object_getClass(obj)与[obj class]的区别

崩溃代码

我们先来看看两段代码,第一段代码主要是展示[self class ]和[super class]的区别,第二段代码会在第一段代码的基础上进一步探讨他们的区别,然后就为什么会引起崩溃做进一步探讨,这会涉及到上面的四个runtime相关的知识点

第一段代码

#import "father.h"

@interface son : father

@end
#import "son.h"

@implementation son
-(instancetype)initWithCoder:(NSCoder *)aDecoder{
    if (self == [super initWithCoder:aDecoder]) {
        NSLog(@"self class-->%@",[self class]);
        NSLog(@"super class-->%@",[super class]);

    }
    return self;
}
@end
输出:
2016-08-09 09:42:40.152 test1[33870:252634] self class-->son  
2016-08-09 09:42:40.153 test1[33870:252634] super class-->son  

分析:

根据其他语言的经验,我们想当然会认为self class是son,super class是father。但是输出的却都是一样的,都是son。这是因为oc一切方法的本质都是消息的发送和接受,是动态的,不能按照字面意思理解。具体的我们后面再进一步探讨。

第二段代码:

#import <UIKit/UIKit.h>

@interface father : UIViewController
@property(nonatomic,strong) NSString * name;

@end

=====================================

#import "father.h"

@implementation father

-(instancetype)initWithCoder:(NSCoder *)aDecoder{
    if (self ==[super initWithCoder:aDecoder]) {
        self.name = @"";
    }
    return self;
}


-(void)setName:(NSString *)name{
    NSLog(@"%s,%@", __PRETTY_FUNCTION__, @"不会调用这个方法");
    _name = name;
}
@end
#import "father.h"

@interface son : father

@end

===================================
#import "son.h"

@implementation son
-(instancetype)initWithCoder:(NSCoder *)aDecoder{
    if (self == [super initWithCoder:aDecoder]) {
        NSLog(@"self class-->%@",[self class]);
        NSLog(@"super class-->%@",[super class]);

    }
    return self;
}

-(void)setName:(NSString *)name{
    NSLog(@"%s,%@", __PRETTY_FUNCTION__, @"会调用这个方法");
    if ([name isEqualToString:@""]){
        [NSException raise:NSInvalidArgumentException format:@"姓名不能为空"];
    }


}

@end

输出:

2016-08-09 10:00:22.203 test1[34027:265079] -[son setName:],会调用这个方法  
2016-08-09 10:00:26.316 test1[34027:265079] *** Terminating app due to uncaught exception 'NSInvalidArgumentException', reason: '姓名不能为空'

分析:

我们在父类father的initWitheCoder方法中设置self.name = @"",我们只想初始化一下name的值为空。然后我们在子类son中重写了setName方法,设置不让name变量为空,否则抛出异常。

按道理说,我们在父类使用self.name方法应该调用father的setName方法,在子类son中使用self.name方法也应该调用sone的setName方法。但是实际上我们看到在父类中使用self.name调用的确实子类son的setName方法,从而导致了崩溃,这是为什么呢?

暂且按下不表,我们先来看看runtime相关的一些知识,只有理解了这些知识,我们才能真正理解上面出现的问题。


objc_msgSend的实现原理

我们平时使用方法调用都是如下的模式:

[target MethodName:var1];

但是却很少去深究这句代码为什么能执行,怎么执行。下面我们就来看看,

首先这句代码会被编译为如下样式:

objc_msgSend(target,@selector(MethodName:),var1);

而objc_msgSend函数就是我们runtime里面的一个非常重要的函数,所有的消息转发都和这个函数息息相关。

ObjC 是一种面向runtime(运行时)的语言,也就是说,它会尽可能地把代码执行的决策从编译和链接的时候,推迟到运行时。这给程序员写代码带来很大的灵活性,比如说你可以把消息转发给你想要的对象,或者随意交换一个方法的实现之类的。这就要求 runtime 能检测一个对象是否能对一个方法进行响应,然后再把这个方法分发到对应的对象去。我们拿 C 来跟 ObjC 对比一下。在 C 语言里面,一切从 main 函数开始,程序员写代码的时候是自上而下地,一个 C 的结构体或者说类吧,是不能把方法调用转发给其他对象的。但是在oc中,我们可以在运行时把上面的target换成其他对象,非常灵活。

objc_msgSend函数的原型如下:

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

上面的函数里面有两个参数id和SEL,我们分别看看。

id

objc_msgSend第一个参数类型为id,大家对它都不陌生,它是一个指向类实例的指针:

typedef struct objc_object *id;  

那objc_object又是啥呢:

struct objc_object { Class isa; };  

objc_object结构体包含一个isa指针,根据isa指针就可以顺藤摸瓜找到对象所属的类。

PS:

isa指针不总是指向实例对象所属的类,不能依靠它来确定类型,而是应该用class方法来确定实例对象的类。因为KVO的实现机理就是将被观察对象的isa指针指向一个中间类而不是真实的类,这是一种叫做 isa-swizzling 的技术。

SEL

objc_msgSend函数第二个参数类型为SEL,它是selector在Objc中的表示类型(Swift中是Selector类)。selector是方法选择器,可以理解为区分方法的 ID,而这个 ID 的数据结构是SEL:

typedef struct objc_selector *SEL;

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

可以根据SEL(方法编号)去类方法列表找到对应的实例方法的实现,或者去元类方法列表找到对应的类方法的实现.

消息转发步骤

结合上面的知识点,我们现在就可以理解了objc_msgSend的实现原理。

  1. 检测这个 selector 是不是要忽略的。比如 Mac OS X 开发,有了垃圾回收就不理会 retain, release 这些函数了。
  2. 检测这个 target 是不是 nil 对象。ObjC 的特性是允许对一个 nil 对象执行任何一个方法不会 Crash,因为会被忽略掉。
  3. 如果上面两个都过了,那就开始查找这个类的 IMP,先从 cache 里面找,完了找得到就跳到对应的函数去执行。
  4. 如果 cache 找不到就找一下方法分发表。
  5. 如果分发表找不到就到超类的分发表去找,一直找,直到找到NSObject类为止。
  6. 如果还找不到就要开始进入动态方法解析了,这个我在另外一篇文章《runtime消息转发机制的理解和使用》中会详细描述

PS:这里说的分发表其实就是Class中的方法列表,它将方法选择器和方法实现地址联系起来。

一图以蔽之:

image


isa指针

上面的objc_msgSend实现原理里面提到了isa指针、类。也是我们平常经常解除的两个概念,但是他们内部具体如何实现,却很少深究。

我们知道所有的对象都是由其对应的类实例化而来,在Objective-C中,我们用到的几乎所有类都是NSObject类的子类,NSObject类定义格式如下(忽略其方法声明):

@interface NSObject <NSObject> {
Class isa;  
}

这个Class为何物?在objc.h中我们发现其仅仅是一个结构(struct)指针的typedef定义:

typedef struct objc_class *Class;  

同样的,objcclass又是什么呢?在Objective-C2.0中,objcclass的定义如下:

struct objc_class {  
Class isa;  
}

写到这里大家可能就晕了,怎么又有一个isa?

我们知道isa指针指向的是该对象所属的类,对于实例对象的isa指针我们知道是指向其所属的类,但是实例对象所属的类的isa指针又指向谁呢?

这里我们先记住一点:类本身也是对象!!

那么既然类本身也是对象,那么他所属的类是谁?

答案就是:元类!!

所以实例对象所属的类的isa指针指向的是元类。

1.类对象的实质

类对象是由编译器创建的,即在编译时所谓的类,就是指类对象(官方文档中是这样说的: The class object is the compiled version of the class)。

任何直接或间接继承了NSObject的类,它的实例对象(instance objec)中都有一个isa指针,指向它的类对象(class object)。这个类对象(class object)中存储了关于这个实例对象(instace object)所属的类的定义的一切:包括变量,方法,遵守的协议等等。

因此,类对象能访问所有关于这个类的信息,利用这些信息可以产生一个新的实例,但是类对象不能访问任何实例对象的内容。当你调用一个 “类方法” 例如 [NSObject alloc],你事实上是发送了一个消息给他的类对象。

2.类对象和实例对象的区别

尽管类对象保留了一个类实例的原型,但它并不是实例本身。它没有自己的实例变量,也不能执行那些类的实例的方法(只有实例对象才可以执行实例方法)。然而,类的定义能包含那些特意为类对象准备的方法–类方法( 而不是的实例方法)。类对象从父类那里继承类方法,就像实例从父类那里继承实例方法一样。

类对象是一个功能完整的对象,所以也能被动态识别(dynamically typed),接收消息,从其他类继承方法。特殊之处在于它们是由编译器创建的,缺少它们自己的数据结构(实例变量),只是在运行时产生实例的代理。

元类

实际上,类对象是元类对象的一个实例!!

元类描述了 一个类对象,就像类对象描述了普通对象一样。不同的是元类的方法列表是类方法的集合,由类对象的选择器来响应。当向一个类发送消息时,objc_msgSend会通过类对象的isa指针定位到元类,并检查元类的方法列表(包括父类)来决定调用哪个方法。元类代替了类对象描述了类方法,就像类对象代替了实例对象描述了实例化方法。

很显然,元类也是对象,也应该是其他类的实例,实际上元类是根元类(root class’s metaclass)的实例,而根元类是其自身的实例,即根元类的isa指针指向自身。

类的superclass指向其父类,而元类的superclass则指向父类的元类。元类的super class链与类的super class链平行,所以类方法的继承与实例方法的继承也是并行的。而根元类(root class’s metaclass)的super_class指向根类(root class),这样,整个指针链就链接起来了!!

记住,当一个消息发送给任何一个对象, 方法的检查 从对象的 isa 指针开始,然后是父类。实例方法在类中定义, 类方法在元类和根类中定义。(根类的元类就是根类自己)。

总结

综上所述,类对象(class object)中包含了类的实例变量,实例方法的定义,而元类对象(metaclass object)中包括了类的类方法(也就是C++中的静态方法)的定义。

类对象和元类对象中当然还会包含一些其它的东西,苹果以后也可能添加其它的内容,但对于我们只需要记住:类对象存的是关于实例对象的信息(变量,实例方法等),而元类对象(metaclass object)中存储的是关于类的信息(类的版本,名字,类方法等)。

要注意的是,类对象(class object)和元类对象(metaclass object)的定义都是objc_class结构,其不同仅仅是在用途上,比如其中的方法列表在类对象(instance object)中保存的是实例方法(instance method),而在元类对象(metaclass object)中则保存的是类方法(class method)

一图以蔽之

image

object_getClass(obj)与[obj class]的区别

  1. object_getClass(obj)返回的是obj中的isa指针;

  2. 而[obj class]则分两种情况:

    • 当obj为实例对象时,[obj class]调用的是实例方法:-(Class)class,返回的obj对象中的isa指针;

    • 当obj为类对象(包括元类和根类以及根元类)时,调用的是类方法:+ (Class)class,返回的结果为其本身。

  3. -(Class)class的实现如下:

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

第一段代码解析

回头我们再看看第一段代码为什么[self class]和[super class]都输出的是son。

[self class]

根据上面的知识,我们知道[self class]最终会转换为如下形式:

id objc_msgSend(son的实例对象self, @selector(class), ...)

消息的接受者是son的实例对象self,然后调用他的class方法,它自己没有实现该方法,最终在NSObject中找到该方法的实现,然后返self的isa指针,此时self是son类的实例对象,那么isa指针也就是指向son类,所以[self class]返回的son。

[super class]

而当使用 [super setName] 调用时,会使用 objcmsgSendSuper 函数. 看下 objcmsgSendSuper 的函数定义:

id objc_msgSendSuper(struct objc_super *super,  @selector(class), ...)

第一个参数是个objcsuper的结构体,第二个参数还是类似上面的类方法的selector,先看下objcsuper这个结构体是什么东西:

struct objc_super {  
   id receiver;
   Class superClass;
};

在此处上面的结构体转换为如下样式:

struct objc_super {  
   son的实例对象self;
   father;
};

那么调用[super class]后的内部流程如下:

  1. 当使用 [super class] 时,这时要转换成 objc_msgSendSuper 的方法。
  2. 先构造 objc_super 的结构体,第一个成员变量就是 self,第二个成员变量是 father,然后要找 class 这个 selector,先去 superClass 也就是father中去找,没有,然后去father的父类中去找,结果还是在 NSObject 中找到了。
  3. 然后内部使用函数 objcmsgSend(objcsuper->receiver, @selector(class)) 去调用,此时已经和我们用 [self class] 调用时相同了,因为此时的 receiver 还是 son的实例对象self,所以这里返回的也是 son。

总结

很多人会想当然的认为“ super 和 self 类似,应该是指向父类的指针吧!”。这是很普遍的一个误区。

其实 super 是一个 Magic Keyword, 它本质是一个编译器标示符,和 self 是指向的同一个消息接受者!他们两个的不同点在于:super 会告诉编译器,调用 class 这个方法时,要去父类的方法,而不是本类里的。

上面的例子不管调用[self class]还是[super class],接受消息的对象都是当前 Son *xxx 这个对象。

当使用 self 调用方法时,会从当前类的方法列表中开始找,如果没有,就从父类中再找;而当使用 super 时,则从父类的方法列表中开始找。然后调用父类的这个方法。


第二段代码解析

第二段代码崩溃的原因是因为在father里面使用self.name = @""调用的是子类的setName方法,从而导致了崩溃。

我们来看看为什么没有调用自己的setName方法,反而是调用了子类son的setName方法。

其实结合第一段代码解析就知道,在父类father里面调用[self setName]方法,消息的接受者依然是son的实例对象,然后去son的类方法列表去找setName方法,找到了,就执行。

所以你会看到明明在父类里面调用的自己的setName方法,但是真正被执行的确实子类son的setName方法。

所以我们要注意,如果子类重写了父类的方法,那么不管在子类还是父类调用该方法,最终被执行的方法是子类的方法。


总结

本文从一个崩溃问题谈起,然后开始逐步深入,探讨了一些runtime的特性和机制,由此可见runtime的一些本质,但也只是管中窥豹,做抛砖引玉之用,大家有更好的想法,欢迎探讨。

后续我会继续对runtime其他特性进行介绍,欢迎一起探讨。

这是runtime的源码,有兴趣的同学可以自行阅读,可以加深理解

http://opensource.apple.com//source/objc4/objc4-208/runtime/objc-runtime.m

comments powered by Disqus