iOS-底层-NSObject本质

作者: Imkata | 来源:发表于2019-11-22 11:27 被阅读0次

问题一：一个NSObject对象占用多少内存？

一. 分析NSObject

1. 通过源码分析

我们平时编写的Objective-C代码，底层实现其实都是C\C++代码

底层

所以Objective-C的面向对象都是基于C\C++的数据结构实现的

思考：Objective-C的对象、类主要是基于C\C++的什么数据结构实现的？
答案: 结构体

如何将Objective-C代码转换为C\C++代码?

首先创建一个命令行项目，只写下面一句代码：

NSObject *obj = [[NSObject alloc] init];

cd到main.m文件对应的文件夹，执行以下指令：

xcrun  -sdk  iphoneos  clang  -arch  arm64  -rewrite-objc  OC源文件  -o  输出的CPP文件

解释:

(使用xcode) (指定sdk跑在iOS平台上) (用clang编译器) (指定架构arm64) (重写objc文件) (OC源文件名称) (输出) (输出文件名称)
如果需要链接其他框架，使用-framework参数。比如-framework UIKit
如果将C++文件添加到项目中，需要将C++文件移除编译，否则运行报错
在使用clang转换OC为C++代码时，可能会遇到以下问题：
cannot create __weak reference in file using manual reference
解决方案：支持ARC、指定运行时系统版本，比如：
xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc -fobjc-arc -fobjc-runtime=ios-8.0.0 main.m

在终端执行xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m -o main-arm64.cpp指令之后我们就把main.m文件转换成C++文件了,打开 main-arm64.cpp文件,搜索int main(int,可以发现main函数被重写成如下代码

int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 

       NSObject *obj = ((NSObject *(*)(id, SEL))(void *)objc_msgSend)((id)((NSObject *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("NSObject"), sel_registerName("alloc")), sel_registerName("init"));

    }
    return 0;
}

再搜索IMPL,发现如下结构体,这就是底层通过C++定义的NSObject的结构体

// NSObject Implementation NSObject底层实现
struct NSObject_IMPL {
    Class isa; // 指针在64位系统占8个字节 在32位系统占4字节
};

对比OC对于NSObject的定义,发现两者其实是一样的

// NSObject定义
@interface NSObject {
    Class isa;
}
@end

验证了Objective-C的对象、类主要是基于C\C++的结构体实现的

点进入Class,发现isa其实就是一个指向结构体的指针

// 指针
typedef struct objc_class *Class;

既然是指针, 指针在64位系统占8个字节,在32位系统占4字节

现在我们就明白了,下面一句代码在内存中做了什么事了

NSObject *obj = [[NSObject alloc] init];

首先alloc之后,系统会给这个结构体分配内存,由于结构体里面只有一个isa指针,所以isa的内存地址就是结构体的内存地址,假设isa指针内存地址为: 0x100400110,那么整个结构体的内存地址也是这个,整个NSObject对象的内存地址也是这个
然后再用一个obj指针指向这个内存地址(这个obj指针里面存放的就是这个对象的地址值)

内存关系图:

内存关系图

回到文章刚开始的问题,一个NSObject对象占用多少内存？
可能你会说是8个,其实是16个字节

先了解两个函数:
size_t class_getInstanceSize(Class _Nullable cls)
获取实例对象的成员变量所占用内存大小(内存对齐后的) -> 其实就是实例对象至少占用的内存大小

size_t malloc_size(const void *ptr)
获取指针所指向内存的大小 -> 其实就是实例对象实际占用的内存大小

分别导入两个函数对应的头文件

#import <objc/runtime.h>
#import <malloc/malloc.h>

打印:

 NSObject *obj = [[NSObject alloc] init];   // 16个字节

 // 获得NSObject实例对象的成员变量所占用的大小 打印 8
 NSLog(@"%zd", class_getInstanceSize([NSObject class]));
        
 // 获得obj指针所指向内存的大小 打印 16
 NSLog(@"%zd", malloc_size((__bridge const void *)obj));

第一个打印8,第二个打印16

回到问题一,我们不难发现问题的答案应该是16

总结：一个NSObject对象占用16字节的内存

系统分配了16个字节给NSObject对象（通过malloc_size函数获得）
但NSObject对象内部只使用了8个字节的空间（64bit环境下，可以通过class_getInstanceSize函数获得)

为什么通过class_getInstanceSize获取的是8呢?

其实objc底层好多源码是开源的,我们在https://opensource.apple.com/tarballs/搜索objc,点击objc4文件夹进去,下载一个最新的(数字最大的)

objc

解压之后我们就能查看runtime源码了,打开项目搜索class_getInstanceSize

