go 结构体 内存对齐

在组内学习go语言规范时，学习到了一个很有意思并且能减少内存分配提高性能的东西，先通过一个简单的问题向大家展示一下~

type Example struct {
    Bool bool
    Int  int32
    Long int64
}

Example 结构体中 bool 占1个字节，int32占4个字节，int64占8个字节，实际上这个结构体一个对象总共占用了16个字节，可以通过 unsafe.Sizeof()函数来查看所占内存大小。

type Example struct {
    Bool bool
    Long int64
    Int  int32
}

那我在调换一下int 和 long 的位置，这个结构体的一个对象就占用24个字节了，是不是很有意思，接下来就引出了go 语言内存对齐的话题

内存对齐

为了最大限度地减少内存碎片整理，go在分配内存时都会将内存边界对齐。要确定 Go 在体系结构上所用的对齐边界，你可以运行 unsafe.Alignof 函数。Go 在 64 位系统的对齐边界是 8 个字节。因此在 Go 确定我们结构体的内存分配时，它将填充字节以确保最终占用的内存是 8 的倍数。unsafe.Offsetof取结构体字段内存的offset值。下面通过Example 这个结构体来具体展示下

type Example struct {
    Bool bool
    Int  int32
    Long int64
}
example := Example{}
alignmentBoundary := unsafe.Alignof(example)

    fmt.Printf("Example Alignof Size : %d\n", alignmentBoundary)

    sizeBool := unsafe.Sizeof(example.Bool)
    offsetBool := unsafe.Offsetof(example.Bool)
    fmt.Printf("BoolValue = Size: %d Offset: %d Addr: %v\n", sizeBool, offsetBool, &example.Bool)

    sizeInt := unsafe.Sizeof(example.Int)
    offsetInt := unsafe.Offsetof(example.Int)
    fmt.Printf("IntValue = Size: %d Offset: %d Addr: %v\n", sizeInt, offsetInt, &example.Int)

    sizeLong := unsafe.Sizeof(example.Long)
    offsetLong := unsafe.Offsetof(example.Long)

    fmt.Printf("LongValue = Size: %d Offset: %d Addr: %v\n", sizeLong, offsetLong, &example.Long)
    
    fmt.Printf("Example SizeOf : %d\n",unsafe.Sizeof(example))

以上代码的输出结果为

Example Alignof Size : 8
BoolValue = Size: 1 Offset: 0 Addr: 0xc0000a4030
IntValue = Size: 4 Offset: 4 Addr: 0xc0000a4034
LongValue = Size: 8 Offset: 8 Addr: 0xc0000a4038
Example SizeOf : 16

bool 和 int 占用了8个字节，在8个字节中 offset 1-4 之间go填充了内存，long正好占用了8个字节。通过unsafe.Sizeof 看到结构体占了16个字节，再将结构体中的int 和 long 调一下位置，会有意想不到的效果。

type Example struct {
    Bool bool
    Long int64
    Int  int32
}
example := Example{}
alignmentBoundary := unsafe.Alignof(example)

    fmt.Printf("Example Alignof Size : %d\n", alignmentBoundary)

    sizeBool := unsafe.Sizeof(example.Bool)
    offsetBool := unsafe.Offsetof(example.Bool)
    fmt.Printf("BoolValue = Size: %d Offset: %d Addr: %v\n", sizeBool, offsetBool, &example.Bool)

    sizeLong := unsafe.Sizeof(example.Long)
    offsetLong := unsafe.Offsetof(example.Long)

    fmt.Printf("LongValue = Size: %d Offset: %d Addr: %v\n", sizeLong, offsetLong, &example.Long)

    sizeInt := unsafe.Sizeof(example.Int)
    offsetInt := unsafe.Offsetof(example.Int)
    fmt.Printf("IntValue = Size: %d Offset: %d Addr: %v\n", sizeInt, offsetInt, &example.Int)

    fmt.Printf("Example SizeOf : %d\n",unsafe.Sizeof(example))

以上输出结果为

Example Alignof Size : 8
BoolValue = Size: 1 Offset: 0 Addr: 0xc00001c0e0
LongValue = Size: 8 Offset: 8 Addr: 0xc00001c0e8
IntValue = Size: 4 Offset: 16 Addr: 0xc00001c0f0
Example SizeOf : 24

说明:由于bool 占用1个字节，long占用8个字节，第一个对齐边界还剩4字节放不下long类型的8个字节，因此会重新开辟一个边界8字节，long正好占满，剩下的int 在开辟一个8字节，剩余的go会把内存填充。所以Example 占用了24个字节。因此在定义结构体时，还是要考虑字段顺序问题，这样能减少不必要的内存分配，减少gc，在流量大的情况下能提高系统性能

unsafe 内存操作

借助unsafe.Pointer 我们可以拿到结构体中字段的指针，然后修改它的值，举例如下

e := &Example{
        Bool: true,
        Int:  1,
        Long: 1,
    }
    fmt.Printf("Example before value %+v \n",e)
    pointer := unsafe.Pointer(e)
    // bool 设置值
    b := (*bool)(pointer)
    *b = false
    // int 设置值
    i := (*int32)(unsafe.Pointer(uintptr(unsafe.Pointer(e)) + unsafe.Offsetof(e.Int)))
    *i = 100

    l := (*int64)(unsafe.Pointer(uintptr(unsafe.Pointer(e)) + 8))
    *l = 1000
    fmt.Printf("Example after value %+v \n",e)

输出结果如下

Example before value &{Bool:true Int:1 Long:1} 
Example after value &{Bool:false Int:100 Long:1000} 

当结构体的某些字段是小写，并且被别的包引用时，只要能拿到这个结构体的实例，算好字段的offset就可以通过Pointer修改结构体字段的值，感觉还是很有意思的~