iOS - 内存对齐&系统内存分配

首先我们先看一下内存对齐原则:

1.数据成员对⻬规则:结构(struct)(或联合(union))的数据成员，第一个数据成员放在offset为0的地方，以后每个数据成员存储的起始位置要从该成员大小或者成员的子成员大小(只要该成员有子成员，比如说是数组，结构体等)的整数倍开始(比如int为4字节,则要从4的整数倍地址开始存储。
2.结构体作为成员:如果一个结构里有某些结构体成员,则结构体成员要从其内部最大元素大小的整数倍地址开始存储.(struct a里存有struct b,b里char,int,double等元素,那b应该从8的整数倍开始存储.)
3.收尾工作:结构体的总大小,也就是sizeof的结果,.必须是其内部最大成员的整数倍.不足的要补⻬。

我们再来看一段代码:

struct Struct1 {
    char a;     // 占用1个字节,根据8字节对齐原则(以空间换时间)需补7个字节 即:1+7
    double b;   // 占用8个字节 8 + 0
    int c;      //占用4个字节 4 + 4
    short d;    // 占用2个字节 由于int c在分配内存时分配了8个字节实际只用了4个字节,所以系统在内存优化时,将short d 放在了 int c 所分配的后四个字节中
/** 需要分配24个字节 */
} MyStruct1;

struct Struct2 {
    double b;   // 占用8个字节
    char a;     //  占用1个字节 1+7
    int c;      //  由于int需从4的倍数地址开始存储,因此int c可公用 char a中分配地址的后四个字节
    short d;    // 占用2个字节 2+6
  /** 需要分配24个字节 */   
} MyStruct2;


struct Struct3 {
    double b;   // 占用8个字节 8 + 0
    int c;      // 占用4个字节 4 +4
    char a;     // 占1个字节 int c分配了8个字节内存 此时前四个字节存放int c 后四个字节闲置,可共用int c后四个字节中的第一个字节
    short d;    //占用2个字节 根据最小倍数原则,可共用int c后四个字节中的第三和第四个字节,第二个字节空缺
    /** 需要分配16个字节 */
} MyStruct3;
NSLog(@"%lu-%lu-%lu",sizeof(MyStruct1),sizeof(MyStruct2),sizeof(MyStruct3));

因此该代码块的输出结果为:24-24-16

附:

系统内存分配

Teacher  *p = [Teacher alloc];
        p.name = @"XXXX";   // NSString 8个字节
        p.age  = 18;            // int 4个字节
 NSLog(@"%lu - %lu",class_getInstanceSize([p class]),malloc_size((__bridge const void *)(p)));

输出结果为:24 - 32

注: class_getInstanceSize和malloc_size

1.class_getInstanceSize:依赖于<objc/runtime.h>，返回创建一个实例对象所需内存大小;
2.malloc_size:依赖于<malloc/malloc.h>，返回系统实际分配的内存大小.

由此我们可知24为实例对象实际所需的内存大小,32则是系统为该对象分配的内存大小;

由iOS - alloc&init底层初探我们很容得出24是怎么来的,即(NSString 8 + int 8(8字节对齐) +isa 8 = 24),那么32又是怎么来的呢?
我们来看一下libmalloc源码中关于系统内存分配的核心代码:

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
/**
   分析:
         size : 为申请的内存大小 即:24
         size + NANO_REGIME_QUANTA_SIZE - 1 = 24 + 16 - 1 = 39  二机制为: 0010 0111
         (size + NANO_REGIME_QUANTA_SIZE - 1) >> SHIFT_NANO_QUANTUM  即: 39  >>  4   ====>  二机制为: 0000 0010
         k << SHIFT_NANO_QUANTUM 即: 0000 0010 << 4  =====> 0010 0000 即slot_bytes值为32
         */
    *pKey = k - 1;                                                  // Zero-based!

    return slot_bytes;
}

#define SHIFT_NANO_QUANTUM      4
#define NANO_REGIME_QUANTA_SIZE (1 << SHIFT_NANO_QUANTUM)   // 将1左移4位 即:16
        /**
         0000 0001
         0001 0000
         */

由以上分析可以看出32的由来.

总结:

1.对象按照8字节对齐，系统分配按照16字节对齐.
2.因为内存是连续的，通过 16 字节对齐规避风险和容错，防止访问溢出,提高了寻址访问效率，即空间换时间;