经过Runtime源码了解Objective-C中的方法存储

时间  2019-11-06
标签 经过 runtime 源码 了解 objective 方法 存储 栏目 C&C++ 繁體版
原文   原文链接

原文连接git

有经验的iOS开发者应该都知道，Objective-C是动态语言，Objective-C中的方法调用严格来讲实际上是消息传递。举例来讲，调用对象A的hello方法github

[A hello];
复制代码

实际上是向A对象发送了@selector(hello)消息。缓存

在上一篇文章Runtime中的isa结构体中提到过，对象的方法是存储在类结构中的，之因此这样设计是出于内存方面的考虑。那么，方法是如何在类结构中存储的？以及方法是在编译期间添加到类结构中，仍是在运行期间添加到了类结构中？下面分析一下这几个问题。bash

objc_class

首先看一下Objective-C中的类在Runtime源码中是如何表示的：函数

// objc_class继承于objc_object,所以
// objc_class中也有isa结构体
struct objc_class : objc_object {
    isa_t isa;
    Class superclass;
    // 缓存的是指针和vtable,目的是加速方法的调用
    cache_t cache;  
    // class_data_bits_t 至关因而class_rw_t 指针加上rr/alloc标志
    class_data_bits_t bits;  
    // 其余函数
}
复制代码

isa

isa是isa_t类型的结构体，里面存储了类的指针以及一些其余的信息。对象的方法是存储在类中的，当调用对象方法时，对象就是经过isa结构体找到本身所属的类，而后在类结构中找到方法。ui

superclass

父类指针。指向该类的父类。spa

cache

根据Runtime源码提供的注释，cache中缓存了指针和vtable，目的是加速方法的调用（关于cache的内部结构，在以后的文章中会介绍）。设计

bits

bits是class_data_bits_t类型的结构体，看一下class_data_bits_t的定义。3d

class_data_bits_t

struct class_data_bits_t { // 至关于 unsigned long bits; 占64位 // bits其实是一个地址（是一个对象的指针，能够指向class_ro_t，也能够指向class_rw_t） uintptr_t bits; } 单看class_data_bits_t的定义，也看不出来什么有用的信息，里面存储了一个64位的整数（地址）。指针

再回到类的结构，isa、superclass、cache的做用都很明确，惟独bits如今不知道做什么用。并且isa、superclass、cache中也没有保存类的方法，所以咱们有理由相信类的方法存储和bits有关系（由于仅剩这一个了啊）。

看一下苹果官方对bits的注释：

class_data_bits_t bits;    // class_rw_t * plus custom rr/alloc flags
复制代码

以及在objc-runtime-new.h中的注释：

// class_data_bits_t is the class_t->data field (class_rw_t pointer plus flags)
复制代码

注释提到，bits至关因而class_rw_t指针加上rr/alloc flags。rr/alloc flags先无论，看一下class_rw_t结构体究竟是什么。

class_rw_t

Runtime中class_rw_t的定义以下：

// 类的方法、属性、协议等信息都保存在class_rw_t结构体中
struct class_rw_t {
    uint32_t flags;
    uint32_t version;

    const class_ro_t *ro;
    
    // 方法信息
    method_array_t methods;
    // 属性信息
    property_array_t properties;
    // 协议信息
    protocol_array_t protocols;

    Class firstSubclass;
    Class nextSiblingClass;

    char *demangledName;
}
复制代码

在class_rw_t结构体中看到了方法列表、属性列表、协议列表，这正是咱们一直在找的。

须要注意的是，在objc_class结构体中提供了获取class_rw_t 的函数：

class_rw_t *data() {
    // 这里的bits就是class_data_bits_t bits;
    return bits.data();
}
复制代码

调用了class_data_bits_t的data()函数，看一下class_data_bits_t里面的data()函数：

class_rw_t* data() {
    // FAST_DATA_MASK的值是0x00007ffffffffff8UL
    // bits和FAST_DATA_MASK按位与，实际上就是取了bits中的[3,46]位
    return (class_rw_t *)(bits & FAST_DATA_MASK);
}
复制代码

上文提到过，class_data_bits_t中只有一个64位的变量bits。而class_data_bits_t的data函数，就是将bits和FAST_DATA_MASK进行按位与操做。FAST_DATA_MASK转换成二进制后的值是：

0000 0000 0000 0000 0111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1000
复制代码

FAST_DATA_MASK的[3,46]位都为1，其余为是0，所以能够理解成class_rw_t占了class_data_bits_t 中的[3,46]位，其余位置保存了额外的信息。

class_rw_t结构中有一个class_ro_t类型的指针ro,看一下class_ro_t结构体。

class_ro_t

class_ro_t的定义以下：

// class_ro_t结构体存储了类在编译期就已经肯定的属性、方法以及遵循的协议
// 由于在编译期就已经肯定了，因此是ro(readonly)的，不可修改
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;
};
复制代码

