iOS底层系列06 -- OC对象的内存对齐与分配

• 在阐述OC对象内存对齐之前，我们先来看个实例代码

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

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        NSObject *p1 = [[NSObject alloc]init];
    
        int size1 = sizeof(p1);
        size_t size2 = class_getInstanceSize([p1 class]);
        size_t  size3 = malloc_size((__bridge const void*)(p1));
        
        NSLog(@" size1 = %d",size1);
        NSLog(@" size2 = %lu",size2);
        NSLog(@" size3 = %lu",size3);
    }
    return 0;
}

• 上述代码的运行结果如下：

Snip20210624_2.png

• 同一个对象，获取对象内存大小的三种方式，所获取的结果存在差异；
• sizeof()：计算数据类型占用的内存大小，其参数可以传基本数据类型、对象类型、指针类型，对于类似于int这样的基本数据而言，sizeof获取的就是数据类型占用的内存大小，不同的数据类型所占用的内存大小是不一样的；
• class_getInstanceSize()是用来计算实例对象 实际占用的内存大小，采用的是8字节对齐的方式进行运算的，也就是说对象实际占用的内存大小是8的倍数，其实现源码如下所示：

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

uint32_t alignedInstanceSize() const {
        return word_align(unalignedInstanceSize());
}

static inline uint32_t word_align(uint32_t x) {
    return (x + WORD_MASK) & ~WORD_MASK;
}

• 其中 WORD_MASK是宏，其定义为define WORD_MASK 7UL；
• malloc_size()是用来计算实例对象分配的内存大小，其是由系统完成的，采用的是16字节对齐的方式进行运算的，也就是说对象实际占用的内存大小是16的倍数，在iOS底层系列03 -- alloc init new方法的探索文章中已经做了非常详尽的阐述；
• 在研究OC对象内存对齐，我们先来探索结构体的内存对齐，因为OC对象在底层的本质就是结构体；

结构体内存对齐

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

• 结构体内存对齐的规则：

  • 规则一： 结构体第一个数据成员的起始地址是在结构体内存地址偏移量offset=0的位置，然后依次排列其他数据成员，其他数据成员必须满足当前数据成员的起始位置(结构体内存地址偏移量offset)是当前数据成员本身内存大小的整数倍；
  • 规则二：数据成员为结构体：即当结构体中嵌套了结构体时，必须满足作为数据成员的结构体的起始位置是其最大成员内存大小的整数倍，比如结构体a嵌套结构体b，b中有char、int、double等，则b的最大成员内存大小为8；
  • 规则三：最后结构体的内存大小必须是结构体中最大成员内存大小的整数倍，不足的需要补齐；

• 第一个代码实例：

struct Student{
    int age;
    char name;
    float weight;
};

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        struct Student s1;
        NSLog(@" s1的内存大小 = %lu",sizeof(s1)); //s1的内存大小 = 12
    }
    return 0;
}

• int整型变量age，从offset = 0开始 占4个字节，即占用[0,3];
• char字符型name，此时offset = 4，是char本身内存大小的整数倍，满足规则一，所以占用(3,4]；
• float浮点型weight，此时offset = 5，不是float本身内存大小的整数倍，需要补齐3个字节，此时offset = 8，满足是float本身内存大小的整数倍，所以占用[8,11]；
• 所有数据成员排列完成占用了12个字节，满足规则三，最终结构体的内存大小为12个字节；
• 内存布局如下：

Snip20210205_61.png

• 第二个代码实例：

struct Dog{
    char name;
    int age;
    double height;
    short color;
};

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        struct Dog d1;
        NSLog(@"d1的内存大小 = %lu",sizeof(d1));//d1的内存大小=24
    }
    return 0;
}

• char字符型name，从offset = 0开始，占用[0,1);
• int整型变量age，此时offset =1, 不是int本身内存大小的整数倍 需要补齐3个字节，此时offset = 4，所以占用[4,7];
• double浮点型height，此时offset = 8，满足是double本身内存大小的整数倍，所以占用[8,15];
• short字符型color，此时offset =16，满足是short本身内存大小的整数倍，所以占用[16,17];
• 所有数据成员排列完成占用了18个字节，不满足规则三，需补齐4个字节，满足规则三，最终结构体占用24个字节；

Snip20210205_62.png

• 第三个代码实例：在第二个实例的基础上使用同一个结构体Dog，只不过更改了数据成员的顺序；

struct Dog{
    double height;
    int age;
    short color;
    char name;
};

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        struct Dog d1;
        NSLog(@"d1的内存大小 = %lu",sizeof(d1));//d1的内存大小=16
    }
    return 0;
}

