iOS-底层原理 05：内存对齐原理

iOS 底层原理 文章汇总

在探讨内存对齐原理之前，首先介绍下iOS中获取内存大小的三种方式

获取内存大小的三种方式

获取内存大小的三种方式分别是：

• sizeof
• class_getInstanceSize
• malloc_size

sizeof

• 1、sizeof是一个操作符，不是函数
• 2、我们一般用sizeof计算内存大小时，传入的主要对象是数据类型，这个在编译器的编译阶段(即编译时)就会确定大小而不是在运行时确定。
• 3、sizeof最终得到的结果是该数据类型占用空间的大小

class_getInstanceSize

这个方法在iOS-底层原理 02：alloc & init & new 源码分析分析时就已经分析了，是runtime提供的api，用于获取类的实例对象所占用的内存大小，并返回具体的字节数，其本质就是获取实例对象中成员变量的内存大小

malloc_size

这个函数是获取系统实际分配的内存大小

可以通过下面代码的输出结果来验证我们上面的说法

#import <Foundation/Foundation.h>
#import "LGPerson.h"
#import <objc/runtime.h>
#import <malloc/malloc.h>

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        NSObject *objc = [[NSObject alloc] init];
        NSLog(@"objc对象类型占用的内存大小：%lu",sizeof(objc));
        NSLog(@"objc对象实际占用的内存大小：%lu",class_getInstanceSize([objc class]));
        NSLog(@"objc对象实际分配的内存大小：%lu",malloc_size((__bridge const void*)(objc)));
    }
    return 0;
}

以下是打印结果

总结

• sizeof：计算对象类型占用的内存大小，而对象类型中一般都有一个isa属性，一个isa指针所占用的字节数为8字节，所以对象类型占用的字节数为8字节
• class_getInstanceSize：计算对象实际占用的内存大小，这个需要依据类的属性而变化，如果自定义类没有自定义属性，仅仅只是继承自NSObject，则类的实例对象实际占用的内存大小是8，可以简单理解为8字节对齐
• malloc_size：计算对象实际分配的内存大小，这个是由系统完成的，可以从上面的打印结果看出，实际分配的和实际占用的内存大小并不相等，这个问题可以通过iOS-底层原理 02：alloc & init & new 源码分析中的16字节对齐算法来解释这个问题

结构体内存对齐

接下来，我们首先定义两个结构体，分别计算他们的内存大小，以此来引入今天的正题：内存对齐原理

//1、定义两个结构体
struct Mystruct1{
    char a;     //1字节
    double b;   //8字节
    int c;      //4字节
    short d;    //2字节
}Mystruct1;

struct Mystruct2{
    double b;   //8字节
    int c;      //4字节
    short d;    //2字节
    char a;     //1字节
}Mystruct2;

//计算 结构体占用的内存大小
NSLog(@"%lu-%lu",sizeof(Mystruct1),sizeof(Mystruct2));

以下是输出结果

从打印结果我们可以看出一个问题，两个结构体乍一看，没什么区别，其中定义的变量 和 变量类型都是一致的，唯一的区别只是在于定义变量的顺序不一致，那为什么他们做占用的内存大小不相等呢？其实这就是iOS中的内存字节对齐现象

内存对齐规则

每个特定平台上的编译器都有自己的默认“对齐系数”(也叫对齐模数)。程序员可以通过预编译命令#pragma pack(n)，n=1,2,4,8,16来改变这一系数，其中的n就是你要指定的“对齐系数”。在ios中，Xcode默认为#pragma pack(8)，即8字节对齐

一般内存对齐的原则主要有3点，可以回看iOS-底层原理 02：alloc & init & new 源码分析中的说明，

可以将内存对齐原则可以理解为以下两点：

• 【原则一】 数据成员的对齐规则可以理解为min(m, n) 的公式, 其中 m表示当前成员的开始位置, n表示当前成员所需要的位数。如果满足条件 m 整除 n （即 m % n == 0）, n 从 m 位置开始存储, 反之继续检查 m+1 能否整除 n, 直到可以整除, 从而就确定了当前成员的开始位置。
• 【原则二】数据成员为结构体：当结构体嵌套了结构体时，作为数据成员的结构体的自身长度作为外部结构体的最大成员的内存大小，比如结构体a嵌套结构体b，b中有char、int、double等，则b的自身长度为8
• 【原则三】最后结构体的内存大小必须是结构体中最大成员内存大小的整数倍，不足的需要补齐。

验证对齐规则

下表是各种数据类型在ios中的占用内存大小,根据对应类型来计算结构体中内存大小

我们可以通过下图图来说明下为什么两个结构体MyStruct1 & MyStruct2的内存大小打印不一致的情况，如图所示

结构体MyStruct1 内存大小计算