在class_ro_t结构体中，也定义了方法列表、协议列表、属性列表、变量列表。class_ro_t中的方法列表和class_rw_t中的方法列表有什么区别呢？

实际上，class_ro_t结构体存储了类在编译期间肯定的属性、方法、协议以及变量。解释一下，Objective-C是动态语言，所以Objective-C的运行须要编译期和运行时系统共同合做，这一点在类的方法的体现的很是明显。

Objective-C代码通过编译以后，会生成类结构，以及根据代码生成类的属性、方法、协议、变量，这些信息在编译期间就可以彻底肯定，编译期间肯定的信息保存在class_ro_t结构体中。由于是在编译期间肯定的，因此是只读的，不可修改，ro,表明readonly。在运行时，能够往类结构中增长一些额外的方法、协议，好比在Category中写的方法，Category中的方法就是在运行时加入到类结构中的。运行时生成的类的方法、属性、协议保存在class_rw_t结构体中，rw,表明readwrite,能够修改。

也就是说，编译以后，运行时未初始化以前，类结构中的class_data_bits_t bits，指向的是class_ro_t结构体，示意图以下：

image

通过运行时初始化以后，class_data_bits_t bits指向正确的class_rw_t结构体，而class_rw_t结构体中的ro指针，指向上面提到的class_ro_t结构体。示意图以下：

image

下面看一下Runtime中是如何实现上述操做的。

realizeClass

Runtime中class_data_bits_t指向class_rw_t结构体是经过realizeClass函数实现的。Runtime是按照以下顺序执行到realizeClass函数的：

_objc_init->map_images->map_images_nolock->_read_images->realizeClass
复制代码

realizeClass的核心代码以下：

// 该方法包括初始化类的read-write数据，并返回真正的类结构
static Class realizeClass(Class cls)
{
    const class_ro_t *ro;
    class_rw_t *rw;
    Class supercls;
    Class metacls;
    bool isMeta;

    if (!cls) return nil;
    // 若是类已经实现了，直接返回
    if (cls->isRealized()) return cls;
    // 编译期间，cls->data指向的是class_ro_t结构体
    // 所以这里强制转成class_ro_t没有问题
    ro = (const class_ro_t *)cls->data();
    if (ro->flags & RO_FUTURE) {
        // rw结构体已经被初始化（正常不会执行到这里）
        // This was a future class. rw data is already allocated.
        rw = cls->data();
        ro = cls->data()->ro;
        cls->changeInfo(RW_REALIZED|RW_REALIZING, RW_FUTURE);
    } else {
        // 正常的类都是执行到这里
        // Normal class. Allocate writeable class data.
        // 初始化class_rw_t结构体
        rw = (class_rw_t *)calloc(sizeof(class_rw_t), 1);
        // 赋值class_rw_t的class_ro_t，也就是ro
        rw->ro = ro;
        rw->flags = RW_REALIZED|RW_REALIZING;
        // cls->data 指向class_rw_t结构体
        cls->setData(rw);
    }
    // 将类实现的方法（包括分类）、属性和遵循的协议添加到class_rw_t结构体中的methods、properties、protocols列表中
    methodizeClass(cls);
    return cls;
}
复制代码

正常的类会执行到else逻辑里面，整个realizeClass函数作的操做以下：

  1. 将class->data指向的数据强制转化为class_ro_t结构体，由于编译期间class->data指向的就是class_ro_t结构体，因此这一步的转化是没有问题的
  2. 生成一个class_rw_t结构体
  3. 将class_rw_t的ro指针指向上一步转化出的class_ro_t结构体
  4. 设置class_rw_t的flags值
  5. 设置class->data指向class_rw_t结构体
  6. 调用methodizeClass函数

realizeClass的逻辑相对来讲是比较简单的，这里不作太多的介绍。看一下methodizeClass函数作了哪些操做。

methodizeClass

methodizeClass函数的主要做用是赋值类结构class_rw_t结构体里面的方法列表、属性列表、协议列表,包括category中的方法。

methodizeClass函数的主要代码以下：

