关于 NSObject 对象的内存布局，看我就够了

本文字数： 5213字

阅读时间： 16分钟

向上滑动阅览本文目录

1. class_getInstanceSize

2. alloc

3. malloc_size

4. sizeOf

5. 应用

四、内存对齐

1. 内存对齐是什么？

2. 内存对齐的原则

3. 内存对齐的原因

4. 内存对齐的注意事项

1. 情景一：带有一个成员变量的对象占用内存的大小

2. 情景二：不同成员变量的对象占用内存的大小

3. 情景三：继续添加不同类型的成员变量

4. 情景四：调换成员变量声明顺序

5. 情景五：继承体系下的内存分配

在终端执行下面的命令，可以将Objective-C对象转换成C/C++语言：

x crun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m -o main.cpp 

举例说明：

1int main(int argc, const char * argv[]) {
2    @autoreleasepool {
3
4        NSObject *obj = [[NSObject alloc] init];
5    }
6    return 0;
7}

执行上述命令后，得到的结果如下：

 1struct NSObject_IMPL {
 2    Class isa;
 3};
 4
 5int main(int argc, const char * argv[]) {
 6    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 
 7
 8        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"));
 9    }
10    return 0;
11}

通过上述编译后的代码可以看出，NSObject对象的底层数据结构是结构体。

1struct NSObject_IMPL {
2    Class isa;
3};

其中，sizeof确切来说并不算做函数，它是一种操作符。

要想回答这个问题，还先得认识几个常用的获取内存大小的工具： class_getInstanceSize、malloc_size、sizeof

废话不多说，先撸几串，”尝尝”：

 1int main(int argc, const char * argv[]) {
 2    @autoreleasepool {
 3        NSObject *obj = [[NSObject alloc] init];
 4
 5        NSLog(@"class_getInstanceSize = %zd", class_getInstanceSize([NSObject class]));
 6        NSLog(@"malloc_size = %zd", malloc_size((__bridge const void *)(obj)));
 7        NSLog(@"sizeOf = %zd", sizeof(obj));
 8    }
 9    return 0;
10}

控制台打印如下：

1class_getInstanceSize = 8
2malloc_size = 16
3sizeOf = 8

咦？！获取结果居然不一样，那是为什么呢？那就继续探究一下源码实现吧！

这个是一个runtime提供的API，用于获取类实例对象所占用的内存大小，返回所占用的字节数。

在苹果开源网站，找到对应的objc4-756.zip压缩包。看一下源码实现，在objc-class.mm文件到找到了该方法的实现，如下所示：

1size_t class_getInstanceSize(Class cls)
2{
3    if (!cls) return 0;
4    return cls->alignedInstanceSize();
5}

好像看不出所以然来，继续查看alignedInstanceSize实现：

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

对象的创建离不开alloc方法，对象创建的过程中可能存在分配内存空间的方法，一起看下源码。

在NSObject.mm类中找到alloc以及allocFromZone方法的实现：

1+ (id)alloc {
2    return _objc_rootAlloc(self);
3}
4
5// Replaced by ObjectAlloc
6+ (id)allocWithZone:(struct _NSZone *)zone {
7    return _objc_rootAllocWithZone(self, (malloc_zone_t *)zone);
8}

找到时机调用的核心方法是： _objc_rootAllocWithZone

 1id _objc_rootAllocWithZone(Class cls, malloc_zone_t *zone)
 2{
 3    id obj;
 4
 5#if __OBJC2__
 6    // allocWithZone under __OBJC2__ ignores the zone parameter
 7    (void)zone;
 8    obj = class_createInstance(cls, 0);
 9#else
10    if (!zone) {
11        obj = class_createInstance(cls, 0);
12    }
13    else {
14        obj = class_createInstanceFromZone(cls, 0, zone);
15    }
16#endif
17
18    if (slowpath(!obj)) obj = callBadAllocHandler(cls);
19    return obj;
20}

继续寻找： class_createInstance

1id  class_createInstance(Class cls, size_t extraBytes)
2{
3    return _class_createInstanceFromZone(cls, extraBytes, nil);
4}

