GO内存对齐

[问题]
在开始之前，先给大家看下go的各种基本类型在内存中所占大小情况：

func main() {
    fmt.Printf("bool size: %d\n", unsafe.Sizeof(bool(true)))
    fmt.Printf("int32 size: %d\n", unsafe.Sizeof(int32(0)))
    fmt.Printf("int8 size: %d\n", unsafe.Sizeof(int8(0)))
    fmt.Printf("int64 size: %d\n", unsafe.Sizeof(int64(0)))
    fmt.Printf("byte size: %d\n", unsafe.Sizeof(byte(0)))
    fmt.Printf("string size: %d\n", unsafe.Sizeof("EDDYCJY"))
}

输出结果：

bool size: 1 //go中申请内存单位必须是2的整数次幂，最小内存单位为2^0=1byte
int32 size: 4
int8 size: 1
int64 size: 8
byte size: 1
string size: 16

有了以上结果，下面请大家计算一下，Part1结构体在内存中占空间大小为？

type Part1 struct {
    a bool
    b int32
    c int8
    d int64
    e byte
}

输出结果：

func main() {
    part1 := Part1{}
    fmt.Printf("part1 size: %d, align: %d\n", unsafe.Sizeof(part1), unsafe.Alignof(part1))
}
//output:part1 size: 32, align: 8

最终输出为32字节，与预期的 1+4+1+8+1=15不符，为何？其实是编译器在编译阶段会对它进行内存对齐而导致的，要想理解这其中的奥秘，则需要认识什么是“内存对齐”了。

什么是内存对齐

在讲什么是内存对齐之前，我们先来看个例子：

访问未对齐内存示例

现有一片内存空间，首地址偏移量为0，其他采用相对地址。假设需要读取右图阴影部分字节数据，其访问过程如下：

1. 首次读取第一个内存块 0-3 ，移除多余的0字节
2. 读取第二个内存块 4-7 ，移除多余的5-7字节
3. 合并1-4字节，读出 xing.v 值，存入寄存器

对内存进行对齐后，内存地址分布为：

对齐内存访问

此时访问目标数据只需要 首地址+4*(2-1)即可，效率提升了一半呢。

看完例子，总结一下：内存对齐就是指编译器在编译阶段对需要申请的内存地址(虚拟内存地址)进行处理(高位补零填充)，使cpu访问任意内存数据都是一次访问即可，提高访存效率。

为什么要内存对齐

1. 平台兼容和移植性考虑（程序代码通用性）
   不是所有的硬件平台都能访问任意地址上的任意数据的，例如特定硬件平台只允许在特定地址获取特定类型的数据，否则会导致异常情况。

2. 性能原因（对cpu、内存方面有一定要求的话）
   若访问未对齐的内存，将会导致cpu进行俩次内存访问，并且需要花费额外的时钟周期来处理对齐及运算。而对于已经对齐的内存来说，只需一次访问即可完成读取指令动作，效率大大提升。

3. 某些硬件平台（例如ARM）体系不支持未对齐的内存访问

默认对齐系数

不同的平台的编译器都有自己默认的"对齐系数",可通过预编译命令 #pragma pack(n) 更改对齐系数，n代表想指定的系数大小。一般常用的平台系数如下：

• 32位：4 字节
• 64位：8 字节

如何对齐？

首先查看每种类型的对齐系数：

func main() {
    fmt.Printf("bool \talign: %d\n", unsafe.Alignof(true))
    fmt.Printf("int32 \talign: %d\n", unsafe.Alignof(int32(0)))
    fmt.Printf("int8 \talign: %d\n", unsafe.Alignof(int8(0)))
    fmt.Printf("int64 \talign: %d\n", unsafe.Alignof(int64(0)))
    fmt.Printf("byte \talign: %d\n", unsafe.Alignof(byte(0)))
    fmt.Printf("string \talign: %d\n", unsafe.Alignof("EDDYCJY"))
    fmt.Printf("map \talign: %d\n", unsafe.Alignof(map[string]string{}))
}

输出

//单位: byte
bool    align: 1
int32   align: 4
int8    align: 1
int64   align: 8
byte    align: 1
string  align: 8
map     align: 8
slice   align: 8

golang可以使用unsafe.Alignof 查看每种类型的对齐系数。对齐系数一般为2^n次方，但由于类型的对齐系数不能超过默认对齐系数（电脑64win，默认系数=8），所以最大值为8.
[成员对齐规则]
1结构体变量首地址必须模运算对齐系数等于0,必须是对齐系数(也叫对齐边界)的整数倍.
2.第一个成员变量的偏移量为0，往后的每个成员变量地址使用相对地址，对齐值必须为 编译器对齐系数和成员变量类型对齐系数的最小值，成员变量偏移地址必须为对齐系数的整数倍

[结构体对齐规则]
除了结构体成员需要做对齐外，结构体本身也需要对齐，即所得最后的内存大小必须为对齐系数的整数倍，例如64位机器上，结构体成员对齐后大小位21字节，在对结构体对齐时需要填充3字节，使得Sizeof(struct) 为对齐系数整数倍

最后

内存对齐主要是编译器做的事情，对用户代码来说是透明的，某种层面来讲，程序员可以不关心这个。但作为一名专业过硬的程序员，去了解内存对齐很有必要，在性能调优场景，或者是海量数据场景 亦或是对于内存敏感的应用，合理调整结构体的成员位置，分分钟可以节省很多内存空间。（所以，开篇提到的Part1结构体，明白为什么内存大小是32字节了吗？）