• double浮点型height，从offset = 0开始，占用[0,7]；
• int整型变量age，此时offset = 8 是int本身内存大小的整数倍 所以占用[8,11]；
• short浮点型color，此时offset = 12，满足是short本身内存大小的整数倍，所以占用[12,13]；
• char字符型name，此时offset = 14，满足是char本身内存大小的整数倍，所以占用[14,15)；
• 所有数据成员排列完成占用了15个字节，不满足规则三，需补齐1个字节，满足规则三，最终结构体占用16个字节；

Snip20210205_63.png

• 可以看出结构体成员的排列顺序会影响结构体内存的大小，这就为内存优化--属性重排提供了理论依据；

• 第四个代码实例：结构体中嵌套结构体

struct Dog{
    double height;
    int age;
    short color;
    char name;
};

struct Student{
    char name;
    double height;
    int age;
    struct Dog dog;
    float weight;
};

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        struct Student s1;
        NSLog(@"s1的内存大小 = %lu",sizeof(s1));//d1的内存大小=48
    }
    return 0;
}

• char字符型name，从offset = 0开始，占用[0,1)；
• double整型变量height，此时offset = 1,不满足规则一，需补齐7个字节，此时offset = 8，满足规则一，所以占用[8,15]；
• int整型age，此时offset=16，满足规则一，所以占用[16,19]；
• struct结构体dog，此时offset = 20，dog结构最大成员内存大小为8个字节，那么不满足规则二，需补齐4个字节，此时offset = 24，满足规则二，结构体dog占用16个字节，所以在Student结构体中占用[24,39]；
• float浮点型weight，此时offset = 40，满足规则一，所以占用[40,44]；
• 所有数据成员排列完成占用了44个字节，不满足规则三，需补齐4个字节，满足规则三，最终结构体占用48个字节；

内存优化(属性重排)

• 从上面的结构体内存对齐的第二个和第三个实例代码分析，得到结构体成员的顺序影响结构体内存的大小；也可以类推到OC对象；

• 首先介绍几个LLDB调试命令：

  • po 对象 [打印对象信息]
  • x 对象 [读取对象内存信息]
  • x/3gx 对象 [读取3个以8字节内存信息为单位,以16进制形式输出的内存数据] (g--8个字节)
  • x/4wx 对象 [读取4个以4字节内存信息为单位,以16进制形式输出的内存数据] (w--4个字节)
  • x/8hx 对象 [读取8个以2字节内存信息为单位,以16进制形式输出的内存数据] (h--2个字节)
  • x/16bx 对象 [读取16个以1字节内存信息为单位,以16进制形式输出的内存数据] (b--1个字节)
  • x/3gx ，x/4wx，x/8hx，x/16bx 读取的内存数据 已按小端模式显示了；

• 注释：4个二进制位可以完整表示一个16进制位所包含的所有数据，那么两个16进制位可以表示8个二进制位，也就是一个字节；

• 第一个实例代码：

@interface YYPerson : NSObject

@property(nonatomic,assign)int age;

@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        YYPerson *p1 = [[YYPerson alloc]init];
        p1.age = 10;
    }
    return 0;
}

• 断点调试如下：

Snip20210205_67.png

• po p1打印出p1的内存地址；
• x p1 读取p1的内存信息，我们知道OC对象的isa占用8个字节，所以前面的16个16进制位，（每两个16进制位是一个字节）就表示8个字节，又由于iOS是小端模式即低地址存储低字节数据，所以数据的读取从右往左--从高位到低位；
• age是int类型占用4个字节，下面 po 0x000000000000000a其实是打印了8个字节的内存数据，但由于后面四个字节都是空的，所以最终打印的age的值为10；
• YYPerson 的内存布局为isa + age 其占用（isa 8 + age 4）=12，再进行8字节对齐，最后占用16个字节；

• 第二个实例代码：YYPerson新增字符串属性name

@interface YYPerson : NSObject

@property(nonatomic,assign)int age;
@property(nonatomic,copy)NSString *name;

@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        YYPerson *p1 = [[YYPerson alloc]init];
        p1.age = 10;
        p1.name = @"liyanyan";
    }
    return 0;
}

• 断点调试如下：

Snip20210205_68.png

• YYPerson 的内存布局为isa+ age+name 其中isa占8个字节，age占4个字节，name占用8个字节；

• YYPerson占用（isa 8 + age 4 + name 8）= 20，再进行8字节内存对齐，最后占用24个字节；

• 第三个实例代码：YYPerson新增char属性p_char

@interface YYPerson : NSObject

@property(nonatomic,assign)int age;
@property(nonatomic,copy)NSString *name;
@property(nonatomic,assign)char p_char;

