内存对齐对性能的影响

unsafe 包介绍

func Alignof(x ArbitraryType) uintptr
func Offsetof(x ArbitraryType) uintptr
func Sizeof(x ArbitraryType) uintptr
type ArbitraryType int
type Pointer *ArbitraryType
1
2
3
4
5

在unsafe包中，只提供了3个函数，两个类型。就这么少的量，却有着超级强悍的功能。

ArbitraryType

// ArbitraryType is here for the purposes of documentation only and is not actually
// part of the unsafe package. It represents the type of an arbitrary Goexpression.

// ArbitryType仅用于文档目的，实际上并非不安全包的一部分。它表示任意Go表达式的类型。
type ArbitraryType int
1
2
3
4
5

ArbitraryType 是以int为基础定义的一个新类型，但是Go 语言unsafe包中，对ArbitraryType赋予了特殊的意义，通常，把interface{}看作是任意类型，那么ArbitraryType这个类型，在Go 语言系统中，比interface{}还要随意。

Pointer

1. Pointer 是ArbitraryType指针类型为基础的新类型，在Go 语言系统中，可以把Pointer类型，理解成任何指针的亲爹。

2. Go 语言的指针类型长度与int类型长度，在内存中占用的字节数是一样的。ArbitraryType类型的变量也可以是指针。

// Alignof返回变量对齐字节数量
func Alignof(x ArbitraryType) uintptr
// Offsetof返回变量指定属性的偏移量，所以如果变量是一个struct类型，不能直接将这个struct类型的变量当作参数，只能将这个struct类型变量的属性当作参数。
func Offsetof(x ArbitraryType) uintptr
// Sizeof 返回变量在内存中占用的字节数，切记，如果是slice，则不会返回这个slice在内存中的实际占用长度。
func Sizeof(x ArbitraryType) uintptr
1
2
3
4
5
6

unsafe中，通过ArbitraryType 、Pointer 这两个类型，可以将其他类型都转换过来，然后通过这三个函数，分别能取长度，偏移量，对齐字节数，就可以在虚拟内存中来回调度。

指针运算

1. uintptr这个基础类型，在Go 语言中，字节长度是与int一致。
2. 通常Pointer不能参与指针运算，比如要在某个指针地址上加上一个偏移量，Pointer是不能做这个运算的
3. 只有将Pointer类型先转换成uintptr类型，做完地址加减法运算后，再转换成Pointer类型，通过*操作达到取值、修改值的目的。
4. unsafe.Pointer其实就是类似C的void *，在Go 语言中是用于各种指针相互转换的桥梁，也即是通用指针。它可以让任意类型的指针实现相互转换，也可以将任意类型的指针转换为 uintptr 进行指针运算。
5. uintptr是Go 语言的内置类型，是能存储指针的整型， uintptr 的底层类型是int，它和unsafe.Pointer可相互转换。

unsafe.Pointer和uintptr的区别

1。 unsafe.Pointer只是单纯的通用指针类型，用于转换不同类型指针，它不可以参与指针运算；

2. 而uintptr是用于指针运算的，GC 不把 uintptr 当指针，也就是说 uintptr 无法持有对象， uintptr 类型的目标会被回收；

3. unsafe.Pointer 可以和 普通指针 进行相互转换；

4. unsafe.Pointer 可以和 uintptr 进行相互转换。

unsafe包简单使用

1. 准备结构体，成员不导出（私有）
   

2. 初始化结构体

   func main() {
   	s:=pkg.UnsafeStruct{}
   	// {0 0}
   	fmt.Println(s)
   }
   1
   2
   3
   4
   5

