Go语言中节省内存技巧方法示例

引言GO虽然不消耗大量内存,但是仍有一些小技巧可以节省内存,良好的编码习惯是每一个程序员都应该具备的素质。 预先分配切片 数组是具有连续内存的相同类型的集合。数

引言

GO虽然不消耗大量内存,但是仍有一些小技巧可以节省内存,良好的编码习惯是每一个程序员都应该具备的素质。

预先分配切片

数组是具有连续内存的相同类型的集合。数组类型定义时要指定长度和元素类型。

因为数组的长度是它们类型的一部分,数组的主要问题是它们大小固定,不能调整。

与数组类型不同,切片类型无需指定长度。切片的声明方式与数组相同,但没有数量元素。

切片是数组的包装器,它们不拥有任何数据——它们是对数组的引用。它们由指向数组的指针、长度及其容量(底层数组中的元素数)组成。

当您向没有足够容量的切片添加一个新值时 - 会创建一个具有更大容量的新数组,并将当前数组中的值复制到新数组中。这会导致不必要的内存分配和 CPU 周期。

为了更好地理解这一点,让我们看一下以下代码段:

func main() {
	var ints []int
	fmt.Printf("Address: %p, Length: %d, Capacity: %d, Values: %v\n", ints, len(ints), cap(ints), ints)
	for i := 0; i < 5; i++ {
		ints = append(ints, i)
		fmt.Printf("Address: %p, Length: %d, Capacity: %d, Values: %v\n", ints, len(ints), cap(ints), ints)
	}
}

结果

Address: 0x0, Length: 0, Capacity: 0, Values: []
Address: 0xc0000160d0, Length: 1, Capacity: 1, Values: [0]
Address: 0xc0000160e0, Length: 2, Capacity: 2, Values: [0 1]
Address: 0xc000020100, Length: 3, Capacity: 4, Values: [0 1 2]
Address: 0xc000020100, Length: 4, Capacity: 4, Values: [0 1 2 3]
Address: 0xc00001a180, Length: 5, Capacity: 8, Values: [0 1 2 3 4]

可以看到第一次声明数组var ints []int的时候,是不给它分配内存的,内存地址为0,大小和容量也都是0 后面每次扩容都是2的倍数,并且每次扩容内存地址都发生了改变。

当容量<1024 时会涨为之前的 2 倍,当容量>=1024时会以 1.25 倍增长。从 Go 1.18 开始,这已经变得更加线性

func BenchmarkPreallocAssign(b *testing.B) {
	ints := make([]int, b.N)
	for i := 0; i < b.N; i++ {
		ints[i] = i
	}
}
func BenchmarkAppend(b *testing.B) {
	var ints []int
	for i := 0; i < b.N; i++ {
		ints = append(ints, i)
	}
}

结果如下

goos: darwin
goarch: amd64
pkg: mygo
cpu: Intel(R) Core(TM) i7-9750H CPU @ 2.60GHz
BenchmarkPreallocAssign-12      321257311                3.609 ns/op           8 B/op          0 allocs/op
BenchmarkAppend-12              183322678               12.37 ns/op           42 B/op          0 allocs/op
PASS
ok      mygo    6.236s

由上述基准,我们可以得出结论,将值分配给预分配的切片和将值追加到切片之间是存在很大差异的。预先分配大小可以提速3倍多,而且内存分配也更小。

结构体中的字段顺序

以下面结构体为例

type Post struct {
    IsDraft     bool      // 1 byte
    Title       string    // 16 bytes
    ID          int64     // 8 bytes
    Description string    // 16 bytes
    IsDeleted   bool      // 1 byte
    Author      string    // 16 bytes
    CreatedAt   time.Time // 24 bytes
}
func main(){
    p := Post{}
    fmt.Println(unsafe.Sizeof(p))
}

上述的输出为 96 字节,而所有字段相加为 82 字节。那额外的 14 个字节是来自哪里呢?

现代 64 位 CPU 以 64 位(8 字节)的块获取数据

第一个周期占用 8 个字节,拉取“IsDraft”字段占用了 1 个字节并且产生 7 个未使用字节。它不能占用“一半”的字段。

第二个和第三个周期取 Title 字符串,第四个周期取 ID,依此类推。到取 IsDeleted 字段时,它使用 1 个字节并有 7 个字节未使用。

