iOS面试系列iOS 底层原理

OC方法调用的本质以及流程

2021-10-12  本文已影响0人  再好一点点

实例方法、类方法到底是怎么调用的？

一. 先看一个神奇的方法调用结果：

新建一个NSObect 分类

@interface NSObject (Test)

+ (void)test;

@end

@implementation NSObject (Test)

+ (void)test
{
    NSLog(@"+[NSObject test] 类方法 %p", self);
}

- (void)test
{
    NSLog(@"-[NSObject test] 实例方法 %p", self);
}

@end

main函数


@interface Person : NSObject
@end

@implementation Person
@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        NSLog(@"[Person class] - %p", [MJPerson class]);
        NSLog(@"[NSObject class] - %p", [NSObject class]);
        [MJPerson test];
        [NSObject test];
    }
    return 0;
}

结果如下：

[MJPerson class] - 0x100004220
[NSObject class] - 0x7fff80760088
[NSObject test] 类方法 0x100004220
[NSObject test] 类方法 0x7fff80760088

从上述结果来看没什么问题，Person调用test方法，自己不存在此方法，然后调用父类NSObject的类方法。由于上篇文章分析过，每个类都有一个类对象还有元类对象，所以这里获得的打印结果[MJPerson class] - 0x100004220和 [NSObject test] 类方法 0x100004220内存地址是一样的，是同一份。同理[NSObject class] - 0x7fff80760088 和[NSObject test] 类方法 0x7fff80760088也是只有一份，都是类对象地址。

接下来把分类中的类方法删除掉，只保留实例方法，如下：

@implementation NSObject (Test)

- (void)test
{
    NSLog(@"-[NSObject test] 实例方法 %p", self);
}

@end

此时分类中只有实例方法，那么这时候再次运行得到的结果却是这样的：

[MJPerson class] - 0x1000041e0
[NSObject class] - 0x7fff80760088
[NSObject test] 实例方法 0x1000041e0
[NSObject test] 实例方法 0x7fff80760088

是不是很出乎意料，为什么没有类方法test程序不崩溃，反而调用了实例方法test？这个时候就需要研究一下方法的调用流程了，需要用到一个非常重要的东西就是实例对象、类对象、元类对象结构里边的一个指针isa了。

二. 怎么获取真正的isa指针地址

main函数创建一个person对象，然后打断点结果如下：

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Person *person = [[Person alloc] init];        
        NSLog(@"");
    }
    return 0;
}

断点信息：
(lldb) p/x (long)person->isa
(long) $0 = 0x011d800100004511
(lldb) p/x (long)person->isa & 0x00007ffffffffff8ULL
(unsigned long long) $1 = 0x0000000100004510
(lldb) p/x [Person class]
(Class) $2 = 0x0000000100004510 Person

从上述结果可以看出person实例对象的isa指针地址为0x011d800100004511，Person类对象的地址为0x0000000100004510，person->isa & 0x00007ffffffffff8ULL结果也是0x0000000100004510，也就说明了一个对象的isa指针&上指定的掩码可以得到真正指向的内存地址。也就是说一个实例对象的isa指针指向它自己的类对象。

从64位开始，要获取真正的isa指针需要与指定的掩码做&运算才可以得到真正的isa内存地址，64位之前isa的地址就是对应类对象的真实地址。

掩码地址如下：
# if __arm64__
#   define ISA_MASK        0x0000000ffffffff8ULL
# elif __x86_64__
#   define ISA_MASK        0x00007ffffffffff8ULL
# endif

三. 开始验证原理

下面就拿类方法做验证，实例方法和类方法是一样的，因为类对象和元类对象的数据结构是一样的。

下面定义一个结构类型

struct mj_objc_class {
    Class isa;
    Class superclass;
};

示例代码如下：

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        struct mj_objc_class *personClass = (__bridge struct mj_objc_class *)([Person class]);
        struct mj_objc_class *personMateClass = (__bridge struct mj_objc_class *)object_getClass([Person class]);
        struct mj_objc_class *objectClass = (__bridge struct mj_objc_class *)([NSObject class]);
        struct mj_objc_class *objectMateClass = (__bridge struct mj_objc_class *)object_getClass([NSObject class]);
        
        NSLog(@"personClass->isa:%p, personMateClass:%p, personMateClass->isa:%p, objectMateClass:%p, objectMateClass->isa:%p", (long long)personClass->isa & 0x00007ffffffffff8ULL, personMateClass, (long long)personMateClass->isa & 0x00007ffffffffff8ULL, objectMateClass, (long long)objectMateClass->isa & 0x00007ffffffffff8ULL);
        NSLog(@"personMateClass->superclass:%p, objectMateClass:%p, objectMateClass->superclass:%p, objectClass:%p, objectClass->superclass:%p", personMateClass->superclass, objectMateClass, objectMateClass->superclass, objectClass, objectClass->superclass);
    }
    return 0;
}