继续查找：_class_createInstanceFromZone

 1id _class_createInstanceFromZone(Class cls, size_t extraBytes, void *zone, 
 2                              bool cxxConstruct = true, 
 3                              size_t *outAllocatedSize = nil)
 4{
 5    if (!cls) return nil;
 6
 7    assert(cls->isRealized());
 8
 9    // Read class's info bits all at once for performance
10    bool hasCxxCtor = cls->hasCxxCtor();
11    bool hasCxxDtor = cls->hasCxxDtor();
12    bool fast = cls->canAllocNonpointer();
13
14    size_t size = cls->instanceSize(extraBytes);
15
16    if (outAllocatedSize) *outAllocatedSize = size;
17
18    id obj;
19    if (!zone  &&  fast) {
20        obj = (id)calloc(1, size);
21        if (!obj) return nil;
22        obj->initInstanceIsa(cls, hasCxxDtor);
23    } 
24    else {
25        if (zone) {
26            obj = (id)malloc_zone_calloc ((malloc_zone_t *)zone, 1, size);
27        } else {
28            obj = (id)calloc(1, size);
29        }
30        if (!obj) return nil;
31
32        // Use raw pointer isa on the assumption that they might be 
33        // doing something weird with the zone or RR.
34        obj->initIsa(cls);
35    }
36
37    if (cxxConstruct && hasCxxCtor) {
38        obj = _objc_constructOrFree(obj, cls);
39    }
40
41    return obj;
42}

在调用calloc或者malloc_zone_calloc函数是需要传入size参数，可以发现size变量来源于下面的代码：

1size_t size = cls->instanceSize(extraBytes);

继续看一下instanceSize函数的实现：

1size_t instanceSize(size_t extraBytes) {
2        size_t size = alignedInstanceSize() + extraBytes;
3        // CF requires all objects be at least 16 bytes.
4        if (size < 16) size = 16;
5        return size;
6    }

这个函数主要获取系统实际分配的内存大小，具体的底层实现也可以在源码libmalloc找到，具体如下：

 1size_t malloc_size(const void *ptr)
 2{
 3    size_t size = 0;
 4
 5    if (!ptr) {
 6        return size;
 7    }
 8
 9    (void)find_registered_zone(ptr, &size);
10    return size;
11}

核心的方法是find_registered_zone，具体如下：

 1static inline malloc_zone_t *
 2find_registered_zone(const void *ptr, size_t *returned_size)
 3{
 4    // Returns a zone which contains ptr, else NULL
 5
 6    if (0 == malloc_num_zones) {
 7        if (returned_size) {
 8            *returned_size = 0;
 9        }
10        return NULL;
11    }
12
13    // first look in the lite zone
14    if (lite_zone) {
15        malloc_zone_t *zone = lite_zone;
16        size_t size = zone->size(zone, ptr);
17        if (size) { // Claimed by this zone?
18            if (returned_size) {
19                *returned_size = size;
20            }
21            // Return the virtual default zone instead of the lite zone - see 
22            return default_zone;
23        }
24    }
25
26    malloc_zone_t *zone = malloc_zones[0];
27    size_t size = zone->size(zone, ptr);
28    if (size) { // Claimed by this zone?
29        if (returned_size) {
30            *returned_size = size;
31        }
32        if (!has_default_zone0()) {
33            return zone;
34        } else {
35            return default_zone;
36        }
37    }
38
39    int32_t volatile *pFRZCounter = pFRZCounterLive;   // Capture pointer to the counter of the moment
40    OSAtomicIncrement32Barrier(pFRZCounter); // Advance this counter -- our thread is in FRZ
41
42    unsigned index;
43    int32_t limit = *(int32_t volatile *)&malloc_num_zones;
44    malloc_zone_t **zones = &malloc_zones[1];
45    for (index = 1; index size(zone, ptr);
48        if (size) { // Claimed by this zone?
49            goto out;
50        }
51    }
52    // Unclaimed by any zone.
53    zone = NULL;
54    size = 0;
55out:
56    if (returned_size) {
57        *returned_size = size;
58    }
59    OSAtomicDecrement32Barrier(pFRZCounter); // our thread is leaving FRZ
60    return zone;
61}

由于该方法涉及到虚拟内存分配的流程，过于复杂，本文就再详细展开了。理解一点即可，这个函数是获取系统实际分配的内存大小。

值得注意的一点是，sizeof是操作符，不是函数，它的作用对象是数据类型，主要作用于编译时。

因此，它作用于变量时，也是对其类型进行操作。得到的结果是该数据类型占用空间大小，即size_t类型。

1struct test
2{
3    int a;
4    char b;
5};

1NSLog(@"%zd", sizeof([NSObject class]));

sizeof 只会计算类型所占用的内存大小，不会关心具体的对象的内存布局；

例如：在64位架构下，自定义一个NSObject对象，无论该对象生命多少个成员变量，最后得到的内存大小都是8个字节。