对内存节省的关键是按字段占用大小从上到下对字段进行排序。对上述结构进行排序,大小可减少到 88 个字节。最后两个字段 IsDraft 和 IsDeleted 被放在同一个块中,从而将未使用的字节数从 14 (2x7) 减少到 6 (1 x 6),在此过程中节省了 8 个字节。

type Post struct {
    CreatedAt   time.Time // 24 bytes
    Title       string    // 16 bytes
    Description string    // 16 bytes
    Author      string    // 16 bytes
    ID          int64     // 8 bytes
    IsDraft     bool      // 1 byte
    IsDeleted   bool      // 1 byte
}
func main(){
    p := Post{}
    fmt.Println(unsafe.Sizeof(p))
}

上述的输出为 88 字节

极端情况

type Post struct {
	IsDraft  bool  // 1 byte
	I64      int64 // 8 bytes
	IsDraft1 bool  // 1 byte
	I641     int64 // 8 bytes
	IsDraft2 bool  // 1 byte
	I642     int64 // 8 bytes
	IsDraft3 bool  // 1 byte
	I643     int64 // 8 bytes
	IsDraft4 bool  // 1 byte
	I644     int64 // 8 bytes
	IsDraft5 bool  // 1 byte
	I645     int64 // 8 bytes
	IsDraft6 bool  // 1 byte
	I646     int64 // 8 bytes
	IsDraft7 bool  // 1 byte
	I647     int64 // 8 bytes
}
type Post1 struct {
	IsDraft  bool  // 1 byte
	IsDraft1 bool  // 1 byte
	IsDraft2 bool  // 1 byte
	IsDraft3 bool  // 1 byte
	IsDraft4 bool  // 1 byte
	IsDraft5 bool  // 1 byte
	IsDraft6 bool  // 1 byte
	IsDraft7 bool  // 1 byte
	I64      int64 // 8 bytes
	I641     int64 // 8 bytes
	I642     int64 // 8 bytes
	I643     int64 // 8 bytes
	I644     int64 // 8 bytes
	I645     int64 // 8 bytes
	I646     int64 // 8 bytes
	I647     int64 // 8 bytes
}

第一个结构体占用128字节,第二个结构体占用72字节。节省空间:(128-72)/129=43.75%.

在 64 位架构上占用小于 8 字节的 Go 类型:

  • bool: 1 个字节
  • int8/uint8: 1 个字节
  • int16/uint16: 2 个字节
  • int32/uint32/rune: 4 个字节
  • float32: 4 个字节
  • byte: 1 个字节

使用 map[string]struct{} 而不是 map[string]bool

Go 没有内置的集合,通常使用 map[string]bool{} 表示集合。尽管它更具可读性(这非常重要),但将其作为一个集合使用是错误的,因为它具有两种状态(假/真)并且与空结构体相比使用了额外的内存。

空结构体 (struct{}) 是没有额外字段的结构类型,占用零字节的存储空间。

func BenchmarkBool(b *testing.B) {
	m := make(map[uint]bool)
	for i := uint(0); i < 100_000_000; i++ {
		m[i] = true
	}
}
func BenchmarkEmptyStruct(b *testing.B) {
	m := make(map[uint]struct{})
	for i := uint(0); i < 100_000_000; i++ {
		m[i] = struct{}{}
	}
}

结果

goos: darwin
goarch: amd64
pkg: mygo
cpu: Intel(R) Core(TM) i7-9750H CPU @ 2.60GHz
BenchmarkBool-12                       1        24052439603 ns/op       3766222824 B/op  3902813 allocs/op
BenchmarkEmptyStruct-12                1        22450213018 ns/op       3418648448 B/op  3903556 allocs/op
PASS
ok      mygo    46.937s

可以看到执行速度提升了一些,但是效果不太明显。

使用bool值有个好处是查找的时候更方便,从map中取值只需要判断一个值就行了,而使用空结构体则需要判断第二个值

m := make(map[string]bool{})
if m["key"]{
 // Do something
}
v := make(map[string]struct{}{})
if _, ok := v["key"]; ok{
    // Do something
}

参考

【1】Go 中简单的内存节省技巧

【2】Easy memory-saving tricks in Go

以上就是Go语言中节省内存技巧方法示例的详细内容,更多关于Go语言节省内存技巧的资料请关注好代码网其它相关文章!

您可能有感兴趣的文章
golang并发编程的如何实现

golang如何实现redis的延时消息队列功能示例

golang中range在slice和map遍历中的注意事项

Golang命令行进行debug调试操作

golang的空标识符理解