//获得的是内存对齐后的大小  aligned对齐
size_t class_getInstanceSize(Class cls)
{
    if (!cls) return 0;
    return cls->alignedInstanceSize();
}

进去alignedInstanceSize,可以看出返回的是ivar成员变量的内存大小,所以打印的才是8

// Class's ivar size rounded up to a pointer-size boundary.
    uint32_t alignedInstanceSize() {
        return word_align(unalignedInstanceSize());
    }

为什么我们需要8字节,系统给我们分配16字节呢?

现在我们看看alloc内部是怎么实现的,其实alloc内部调用的是allocWithZone,搜索_objc_rootAllocWithZone函数

①进入class_createInstance -> _class_createInstanceFromZone

②在_class_createInstanceFromZone里面我们发现有一个函数 obj = (id)calloc(1, size),其实这个calloc就是实际分配内存的函数,它传入一个参数size

③进入获取size的函数 size_t size = cls->instanceSize(extraBytes)

size_t instanceSize(size_t extraBytes) {
    //size_t size = class_getInstanceSize(Class) + extraBytes;)
    size_t size = alignedInstanceSize() + extraBytes;
    // CF requires all objects be at least 16 bytes.
    if (size < 16) size = 16;
    return size;
}

可以看出,如果size<16,size=16
现在我们就明白了，为什么OC对象至少占用16个字节了，因为系统的硬性规定。

观察上面的代码,发现上面的代码也调用了class_getInstanceSize 的内部方法alignedInstanceSize
所以,size_t size = alignedInstanceSize() + extraBytes其实就相当于size_t size = class_getInstanceSize(Class) + extraBytes

2. 通过Xcode的viewMemory查看对象内存结构

下面我们换个方式，使用Xcode的viewMemory查看obj对象内存结构

打断点,点击obj,获取到打印的内存

点击obj.png

进入viewMemory

viewMemory.png

输入地址

地址.png

查看内存

内存.png

图中是使用16进制的,一个16进制位代表4个二进制位,两个16进制位代表8个二进制位 (一个字节占用8个二进制位大小),所以两个16进制位代表一个字节
不明白的可参考:为什么一个字节占8个二进制

可以发现前8个字节有值,后8个字节为0,可以猜想系统分配内存的时候先清零,先分配了16个字节,但是我只用8个,所以把前8个给用了,后8个字节还空着

3. 使用lldb指令查看内存

除了使用viewMemory查看内存,还可以使用lldb指令查看内存:

常用指令:

print/p :打印
printobject/po :打印对象

读取内存:
memory read/打印数量+格式+字节数内存地址
x/打印数量+格式+字节数内存地址 (x是memory read简写)
例如: x/3xw 0x10010
(打印几串)(用什么进制)(每一串多少字节)

修改内存中的值:
memory write 内存地址数值
memory write 0x0000010 10

格式:
x是16进制，f是浮点，d是10进制

字节数:
b：byte 1字节，h：half word 2字节
w：word 4字节，g：giant word 8字节

例如我们读取上面的obj地址:

(lldb) p obj
(NSObject *) $0 = 0x0000000100766be0
(lldb) po obj
<NSObject: 0x100766be0>

(lldb) memory read 0x100766be0
0x100766be0: 41 91 e9 97 ff ff 1d 00 00 00 00 00 00 00 00 00  A...............
0x100766bf0: c0 6c 76 00 01 00 00 00 00 6f 76 00 01 00 00 00  .lv......ov.....

(lldb) memory read/3xg 0x100766be0
0x100766be0: 0x001dffff97e99141 0x0000000000000000
0x100766bf0: 0x0000000100766cc0

(lldb) x 0x100766be0
0x100766be0: 41 91 e9 97 ff ff 1d 00 00 00 00 00 00 00 00 00  A...............
0x100766bf0: c0 6c 76 00 01 00 00 00 00 6f 76 00 01 00 00 00  .lv......ov.....

(lldb) x/3xg 0x100766be0
0x100766be0: 0x001dffff97e99141 0x0000000000000000
0x100766bf0: 0x0000000100766cc0

(lldb) x/4xw 0x100766be0
0x100766be0: 0x97e99141 0x001dffff 0x00000000 0x00000000

(lldb) x/4dg 0x100766be0
0x100766be0: 8444247555019073
0x100766be8: 0
0x100766bf0: 4302728384
0x100766bf8: 4302728960
(lldb)

就按照x/(打印几串)(用什么进制)(每一串多少字节)格式来就可以了

可以发现打印结果和使用viewMemory是一样的,但是x 0x100766be0和x/3xg 0x100766be0打印的内存信息展示方式却是相反的,这是因为iOS都是小端模式,是从右往左读取的,所以,内存中分布是:41 91 e9 97 ff ff 1d 读取出来就是:0x001dffff97e99141