Q

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

1struct object {
2    int a; // 4
3    NSString *b; // 8
4    int c; // 4
5    char d; // 1
6};

控制台打印：

1Align------24

结构体中最大的成员变量占用8个字节，根据上面的对齐原则，最终获得的对齐系数是min(最大成员变量大小8个字节, 对齐系数8个字节) = 8。

不考虑内存对齐的情况下，实际占用4 + 8 + 4 + 1 = 17个字节，考虑字节对齐的情况下，分配24个字节。

具体分配的情况如下表所示：

未对齐时：

▼▼▼

对齐时：

▼▼▼

1struct object {
2    int a; // 4
3    char b; // 1
4    int c; // 4
5};

控制台打印：

1Align------12

根据上面结构体，可以得出需要对齐的字节数为min(对齐系数, 最大成员变量的内存大小) = 4个字节。对齐后的内存分配表如下所示：

4.1 内存分配

在结构体中，声明成员变量的顺序不一致，也会导致最终分配内存大小的不同。

1struct object {
2    int a; // 4
3    NSString *b; // 8
4    int c; // 4
5};

对齐情况下，系统分配24个字节，具体分配如下：

调换一下成员变量的声明顺序：

1struct object {
2    int a; // 4
3    int c; // 4
4    NSString *b; // 8
5};

控制台打印：

1Align------16

这种情况下，系统分配16个字节，具体分配如下：

通过上面对比可以看出，在日常开发中，设计结构的时候，合理调换成员变量的顺序，可以很好地节省内存空间。

1字节对齐

如何实现1字节对齐呢？需要用到伪指令#pragma pack(n)（n为字节对齐数）使得结构体1字节对齐。

所谓的1字节对齐，就是取消原有平台的对齐限制，或者认为是重新设置对齐系数为1个字节。

在结构体声明的时候添加上述的伪代码指令，如下所示：

1#pragma pack(1) /*1字节对齐*/
2struct object {
3    int a; // 4
4    char b; // 1
5    int c; // 4
6};
7#pragma pack() /*还原默认对齐*/

控制台打印：

1Align------9

按照实际占用大小去计算，4+1+4 = 9个字节，确实达到了1字节对齐的目的。

去除字节对齐限制呢？如下所示：

1//#pragma pack(1) /*1字节对齐*/
2struct object {
3    int a; // 4
4    char b; // 1
5    int c; // 4
6};
7//#pragma pack() /*还原默认对齐*/

控制台打印：

1Align------12

分配的数据又重新变成了12个字节。

在1字节对齐下，确实能够很好的保证跨平台正常的通信，同时也节省了内存空间，但是这样做降低读取的效率，只能按单个字节为单位读取，耗时低效。

还有两种方式也可以定义对齐方式：

1、 __attribute__((packed))  ：消结构在编译过程中的优化对齐，也可以认为是1字节对齐；

1struct object {
2    int a; // 4
3    char b; // 1
4    int c; // 4
5}__attribute__((packed));

控制台打印：

1Align------9

2、 __attribute__((aligned(n))) ：使结构体中的成员变量对齐在n字节的自然边界上，即取最大成员变量的长度和n的最大值作为对齐字节数。

在下面的结构体中，最大的成员变量的大小是4个字节，此时设置n=8，结果如下：

1struct object {
2    int a; // 4
3    char b; // 1
4    int c; // 4
5}__attribute__((aligned(8)));

控制台打印：

1Align------16

得出结果正是按照8字节对齐的。

如果将n设置为1呢？

1struct object {
2    int a; // 4
3    char b; // 1
4    int c; // 4
5}__attribute__((aligned(1)));

控 制台打印：

1Align------12

发现最终打印的结果是按照4字节对齐的得出的，因为结构体中最大的成员变量占用4个字节，即max(4, 1) = 4

自己对结构体填充

1struct object {
2    int a; // 4
3    char b; // 1
4    char b1[3]; // 自己填充字节
5    int c; // 4
6};

这样虽然保证了访问效率高，但并不节省空间，同时扩展性不是很好。例如，当字节对齐有变化时，需要填充的字节数可能就会发生变化。

在创建好的Mac命令过程中新建一个类Animal,并且利用上述讲解的三个工具查看一下具体占用的内存，具体代码如下：

 1@interface Animal : NSObject {
 2    @public
 3    int _age;
 4}
 5
 6@end
 7
 8@implementation Animal
 9
10@end

在main.m中打印对应的内存大小：