// 设置类的方法列表、协议列表、属性列表，包括category的方法
static void methodizeClass(Class cls)
{
    bool isMeta = cls->isMetaClass();
    auto rw = cls->data();
    auto ro = rw->ro;
    // 将class_ro_t中的methodList添加到class_rw_t结构体中的methodList
    method_list_t *list = ro->baseMethods();
    if (list) {
        prepareMethodLists(cls, &list, 1, YES, isBundleClass(cls));
        rw->methods.attachLists(&list, 1);
    }
    // 将class_ro_t中的propertyList添加到class_rw_t结构体中的propertyList
    property_list_t *proplist = ro->baseProperties;
    if (proplist) {
        rw->properties.attachLists(&proplist, 1);
    }
    // 将class_ro_t中的protocolList添加到class_rw_t结构体中的protocolList
    protocol_list_t *protolist = ro->baseProtocols;
    if (protolist) {
        rw->protocols.attachLists(&protolist, 1);
    }
    // 添加category方法
    category_list *cats = unattachedCategoriesForClass(cls, true /*realizing*/);
    attachCategories(cls, cats, false /*don't flush caches*/); if (cats) free(cats); } 复制代码

至此，类的class_rw_t结构体设置完毕。

在看这一部分代码的时候，我有个问题一直没想明白。咱们知道，类的Category能够添加方法，可是是不能添加变量的。经过看Runtime的源码也证实了这一点，由于类的变量是在class_ro_t结构体中保存，class_ro_t结构体在编译期间就已经肯定了，是不可修改的，因此运行时不容许添加变量，这没问题。问题是运行时能够添加属性，在methodizeClass函数中有将属性赋值到class_rw_t结构体的操做，并且在处理Category的函数attachCategories中，也有将Category中的属性添加到类属性中的代码：

property_list_t **proplists = (property_list_t **)
        malloc(cats->count * sizeof(*proplists));
rw->properties.attachLists(proplists, propcount);
复制代码

在Objective-C中，属性 = get方法 + set方法 + 实例变量。既然不能添加实例变量，那Category支持添加属性的意义又在哪里？若是有了解这一点的，还但愿不吝赐教。

到这里，关于方法在类结构体中的存储位置，以及方法是何时添加到类结构体中的已经清楚了。然而，上面的结论基本上是经过看Runtime源码以及一些猜想组成的，下面写代码验证一下。

代码验证

准备代码

首先定义一个Person类，Person类中只有一个方法say，代码以下：

// Person.h

@interface Person : NSObject

- (void)say;

@end

// Person.m
- (void)say
{
    NSLog(@"hello,world!");
}
复制代码

在main.m中获取Person类的地址，代码以下：

Class pcls = [Person class];
NSLog(@"p address = %p",pcls);
复制代码

相对地址

在继续下一步以前，先了解一下相对地址的概念。正如上面代码，咱们可以打印出Person类的地址。须要注意的是，这里的地址是相对地址。所谓相对地址，是指这里的地址不是计算机里面的绝对地址，而是相对程序入口的偏移量。

代码通过编译以后，会为类分配一个地址，这个地址就是相对程序入口的偏移量。程序入口地址+该偏移量，就可以访问到类。编译运行成功以后，中止运行，不修改任何代码，再次编译，类的地址是不会变的。用上面的代码来讲就是，不修改代码，屡次编译，Person类的地址是不会改变的。缘由也很容易想到，Person类的地址是相对地址，代码没有改变的状况下，相对地址确定也是不会变的。

objc_class中各变量占用的位数

objc_class结构体以下：

struct objc_class : objc_object {
    isa_t isa;
    Class superclass;
    // 缓存的是指针和vtable,目的是加速方法的调用
    cache_t cache;  
    // class_data_bits_t 至关因而class_rw_t 指针加上rr/alloc标志
    class_data_bits_t bits;  
    // 其余函数
}
复制代码

在realizeClass中，咱们能够打印出objc_class中isa、superclass、cache所占的位数，代码以下：

printf("cache bits = %d\n",sizeof(cls->cache));
printf("super bits = %d\n",sizeof(cls->superclass));
printf("isa bits = %d\n",sizeof(cls->ISA()));
复制代码

不论调用多少次，输出的结果是一致的：

cache bits = 16
super bits = 8
isa bits = 8
复制代码

说明isa占8位，superclass占8位，cache占16位。也就是说，objc_class的地址偏移32位，便可获得bits的地址。

编译后类的结构

首先运行代码，打印出Person类的地址是：

0x1000011e8
复制代码

而后在_objc_init函数里面打断点，以下图：

image

_objc_init是Runtime初始化的入口函数，断点打在这里，可以确保此时Runtime还未初始化。接下来咱们借助lldb来查看编译后类的结构。

p (objc_class *)0x1000011e8 // 打印类指针
(objc_class *) $0 = 0x00000001000011e8