修改内存:
从上面可以看出,第一个字节的内存地址是0x100766be0,我们想修改第十个字节的数据为9,指令为memory write 0x100766be9 9

(lldb) x 0x100766be0
0x100766be0: 41 91 e9 97 ff ff 1d 00 00 00 00 00 00 00 00 00  A...............
0x100766bf0: c0 6c 76 00 01 00 00 00 00 6f 76 00 01 00 00 00  .lv......ov.....

(lldb) memory write 0x100766be9 9

(lldb) x 0x100766be0
0x100766be0: 41 91 e9 97 ff ff 1d 00 00 09 00 00 00 00 00 00  A...............
0x100766bf0: c0 6c 76 00 01 00 00 00 00 6f 76 00 01 00 00 00  .lv......ov.....
(lldb)

可以发现第十个字节被改成09了

二. 分析Student

上面我们分析是最简单的NSObject类，现在我们定义一个有两个成员变量的Student类，如下，查看它的内存情况。

首先我们要知道指针占用8字节，int类型数据占用4字节。

@interface Student : NSObject
{
    @public
    int _no;
    int _age;
}
@end

使用上面相同的方法重写为C++文件,在文件中搜索Student_IMPL,结果如下:

struct Student_IMPL {
    struct NSObject_IMPL NSObject_IVARS;
    int _no;
    int _age;
};

上面我们已经知道NSObject_IMPL结构体就是NSObject的底层定义,里面只有一个isa指针

//NSObject的实现 这个结构体只占用8个字节,只不过硬性分配给他16个字节
struct NSObject_IMPL {
    Class isa;
};

所以Student类内部的底层的结构体实现其实就是:

struct Student_IMPL {
    //struct NSObject_IMPL NSObject_IVARS;
    Class isa;
    int _no;
    int _age;
};

赋值:

Student *stu = [[Student alloc] init];
stu->_no = 4;
stu->_age = 5;

现在Student对象内部的内存分布情况我们就很明白了

内存.png

由于这个结构体中的第一个值的内存地址是0x100400110 所以整个结构体的内存地址也是0x100400110
,所以Student对象的内存地址也是0x100400110,所以stu指针里面存放的地址也是0x100400110

再次验证对象本质就是结构体:
下面用结构体指针指向stu,再通过结构体直接访问成员变量,访问成功,说明对象本质就是结构体

struct Student_IMPL *stuImpl = (__bridge struct Student_IMPL *)stu;
NSLog(@"no is %d, age is %d", stuImpl->_no, stuImpl->_age);
//no is 4, age is 5

同样我们使用viewMemory验证,发现4和5的确在内存里面

内存.png

同样使用上面两个函数打印

NSLog(@"%zd", class_getInstanceSize([Student class]));
//16
NSLog(@"%zd", malloc_size((__bridge const void *)stu));
//16

可以发现Student对象里的成员变量一共占用16个字节，stu指针指的内存也是占用16个字节，其中前面8个字节放isa，后面4字节个放_no，最后4个字节放_age。

它们在内存中是连续的,内存图如下:

分布.png

三. 分析Person和Student

我们定义更复杂的类,如下

// Person
@interface Person : NSObject
{
    @public
    int _age;
}
@end

//Student
@interface Student : Person
{
    int _no;
}
@end

Student继承于Person

Person *person = [[Person alloc] init];
person->_age = 20;
Student *stu = [[Student alloc] init]; 
stu->_no = 10;

class_getInstanceSize 获取的是对齐后的内存大小
NSLog(@"person - %zd", class_getInstanceSize([Person class])); //16
NSLog(@"person - %zd", malloc_size((__bridge const void *)person)); //16

NSLog(@"stu - %zd", class_getInstanceSize([Student class]));  //16
NSLog(@"stu - %zd", malloc_size((__bridge const void *)stu));  //16

可以发现打印都是16,分析:
对于person,底部代码为:

struct Person_IMPL {
    struct NSObject_IMPL NSObject_IVARS; // 8
    int _age; // 4
}; // 一共16字节

就算没OC源码里面的至少为16字节的规定，由于结构体的内存对齐：结构体的大小必须是最大成员大小的倍数 从这个角度看也是16字节。

对于Student,底部源码是:

struct Student_IMPL {
    struct Person_IMPL Person_IVARS; // 16
    int _no; // 4
}; // 一共16字节

虽然Person_IMPL占用16字节,但是他有4字节空出来的,所以_no正好放在那里

他们内存结构图如下:

内存.png

当然你也可以使用viewMemory和lldb查看内存情况,这里就省略了

如果给Person添加一个属性,内存中是什么样呢?

@property (nonatomic, assign) int height;