3. 众所周知，结构体的地址就是第一个成员的地址

   func main() {
   	s:=pkg.UnsafeStruct{}
   
   	// 取成员1
   	field1Pointer:=unsafe.Pointer(&s)
   	fmt.Println(field1Pointer)
   	// 转为int32类型指针
   	field1Ptr:=(*int32)(field1Pointer)
   	fmt.Println(*field1Ptr)
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10

   

4. 赋值，可以看到私有字段已经被改变

   func main() {
   	s:=pkg.UnsafeStruct{}
   
   	// 取成员1
   	field1Pointer:=unsafe.Pointer(&s)
   	fmt.Println(field1Pointer)
   	// 转为int32类型指针
   	field1Ptr:=(*int32)(field1Pointer)
   	fmt.Println(*field1Ptr)
   
   	// 赋值
   	*field1Ptr = 10
   	fmt.Println(s)
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14

   

5. 利用偏移量改变字段2的值

   func main() {
   	s:=pkg.UnsafeStruct{}
   
   	// 取成员1
   	field1Pointer:=unsafe.Pointer(&s)
   	fmt.Println(field1Pointer)
   	// 转为int32类型指针
   	field1Ptr:=(*int32)(field1Pointer)
   	fmt.Println(*field1Ptr)
   
   	// 赋值
   	*field1Ptr = 1314
   	fmt.Println(s)
   
   	// 获取成员2的Pointer
   	filed2Pointer:= unsafe.Pointer(uintptr(field1Pointer)+ unsafe.Sizeof(int64(0)))
   	fmt.Println(filed2Pointer)
   	// 转为int64类型指针
   	field2Ptr:=(*int64)(filed2Pointer)
   	fmt.Println(*field2Ptr)
   
   	// 赋值
   	*field2Ptr = 520
   	fmt.Println(s)
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25

   

6. 成员声明为int32和int64是为了避免对齐的影响，否则就要加上对齐值

计算字节数

在 Go 语言中，可以使用 unsafe.Sizeof 计算出一个数据类型实例需要占用的字节数。

package main

import (
	"fmt"
	"unsafe"
)

type Args struct {
	num1 int
	num2 int
}

type Flag struct {
	num1 int16
	num2 int32
}

func main() {
	fmt.Println(unsafe.Sizeof(Args{}))
	fmt.Println(unsafe.Sizeof(Flag{}))
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

1. Args 由 2 个 int 类型的字段构成，在 64位机器上，一个 int 占 8 字节，因此存储一个 Args 实例需要 16 字节。
2. Flag 由一个 int32 和 一个 int16 的字段构成，成员变量占据的字节数为 4+2 = 6，但是 unsafe.Sizeof 返回的结果为 8 字节，多出来的 2 字节是内存对齐的结果。

因此，一个结构体实例所占据的空间等于各字段占据空间之和，再加上内存对齐的空间大小。

什么是内存对齐

1. CPU 只从对齐的地址开始加载数据

2. CPU 读取块的大小是固定的，通常为 B 的 2 的整数幂次

3. CPU 访问内存时，并不是逐个字节访问，而是以字长（word size）为单位访问。比如 32 位的 CPU ，字长为 4 字节，那么 CPU 访问内存的单位也是 4 字节。

4. 这么设计的目的，是减少 CPU 访问内存的次数，加大 CPU 访问内存的吞吐量。比如同样读取 8 个字节的数据，一次读取 4 个字节那么只需要读取 2 次。

5. CPU 始终以字长访问内存，如果不进行内存对齐，很可能增加 CPU 访问内存的次数。

6. 变量 a、b 各占据 3 字节的空间，内存对齐后，a、b 占据 4 字节空间，CPU 读取 b 变量的值只需要进行一次内存访问。
7. 如果不进行内存对齐，CPU 读取 b 变量的值需要进行 2 次内存访问。第一次访问得到 b 变量的第 1 个字节，第二次访问得到 b 变量的后两个字节。

结论：内存对齐对实现变量的原子性操作也是有好处的，每次内存访问是原子的，如果变量的大小不超过字长，那么内存对齐后，对该变量的访问就是原子的，这个特性在并发场景下至关重要。

对齐系数

unsafe 标准库提供了 Alignof 方法，可以返回一个类型的对齐值，也可以叫做对齐系数或者对齐倍数。

unsafe.Alignof(Args{}) // 8
unsafe.Alignof(Flag{}) // 4

1
2
3

1. 对于任意类型的变量 x ，unsafe.Alignof(x) 至少为 1。
2. 对于 struct 结构体类型的变量 x，计算 x 每一个字段 f 的 unsafe.Alignof(x.f)，unsafe.Alignof(x) 等于其中的最大值。
3. 对于 array 数组类型的变量 x，unsafe.Alignof(x) 等于构成数组的元素类型的对齐倍数。
4. 没有任何字段的空 struct{} 和没有任何元素的 array 占据的内存空间大小为 0，不同的大小为 0 的变量可能指向同一块地址。

struct 内存对齐

type demo1 struct {
	a int8
	b int16
	c int32
}

type demo2 struct {
	a int8
	c int32
	b int16
}

func main() {
	fmt.Println(unsafe.Sizeof(demo1{})) // 8
	fmt.Println(unsafe.Sizeof(demo2{})) // 12
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

demo1

1. a 是第一个字段，默认是已经对齐的，从第 0 个位置开始占据 1 字节。
2. b 是第二个字段，对齐倍数为 2，因此，必须空出 1 个字节，偏移量才是 2 的倍数，从第 2 个位置开始占据 2 字节。
3. c 是第三个字段，对齐倍数为 4，此时，内存已经是对齐的，从第 4 个位置开始占据 4 字节即可。

因此 demo1 的内存占用为 8 字节。

demo2

1. a 是第一个字段，默认是已经对齐的，从第 0 个位置开始占据 1 字节。
2. c 是第二个字段，对齐倍数为 4，因此，必须空出 3 个字节，偏移量才是 4 的倍数，从第 4 个位置开始占据 4 字节。
3. b 是第三个字段，对齐倍数为 2，从第 8 个位置开始占据 2 字节，但最大对齐倍数为4，需要填充2个字节

demo2 的对齐倍数由 c 的对齐倍数决定，也是 4，因此，demo2 的内存占用为 12 字节。

空结构体

空 struct{} 大小为 0，作为其他 struct 的字段时，一般不需要内存对齐。

但是有一种情况除外：即当 struct{} 作为结构体最后一个字段时，需要内存对齐。