根据内存对齐规则计算MyStruct1的内存大小，详解过程如下：

• 变量a：占1个字节，从0开始，此时min（0，1），即 0 存储 a
• 变量b：占8个字节，从1开始，此时min（1，8），1不能整除8，继续往后移动，知道min（8，8），从8开始，即 8-15 存储 b
• 变量c：占4个字节，从16开始，此时min（16，4），16可以整除4，即 16-19 存储 c
• 变量d：占2个字节，从20开始，此时min(20, 2)，20可以整除2，即20-21 存储 d

因此MyStruct1的需要的内存大小为 18字节，而MyStruct1中最大变量的字节数为8，所以 MyStruct1 实际的内存大小必须是 8 的整数倍，18向上取整到24，主要是因为24是8的整数倍，所以 sizeof(MyStruct1) 的结果是 24

结构体MyStruct2 内存大小计算

根据内存对齐规则计算MyStruct2的内存大小，详解过程如下：

• 变量b：占8个字节，从0开始，此时min（0，8），即 0-7 存储 b
• 变量c：占4个字节，从8开始，此时min（8，4），8可以整除4，即 8-11 存储 c
• 变量d：占2个字节，从12开始，此时min(12, 2)，20可以整除2，即12-13 存储 d
• 变量a：占1个字节，从14开始，此时min（14，1），即 14 存储 a

因此MyStruct2的需要的内存大小为 15字节，而MyStruct1中最大变量的字节数为8，所以 MyStruct2 实际的内存大小必须是 8 的整数倍，15向上取整到16，主要是因为16是8的整数倍，所以 sizeof(MyStruct2) 的结果是 16

结构体嵌套结构体

上面的两个结构体只是简单的定义数据成员，下面来一个比较复杂的，结构体中嵌套结构体的内存大小计算情况

• 首先定义一个结构体MyStruct3，在MyStruct3中嵌套MyStruct2，如下所示

//1、结构体嵌套结构体
struct Mystruct3{
    double b;   //8字节
    int c;      //4字节
    short d;    //2字节
    char a;     //1字节
    struct Mystruct2 str; 
}Mystruct3;

//2、打印 Mystruct3 的内存大小
NSLog(@"Mystruct3内存大小：%lu", sizeof(Mystruct3));
NSLog(@"Mystruct3中结构体成员内存大小：%lu", sizeof(Mystruct3.str));

打印 的结果如下所示

• 分析Mystruct3的内存计算
  根据内存对齐规则，来一步一步分析Mystruct3内存大小的计算过程

  • 变量b：占8个字节，从0开始，此时min（0，8），即 0-7 存储 b
  • 变量c：占4个字节，从8开始，此时min（8，4），8可以整除4，即 8-11 存储 c
  • 变量d：占2个字节，从12开始，此时min(12, 2)，20可以整除2，即12-13 存储 d
  • 变量a：占1个字节，从14开始，此时min（14，1），即 14 存储 a
  • 结构体成员str：str是一个结构体，根据内存对齐原则二，结构体成员要从其内部最大成员大小的整数倍开始存储，而MyStruct2中最大的成员大小为8，所以str要从8的整数倍开始，当前是从15开始，所以不符合要求，需要往后移动到16，16是8的整数倍，符合内存对齐原则，所以 16-31 存储 str

因此MyStruct3的需要的内存大小为 32字节，而MyStruct1中最大变量为str, 其内存字节数为16，所以 MyStruct2 实际的内存大小必须是 16 的整数倍，32正好是16的整数倍，所以 sizeof(MyStruct3) 的结果是 32

其内存存储情况如下图所示

内存优化（属性重排）

MyStruct1 通过内存字节对齐原则，增加了9个字节，而MyStruct2通过内存字节对齐原则，通过4+2+1的组合，只需要补齐一个字节即可满足字节对齐规则，这里得出一个结论结构体内存大小与结构体成员内存大小的顺序有关

• 如果是结构体中数据成员是根据内存从小到大的顺序定义的，根据内存对齐规则来计算结构体内存大小，需要增加有较大的内存padding即内存占位符，才能满足内存对齐规则，比较浪费内存

• 如果是结构体中数据成员是根据内存从大到小的顺序定义的，根据内存对齐规则来计算结构体内存大小，我们只需要补齐少量内存padding即可满足堆存对齐规则，这种方式就是苹果中采用的，利用空间换时间，将类中的属性进行重排，来达到优化内存的目的

以下面这个例子来进行说明 苹果中属性重排，即内存优化

• 定义一个自定义CJLPerson类，并定义几个属性，

@interface LGPerson : NSObject

@property (nonatomic, copy) NSString *name;
@property (nonatomic, copy) NSString *nickName;
// @property (nonatomic, copy) NSString *hobby;
@property (nonatomic, assign) int age;
@property (nonatomic, assign) long height;