1Animal *animal = [[Animal alloc] init];
2NSLog(@"Animal -- class_getInstanceSize = %zd", class_getInstanceSize([animal class]));
3NSLog(@"Animal -- malloc_size = %zd", malloc_size((__bridge const void *)(animal)));
4NSLog(@"Animal -- sizeOf = %zd", sizeof(animal));

在控制台的打印结果：

1Animal -- class_getInstanceSize = 16
2Animal -- malloc_size = 16
3Animal -- sizeOf = 8

那它的内存是如何计算的呢？那就看一下，OC代码转换成C++语言，是如何构造数据的。

在main.m文件所在的目录下，继续执行上述讲解的Clang的命令。

在main.cpp文件中，我们搜索查找到Animal类的定义，究其精华如下：

1struct NSObject_IMPL {
2    Class isa;
3};
4
5struct Animal_IMPL {
6    struct NSObject_IMPL NSObject_IVARS; //指针对象，占用一个机器字长，占用8个字节
7    int _age; // 4个字节
8};

发现Animal结构体中自动增加了一个成员变量NSObject_IVARS，即Class类型的成员变量。于是，获取Animal实例对象的内存大小，就等价于获取Animal_IMPL结构体所占用的内存大小。

在上述的讲解中，可以知道获取内存大小方法的区别。malloc_size函数获取系统分配的内存大小，class_getInstanceSize是获取实际占用的内存大小。

通过上述打印结果可以看出，系统分配给Animal实例对象内存是16个字节，实际占用的也是16个字节。看到这，想必疑问重重，实际占用的内存大小不应该是8 + 4 = 12个字节么？这是怎么回事呢？

其实这里涉及一点计算机的知识点——内存对齐。在结构体中，总大小为结构体对最大成员大小的整数倍，如不满足，最后填充字节以满足，可分配的最小内存是结构体中内存占用最大的成员变量的大小。

在Animal_IMPL结构体中，占用内存最大的成员变量是NSObject_IVARS，占用的内存是8个字节。成员变量_age占用4个字节，由于不满足内存对齐规则，故实际占用8个字节，实际占用的内存大小就是16个字节。

具体内存分配如下图所示:

在情景一的基础上，在Animal对象再添加一个成员变量_weight，如下所示：

 1@interface Animal : NSObject {
 2    @public
 3    int _age;
 4    int _weight;
 5}
 6
 7@end
 8
 9@implementation Animal
10
11@end

控制台打印结果如下所示：

1Animal -- class_getInstanceSize = 16
2Animal -- malloc_size = 16
3Animal -- sizeOf = 8

那它的内存是如何计算的呢？那就看一下，OC代码转换成C++语言，是如何构造数据的。

执行完Clang命令后，在main.cpp文件中，我们搜索查找到Animal类的定义，究其精华如下：

1struct NSObject_IMPL {
2    Class isa;
3};
4
5struct Animal_IMPL {
6    struct NSObject_IMPL NSObject_IVARS; // 8个字节
7    int _age; // 4个字节
8    int _weight; // 4个字节
9};

结构体中成员变量的内存都是连续分配，具体演示如下：

啊！？怎么还是16个字节呢？难道我多一个成员变量没有分配内存么？请往下看：

通过图标分析，可以看出两个成员变量正好占用了8个字节，满足内存对齐的原则。

是不是感觉还是有点懵？继续往下看…

添加整型成员变量

 1@interface Animal : NSObject {
 2    @public
 3    int _age;
 4    int _weight;
 5    int _height;
 6}
 7
 8@end
 9
10@implementation Animal
11
12@end

控制台打印结果：

1Animal -- class_getInstanceSize = 24
2Animal -- malloc_size = 32
3Animal -- sizeOf = 8

按照之前的讲解，系统实际分配内存大小是16个字节的整数倍，故malloc_size函数获取内存大小是32个字节。新添加的成员变量占用4个字节，应该是16+4 = 20字节，但是由于内存对齐的原则存在，实际占用16+8 = 24个字节。

添加字符串型成员变量

 1@interface Animal : NSObject {
 2    @public
 3    int _age;
 4    int _weight;
 5    int _height;
 6    NSString *_name;
 7}
 8@end
 9
10@implementation Animal
11
12@end

控制台打印：

1Animal -- class_getInstanceSize = 32
2Animal -- malloc_size = 32
3Animal -- sizeOf = 8

这个案例，很容易就能算出实际分配了32个字节。

看到这，大概掌握了一些规律，接下来难度升级一下。