@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        YYPerson *p1 = [[YYPerson alloc]init];
        p1.age = 10;
        p1.name = @"liyanyan";
        p1.p_char = 'A'; //65
    }
    return 0;
}

• 断点调试如下：

Snip20210205_72.png

• 从调试控制台上可以看出YYPerson对象占用24个字节，内存布局依次是isa+char+int+NSString，与YYPerson定义的属性顺序并不一致，如果按照定义的属性顺序进行内存布局，其占用的字节数为32个；

• 从这里就可以看出，系统为了优化内存，会在每个对象内部进行属性重排，并使用8字节对齐，使单个对象占用的资源尽可能小；

• 第四个实例代码：

@interface YYPerson : NSObject

@property(nonatomic,assign)int age;
@property(nonatomic,copy)NSString *name1;
@property(nonatomic,assign)char p_char1;
@property(nonatomic,copy)NSString *name2;
@property(nonatomic,assign)char p_char2;
@property(nonatomic,assign)short s_age;
@property(nonatomic,assign)char p_char3;
@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        YYPerson *p1 = [[YYPerson alloc]init];
        p1.age = 10;
        p1.name1 = @"liyanyan";
        p1.p_char1 = 'A'; //65
        p1.name2 = @"li";
        p1.p_char2 = 'B'; //66
        p1.s_age = 30;
        p1.p_char3 = 'C'; //67
        
        int size1 = sizeof(p1);
        size_t size2 = class_getInstanceSize([p1 class]);
        size_t  size3 = malloc_size((__bridge const void*)(p1));
        
        NSLog(@" size1 = %d",size1); //8
        NSLog(@" size2 = %zu",size2); //40
        NSLog(@" size3 = %zu",size3); //48
    }
    return 0;
}

• 内存分析如下：

Snip20210207_75.png

• x p1 打印出YYPerson对象在内存中信息内存，从控制台的结果来看35 35 00 00 01 80 1d 00这是首8个字节的内容是isa的内容，41 42 43 00 1e 00 00 00这是后面紧跟的8个字节的内容，其中前面四个字节应该是三个char类型的属性值和一个空字节内容，分别对应p_char1，p_char2和p_char3，然后 后面四个字节1e 00 00 00应该是short类型s_age的值；

• 从上面的分析不难得出YYPerson的内存布局为：isa+ p_char1+ p_char2 + p_char3 + s_age+age+name1+name2这与YYPerson在.h文件中定义的属性顺序不同，表明系统做了内存优化，进行了属性的重排；
  -x/5gx p1打印出5个以8字节为单位的内存信息，总共40个字节的内存数据；po 0x0000000100002010 可以看出是属性name1的值 p1.name1 = @"liyanyan"；po 0x0000000100002030可以看出是属性name2的值 p1.name2 = @"li"；
  0x001d800100003535 -- 是isa的内容；
  0x0000001e00434241 -- 包含了三个char/一个空字节和一个short/两个空字节的内容;
  0x000000000000000a -- 包含一个int age的内容和四个空字节；
  总共40个字节；也就是说YYPerson的内存大小为40个字节；

• x/10wx p1 打印出10个以4字节为单位的内存信息，总共40个字节的内存数据，其中0x0000000a是int age的值=30，后面四个字节内容0x00000000为空，是因为内存对齐的原因，空出了这四个字节，p 0x0000000a打印的是age的值p1.age = 10；
  p 0x0000001e打印的是s_age的值p1.s_age = 30；

Snip20210207_76.png

• x/16bx p1 打印出16个以1字节为单位的内存信息，总共16个字节的内存数据；

• p 0x41打印出p_char1= 65 ('A') 占一个字节；

• p 0x42打印出p_char2= 66 ('B') 占一个字节；

• p 0x43打印出p_char3= 67 ('C') 占一个字节；

• 最后由size_t size2 = class_getInstanceSize([p1 class])，计算出YYPerson内存大小为40个字节；即size2 = 40；与上面的分析吻合；

• 但是由malloc_size()函数，计算出来的结果 size3 = 48，即YYPerson需要分配48个字节的内存空间，与上面size2=40 YYPerson实际的内存大小不匹配，原因在于malloc_size()函数的内部计算逻辑不同，下一章专门探讨malloc_size()函数的底层实现；

最终总结：

• OC对象在计算实际占用内存大小时采用8字节对齐，即调用了class_getInstanceSize()函数进行计算的；
• OC对象在计算实际分配内存大小采用的16字节对齐，即调用了calloc()函数或者malloc_size()函数；
• 系统为了优化内存，会在每个对象内部进行属性重排，并使用8字节对齐，使单个对象占用的内存资源尽可能的小；