执行结果如下：

personClass->isa:0x1000044d8, personMateClass:0x1000044d8, personMateClass->isa:0x7fff80760060, objectMateClass:0x7fff80760060, objectMateClass->isa:0x7fff80760060
personMateClass->superclass:0x7fff80760060, objectMateClass:0x7fff80760060, objectMateClass->superclass:0x7fff80760088, objectClass:0x7fff80760088, objectClass->superclass:0x0

从上边第一行打印结果可以看出类对象Person的isa指针指向Person的元类，Person元类的isa指针指向NSObject的元类（根元类/基元类）。NSObject元类的isa指针指向他自己。
然后从第二行打印结果可以看出Person这个元类对象的superclass指向NSObject元类对象，NSObject元类对象的superclass指向NSObject类对象，NSObject类对象的superclass指向nill。具体流程可以见最底下图片展示。

查找路径为：

通过Person类对象的isa指针找到Person的元类对象，然后查看元类对象里边是否有方法，如果没有就通过Person元类对象的superclass继续查找到NSObject元类对象，如果没有找到，然后就通过NSObject的元类对象的superclass继续查找，就找到了NSObject类对象，发现NSObject类对象里边有test方法就调用。

所以就出现了最上边的调用+test，因为没有找到+test方法，最后调用了-test方法。

四. 通过自定义辅助结构体了解方法调用内部原理

下面是MJ大神写的一个辅助结构体，使用如下结构体就可以大致窥探到方法调用顺序以及方法到底存储在哪里。

#import <Foundation/Foundation.h>

#ifndef MJClassInfo_h
#define MJClassInfo_h

# if __arm64__
#   define ISA_MASK        0x0000000ffffffff8ULL
# elif __x86_64__
#   define ISA_MASK        0x00007ffffffffff8ULL
# endif

#if __LP64__
typedef uint32_t mask_t;
#else
typedef uint16_t mask_t;
#endif
typedef uintptr_t cache_key_t;

struct bucket_t {
    cache_key_t _key;
    IMP _imp;
};

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

struct entsize_list_tt {
    uint32_t entsizeAndFlags;
    uint32_t count;
};

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

struct method_list_t : entsize_list_tt {
    method_t first;
};

struct ivar_t {
    int32_t *offset;
    const char *name;
    const char *type;
    uint32_t alignment_raw;
    uint32_t size;
};

struct ivar_list_t : entsize_list_tt {
    ivar_t first;
};

struct property_t {
    const char *name;
    const char *attributes;
};

struct property_list_t : entsize_list_tt {
    property_t first;
};

struct chained_property_list {
    chained_property_list *next;
    uint32_t count;
    property_t list[0];
};

typedef uintptr_t protocol_ref_t;
struct protocol_list_t {
    uintptr_t count;
    protocol_ref_t list[0];
};

struct class_ro_t {
    uint32_t flags;
    uint32_t instanceStart;
    uint32_t instanceSize;  // instance对象占用的内存空间
#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;
};

struct class_rw_t {
    uint32_t flags;
    uint32_t version;
    const class_ro_t *ro;
    method_list_t * methods;    // 方法列表
    property_list_t *properties;    // 属性列表
    const protocol_list_t * protocols;  // 协议列表
    Class firstSubclass;
    Class nextSiblingClass;
    char *demangledName;
};

#define FAST_DATA_MASK          0x00007ffffffffff8UL
struct class_data_bits_t {
    uintptr_t bits;
public:
    class_rw_t* data() {
        return (class_rw_t *)(bits & FAST_DATA_MASK);
    }
};

/* OC对象 */
struct mj_objc_object {
    void *isa;
};

/* 类对象 */
struct mj_objc_class : mj_objc_object {
    Class superclass;
    cache_t cache;
    class_data_bits_t bits;
public:
    class_rw_t* data() {
        return bits.data();
    }
    
    mj_objc_class* metaClass() {
        return (mj_objc_class *)((long long)isa & ISA_MASK);
    }
};

#endif /* MJClassInfo_h */

main函数：

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        MJStudent *stu = [[MJStudent alloc] init];
        stu->_weight = 10;
        
        mj_objc_class *personClass = (__bridge mj_objc_class *)([MJPerson class]);
        class_rw_t *personClassData = personClass->data();
        class_rw_t *personMetaClassData = personClass->metaClass()->data();

        NSLog(@"1111");
    }
    return 0;
}

以上代码可自行复制到工程然后断点查看具体结果。

总结：

方法调用流程图

这张图是苹果官方文档给的图，非常形象的展示了方法调用的原理以及流程

  1. 实例方法调用：实例对象isa->类对象->类cache->类methonList->superclass->父类cache->父类methonList->superclass->...nil
  2. 类方法调用：类对象isa->元类对象->元类cache->元类methonList->superclass->父元类cache->父元类methonList->superclass->...nil
上一篇下一篇

猜你喜欢

热点阅读