查看C++文件,看出底层是这样的

struct Person_IMPL {
    struct NSObject_IMPL NSObject_IVARS; //8字节
    int _no; //4字节
    int _height //4字节
}; //一共16字节

可以看出实例对象的内存中多了一个_height，没有setter和getter方法。

setter和getter方法为什么不和成员变量放一块呢?
因为方法一份就够了,多个对象都可以调用,没必要放实例对象的内存中,其实方法放到类对象和方法列表里面)

四. 解答最后一个疑问，引入iOS的内存对齐

创建如下类

@interface MJPerson : NSObject
{
    int _age;
    int _height;
    int _no;
}
@end

通过上面的学习,我么你很容易知道它底层是这样的

struct NSObject_IMPL
{
    Class isa;
};

struct MJPerson_IMPL
{
    struct NSObject_IMPL NSObject_IVARS; // 8
    int _age; // 4
    int _height; // 4
    int _no; // 4
}; // 计算结构体大小，按照结构体内存对齐，24

然后我们按照最少16字节,结构体的内存对齐要是8的倍数来分析,这个结构体至少需要占用24字节

接下来我们打印:

MJPerson *p = [[MJPerson alloc] init];
NSLog(@"%zd", sizeof(struct MJPerson_IMPL)); // 24
NSLog(@"%zd %zd",
      class_getInstanceSize([MJPerson class]), // 24
      malloc_size((__bridge const void *)(p))); // 32

可以发现,结构体实际需要24字节,但是系统却给Person对象32字节,为什么呢?

首先,我们还是查看源码,按照刚开始的查看alloc底层方法调用的顺序,我们会发现如下两个熟悉的方法

size_t size = cls->instanceSize(extraBytes);
obj = (id)calloc(1, size);

按照刚开始我们的分析instanceSize其实就相当于class_getInstanceSize,所以它返回的就是24,但是在calloc函数里面把24传进入怎么就变成32了呢?

你可能会说再查看calloc底层不就好了,calloc的底层在liamalloc库里面,也是在https://opensource.apple.com/tarballs/里面下载,但是分析太麻烦了，我就直接说结论了。

结论：

因为ios系统也有内存对齐的概念，内存必须是16的倍数，就算你只需要24字节，传给我24，我也会传给你32字节。
这也解释了，为什么NSObject里面只有一个isa指针(占8字节)，但是还是给他16字节的原因了。

小补充: sizeof

sizeof和class_getInstanceSize都是返回至少需要多少内存,而malloc_size返回的是实际需要的
但是他们也有不同点:sizeof传进来一个类型进来,我告诉你类型有多大,比如int,sizeof是个运算符,不是函数,所以上面我们使用sizeof打印的时候需要传入结构体NSLog(@"%zd", sizeof(struct MJPerson_IMPL)); // 24

就算你这样写

MJPerson *p = [[MJPerson alloc] init];
NSLog(@"%zd", sizeof(p)); //8

就算你把p传进去,它打印的也是8,因为你把一个指针(占用8字节)传进去了,因为sizeof是个运算符,所以在编译的时候就已经确定是8了,就相当于

MJPerson *p = [[MJPerson alloc] init];
NSLog(@"%zd", 8); //8

class_getInstanceSize传一个类进来,我告诉你最终创建的实例大小,是个函数

总结：

Objective-C的对象、类主要是基于C\C++的结构体实现的. NSObject对象底层是个结构体,结构体内部只有一个isa指针。
一个指针占8个字节，所以结构体实际需要8字节，但是一个NSObject对象却占用16个字节（因为iOS的内存对齐或者说系统规定至少占用16字节内存）。
分析对象内存的时候不要忘记结构体内存对齐（结构体的大小必须是最大成员大小的倍数，一般是8）和iOS内存对齐（对象内存大小必须是16的倍数）。
两个获取内存大小的函数
① size_t class_getInstanceSize(Class _Nullable cls)
获取实例对象的成员变量所占用内存大小（内存对齐后的）-> 其实就是实例对象至少占用的内存大小。
sizeof同上，返回的是传入类型至少占用的内存大小，sizeof是个运算符。
② size_t malloc_size(const void *ptr)
获取指针所指向内存的大小 -> 其实就是实例对象实际占用的内存大小。

Demo地址：NSObject本质

iOS-底层-NSObject本质

问题一：一个NSObject对象占用多少内存？

一. 分析NSObject

1. 通过源码分析

总结：一个NSObject对象占用16字节的内存

2. 通过Xcode的viewMemory查看对象内存结构

3. 使用lldb指令查看内存

二. 分析Student

三. 分析Person和Student

四. 解答最后一个疑问，引入iOS的内存对齐

结论：

小补充: sizeof

总结：

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读