p (class_data_bits_t *)0x100001208  // 偏移32位，打印class_data_bits_t指针
(class_data_bits_t *) $1 = 0x0000000100001208

p $1->data()   // 经过data函数获取到class_rw_t结构体，此时的class_rw_t其实是class_ro_t结构体
(class_rw_t *) $2 = 0x0000000100001150

p (class_ro_t *)$2  // 将class_rw_t强制转换为class_ro_t
(class_ro_t *) $3 = 0x0000000100001150

p *$3  // 打印class_ro_t结构体
(class_ro_t) $5 = {
  flags = 128
  instanceStart = 8
  instanceSize = 8
  reserved = 0
  ivarLayout = 0x0000000000000000 <no value available>
  name = 0x0000000100000f65 "Person"
  baseMethodList = 0x0000000100001130
  baseProtocols = 0x0000000000000000
  ivars = 0x0000000000000000
  weakIvarLayout = 0x0000000000000000 <no value available>
  baseProperties = 0x0000000000000000
}
// 打印出的结构体，变量列表为空，属性列表为空，方法列表不为空，这是符合咱们预期的。由于Person类没有属性，没有变量，只有一个方法。

p $5.baseMethodList // 打印class_ro_t的方法列表
(method_list_t *) $6 = 0x0000000100001130

p $6->get(0)  // 打印方法列表中的第一个方法。由于 method_list_t中提供了get(index)函数
(method_t) $7 = {
  name = "say"
  types = 0x0000000100000fa1 "v16@0:8"
  imp = 0x0000000100000d50 (runtimeTest`-[Person say] at Person.m:12)
}

// 若是再尝试获取下一个方法，会提示错误
p $6->get(1)
Assertion failed: (i < count), function get,
复制代码

运行时初始化后类的结构

再来看一下运行时初始化以后类的结构。

在realizeClass中添加以下代码，确保当前初始化的的确是Person类

// 这里经过类名来判断
int flag = strcmp("Person",ro->name);
if(flag == 0){
    printf("nname = %s\n",ro->name);
}
复制代码

在else语句以后打断点，此时用lldb调试：

// 注意这里不能用编译期间的地址，由于编译和运行属于两个不一样的进程
(lldb) p (objc_class *)cls
(objc_class *) $0 = 0x00000001000011e8
(lldb) p (class_data_bits_t *)0x0000000100001208
(class_data_bits_t *) $1 = 0x0000000100001208
(lldb) p $1->data()
(class_rw_t *) $2 = 0x0000000100f5cf00
(lldb) p *$2
(class_rw_t) $3 = {
  flags = 2148007936
  version = 0
  ro = 0x0000000100001150
  methods = {
    list_array_tt<method_t, method_list_t> = {
       = {
        list = 0x0000000000000000
        arrayAndFlag = 0
      }
    }
  }
  properties = {
    list_array_tt<property_t, property_list_t> = {
       = {
        list = 0x0000000000000000
        arrayAndFlag = 0
      }
    }
  }
  protocols = {
    list_array_tt<unsigned long, protocol_list_t> = {
       = {
        list = 0x0000000000000000
        arrayAndFlag = 0
      }
    }
  }
  firstSubclass = nil
  nextSiblingClass = nil
  demangledName = 0x0000000000000000 <no value available>
}
复制代码

此时class_rw_t结构体的ro指针已经设置好了，可是其方法列表如今仍是空。

在return 语句上打断点，也就是执行完 methodizeClass(cls)函数以后：

(lldb) p *$2
(class_rw_t) $3 = {
  flags = 2148007936
  version = 0
  ro = 0x0000000100001150
  methods = {
    list_array_tt<method_t, method_list_t> = {
       = {
        list = 0x0000000100001130
        arrayAndFlag = 4294971696
      }
    }
  }
  properties = {
    list_array_tt<property_t, property_list_t> = {
       = {
        list = 0x0000000000000000
        arrayAndFlag = 0
      }
    }
  }
  protocols = {
    list_array_tt<unsigned long, protocol_list_t> = {
       = {
        list = 0x0000000000000000
        arrayAndFlag = 0
      }
    }
  }
  firstSubclass = nil
  nextSiblingClass = NSDate
  demangledName = 0x0000000000000000 <no value available>
}
复制代码

注意看class_rw_t中的methods已经有内容了。

打印一下class_rw_t结构体中methods的内容：

(lldb) p $3.methods.beginCategoryMethodLists()[0][0]
(method_list_t) $7 = {
  entsize_list_tt<method_t, method_list_t, 3> = {
    entsizeAndFlags = 26
    count = 1
    first = {
      name = "say"
      types = 0x0000000100000fa1 "v16@0:8"
      imp = 0x0000000100000d50 (runtimeTest`-[Person say] at Person.m:12)
    }
  }
}
复制代码