情况一：整型变量中掺杂字符串变量

 1@interface Animal : NSObject {
 2    @public
 3    int _age;
 4    NSString *_name;
 5    int _weight;
 6    NSString *_nick;
 7    int _height;
 8}
 9
10@end
11
12@implementation Animal
13
14@end

控制台打印：

1Animal -- class_getInstanceSize = 48
2Animal -- malloc_size = 48
3Animal -- sizeOf = 8

系统分配了48个字节，实际占用了48个字节。

情况二：调换一下声明成员变量的顺序

 1@interface Animal : NSObject {
 2    @public
 3    int _age;
 4    int _weight;
 5    int _height;
 6    NSString *_name;
 7    NSString *_nick;
 8}
 9@end
10
11@implementation Animal
12@end

控制台打印：

1Animal -- class_getInstanceSize = 40
2Animal -- malloc_size = 48
3Animal -- sizeOf = 8

系统分配了48个字节，实际占用了40个字节。

具体的内存分配表如下：

情况一：整型变量中掺杂字符串变量

 1@interface Animal : NSObject {
 2    @public
 3    int _age;
 4    int _weight;
 5}
 6@end
 7
 8@implementation Animal
 9@end
10
11@interface Dog : Animal {
12    @public
13    int _height;
14}
15@end
16
17@implementation Dog
18@end

控制台打印：

1Dog -- class_getInstanceSize = 24
2Dog -- malloc_size = 32
3Dog -- sizeOf = 8

系统分配了48个字节，实际占用了48个字节。

情况二：调换一下声明成员变量的顺序

 1@interface Animal : NSObject {
 2    @public
 3    int _age;
 4    int _weight;
 5    int _height;
 6    NSString *_name;
 7    NSString *_nick;
 8}
 9@end
10
11@implementation Animal
12@end

控制台打印

1Animal -- class_getInstanceSize = 40
2Animal -- malloc_size = 48
3Animal -- sizeOf = 8

系统分配了48个字节，实际占用了40个字节。

具体的内存分配表如下：

新加一个Animal的子类Dog，如下所示：

 1@interface Animal : NSObject {
 2    @public
 3    int _age;
 4    int _weight;
 5}
 6@end
 7
 8@implementation Animal
 9@end
10
11@interface Dog : Animal {
12    @public
13    int _height;
14}
15@end
16
17@implementation Dog
18@end

控制台打印：

1Dog -- class_getInstanceSize = 24
2Dog -- malloc_size = 32
3Dog -- sizeOf = 8

系统分配了32个字节，实际占用了24个字节。

继承关系如下：Dog —> Animal –> NSObject

那么在这样继承关系下，是如何计算内存大小的呢？

在main.cpp中找到一些编译后的数据结构：

 1struct NSObject_IMPL {
 2    Class isa; // 8个字节
 3};
 4
 5struct Animal_IMPL {
 6    struct NSObject_IMPL NSObject_IVARS; // 8个字节
 7    int _age; // 4个字节
 8    int _weight; // 4个字节
 9};
10
11struct Dog_IMPL {
12    struct Animal_IMPL Animal_IVARS; // 16个字节
13    int _height; // 4个字节
14};
15
16// 转化精简之后的结构体：
17struct Dog_IMPL {
18    Class isa; // 8个字节
19  int _age; // 4个字节
20  int _weight; // 4个字节
21    int _height; // 4个字节
22};

内存分配表如下：

本文主要以探索OC对象的内存布局为核心目的。先通过Clang编译器命令将OC代码转化成C/C++代码，了解OC对象的底层结构。

紧接着，通过剖析获取内存大小API的源码以及内存对齐的原理，明确了数据结构底层计算内存大小的普适规则。

最后，又通过不同场景下的数据举例，验证了不同数据结构内存大小计算规则，进而揭示了OC对象在内存布局上所遵循的通用规律。

在掌握OC对象的内存布局的原理后，可以在以后的开发过程中，更加合理地设计数据结构，更高效的利用系统内存，进而写出健壮性更高的代码。

参考文献：

[1]https://opensource.apple.com

[2]https://developer.ibm.com/articles/pa-dalign/

[3]https://link.jianshu.com/?t=https://en.wikipedia.org/wiki/Data_structure_alignment

[4]https://link.jianshu.com/?t=https://msdn.microsoft.com/en-us/library/ms253949.aspx

[5]https://link.jianshu.com/?t=https://zh.wikipedia.org/wiki/PowerPC

     您对本文有什么疑问吗？

     点我写留言

▼▼ ▼