@property (nonatomic) char c1;
@property (nonatomic) char c2;
@end

@implementation LGPerson

@end

• 在main中创建CJLPerson的实例对象，并对其中的几个属性赋值

int main(int argc, char * argv[]) {
    @autoreleasepool {
        CJLPerson *person = [CJLPerson alloc];
        person.name      = @"Cooci";
        person.nickName  = @"KC";
        person.age       = 18;
        person.c1        = 'a';
        person.c2        = 'b';

        NSLog(@"%@",person);
    }
    return 0;
}

• 断点调试person，根据CJLPerson的对象地址，查找出属性的值

  • 通过地址找出 name & nickName
    

  • 当我们向通过0x0000001200006261地址找出age等数据时，法线是乱码，这里无法找出值的原因是苹果中针对age、c1、c2属性的内存进行了重排，因为age类型占4个字节，c1和c2类型char分别占1个字节，通过4+1+1的方式，按照8字节对齐，不足补齐的方式存储在同一块内存中，

    • age的读取通过0x00000012地址
    • c1的读取通过0x62地址
    • c2的读取通过0x61地址
      

下图是CJLPerson的内存分布情况

注意：
1、char类型的数据读取出来是以ASCII码的形式显示
2、图片中地址为0x0000000000000000,表示person中还有属性未赋值

总结

所以，这里可以总结下苹果中的内存对齐思想：

• 大部分的内存都是通过固定的内存块进行读取，
• 尽管我们在内存中采用了内存对齐的方式，但并不是所有的内存都可以进行浪费的，苹果会自动对属性进行重排，以此来优化内存

字节对齐到底采用多少字节对齐？

到目前为止，我们在前文既提到了8字节对齐，也提及了16字节对齐，那我们到底采用哪种字节对齐呢？

我们可以通过objc4中class_getInstanceSize的源码来进行分析

/** 
 * Returns the size of instances of a class.
 * 
 * @param cls A class object.
 * 
 * @return The size in bytes of instances of the class \e cls, or \c 0 if \e cls is \c Nil.
 */
OBJC_EXPORT size_t
class_getInstanceSize(Class _Nullable cls) 
    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);

⬇️

size_t class_getInstanceSize(Class cls)
{
    if (!cls) return 0;
    return cls->alignedInstanceSize();
}

⬇️

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

⬇️

static inline uint32_t word_align(uint32_t x) {
    //x+7 & (~7) --> 8字节对齐
    return (x + WORD_MASK) & ~WORD_MASK;
}


//其中 WORD_MASK 为
#   define WORD_MASK 7UL

通过源码可知：

• 对于一个对象来说，其真正的对齐方式 是 8字节对齐，8字节对齐已经足够满足对象的需求了
• apple系统为了防止一切的容错，采用的是16字节对齐的内存，主要是因为采用8字节对齐时，两个对象的内存会紧挨着，显得比较紧凑，而16字节比较宽松，利于苹果以后的扩展。

总结
综合前文提及的获取内存大小的方式

• class_getInstanceSize：是采用8字节对齐，参照的对象的属性内存大小
• malloc_size：采用16字节对齐，参照的整个对象的内存大小，对象实际分配的内存大小必须是16的整数倍

内存对齐算法

目前已知的16字节内存对齐算法有两种

• alloc源码分析中的align16：
• malloc源码分析中的segregated_size_to_fit

align16： 16字节对齐算法

这个算法的思想已经在iOS-底层原理 02：alloc & init & new 源码分析中有所提及

static inline size_t align16(size_t x) {
    return (x + size_t(15)) & ~size_t(15);
}

segregated_size_to_fit： 16字节对齐算法

#define SHIFT_NANO_QUANTUM		4
#define NANO_REGIME_QUANTA_SIZE	(1 << SHIFT_NANO_QUANTUM)	// 16

static MALLOC_INLINE size_t
segregated_size_to_fit(nanozone_t *nanozone, size_t size, size_t *pKey)
{
	size_t k, slot_bytes;

	if (0 == size) {
		size = NANO_REGIME_QUANTA_SIZE; // Historical behavior
	}
	k = (size + NANO_REGIME_QUANTA_SIZE - 1) >> SHIFT_NANO_QUANTUM; // round up and shift for number of quanta
	slot_bytes = k << SHIFT_NANO_QUANTUM;							// multiply by power of two quanta size
	*pKey = k - 1;													// Zero-based!

	return slot_bytes;
}

算法原理：k + 15 >> 4 << 4 ，其中 右移4 + 左移4相当于将后4位抹零，跟 k/16 * 16一样 ，是16字节对齐算法，小于16就成0了

以 k = 2为例，如下图所示