确实是Person的say方法。当尝试打印下一个方法时：

(lldb) p $3.methods.beginCategoryMethodLists()[0][1]
(method_list_t) $6 = {
  entsize_list_tt<method_t, method_list_t, 3> = {
    entsizeAndFlags = 128
    count = 8
    first = {
      name = <no value available>
      types = 0x0000000000000000 <no value available>
      imp = 0x0000000100000f65 ("Person")
    }
  }
}
复制代码

结果为空。

符合咱们的预期。

添加Category后类的结构

如今给Person类添加一个Category,而且在Category中添加一个方法，再来验证一下。

为Person类添加一个Fly分类,Category代码：

@interface Person (Fly)

- (void)fly;

@end

@implementation Person (Fly)

- (void)fly
{
    NSLog(@"I can fly");
}

@end
复制代码

和上面的验证逻辑同样，在realizeClass函数的else分以后和return语句前加断点，固然前提仍是当前确实是在初始化Person类。

在else分之以后的打印和以前一致：

(lldb) p (objc_class *)cls
(objc_class *) $0 = 0x0000000100001220
(lldb) p (class_data_bits_t *)0x0000000100001240
(class_data_bits_t *) $1 = 0x0000000100001240
(lldb) p (class_rw_t *)$1->data()
(class_rw_t *) $2 = 0x0000000100e58a30
(lldb) p *$2
(class_rw_t) $3 = {
  flags = 2148007936
  version = 0
  ro = 0x0000000100001188
  methods = {
    list_array_tt<method_t, method_list_t> = {
       = {
        list = 0x0000000000000000
        arrayAndFlag = 0
      }
    }
  }
  properties = {
    list_array_tt<property_t, property_list_t> = {
       = {
        list = 0x0000000000000000
        arrayAndFlag = 0
      }
    }
  }
  protocols = {
    list_array_tt<unsigned long, protocol_list_t> = {
       = {
        list = 0x0000000000000000
        arrayAndFlag = 0
      }
    }
  }
  firstSubclass = nil
  nextSiblingClass = nil
  demangledName = 0x0000000000000000 <no value available>
}
复制代码

重点看一下执行完methodizeClass函数以后：

(lldb) p *$2
(class_rw_t) $4 = {
  flags = 2148007936
  version = 0
  ro = 0x0000000100001188
  methods = {
    list_array_tt<method_t, method_list_t> = {
       = {
        list = 0x0000000100001108
        arrayAndFlag = 4294971656
      }
    }
  }
  properties = {
    list_array_tt<property_t, property_list_t> = {
       = {
        list = 0x0000000000000000
        arrayAndFlag = 0
      }
    }
  }
  protocols = {
    list_array_tt<unsigned long, protocol_list_t> = {
       = {
        list = 0x0000000000000000
        arrayAndFlag = 0
      }
    }
  }
  firstSubclass = nil
  nextSiblingClass = NSDate
  demangledName = 0x0000000000000000 <no value available>
}
复制代码

class_rw_t结构体的methods有内容，打印一下methods中的内容：

(lldb) p $3.methods
(method_array_t) $5 = {
  list_array_tt<method_t, method_list_t> = {
     = {
      list = 0x0000000100001108
      arrayAndFlag = 4294971656
    }
  }
}


(lldb) p $5.list
(method_list_t *) $6 = 0x0000000100001108

// 打印第一个方法
(lldb) p $6->get(0)
(method_t) $8 = {
  name = "say"
  types = 0x0000000100000fa2 "v16@0:8"
  imp = 0x0000000100000cb0 (runtimeTest`-[Person say] at Person.m:12)
}

// 打印第二个方法
(lldb) p $6->get(1)
(method_t) $9 = {
  name = "fly"
  types = 0x0000000100000fa2 "v16@0:8"
  imp = 0x0000000100000e90 (runtimeTest`-[Person(Fly) fly] at Person+Fly.m:12)
}

复制代码

Category中的方法已经成功添加，符合预期。

总结

本篇文章主要是分析了对象的方法在类结构中存储的位置，以及方法是在什么时期添加到类结构中的。经过Runtime源码以及代码验证，证明了咱们的结论。

在最后，有一些不经常使用到的知识点再次提一下：

  1. 咱们在代码中打印的地址是相对地址，不是绝对地址，是相对程序入口的偏移量
  2. 在不修改代码的前提下，类的内存地址是不变的
  3. 编译和运行属于两个不一样的进程

参考文章

深刻解析 ObjC 中方法的结构

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程