我很好奇
map
和slice
的内存消耗,所以我写了一个程序来比较它们的大小。我通过unsafe.Sizeof(s)
得到了内存大小,但显然这是错误的,因为当我改变大小时,输出是相同的。
func getSlice(size int) []int {
t := time.Now()
s := make([]int, size*2)
for i := 0; i < size; i++ {
index := i << 1
s[index] = i
s[index+1] = i
}
fmt.Println("slice time cost: ", time.Since(t))
return s
}
func getMap(size int) map[int]int {
t := time.Now()
m := make(map[int]int, size)
for i := 0; i < size; i++ {
m[i] = i
}
fmt.Println("map time cost: ", time.Since(t))
return m
}
func TestMem(t *testing.T) {
size := 1000
s := getSlice(size)
m := getMap(size)
fmt.Printf("slice size: %d\n", unsafe.Sizeof(s))
fmt.Printf("map size: %d\n", unsafe.Sizeof(m))
}
unsafe.SizeOf()
和reflect.Type.Size()
仅返回传递值的大小,而不递归遍历数据结构并添加指向值的大小。
reflect.SliceHeader
,并且由于我们知道它引用了一个支持数组,因此我们可以轻松地“手动”计算其大小,例如:
s := make([]int32, 1000)
fmt.Println("Size of []int32:", unsafe.Sizeof(s))
fmt.Println("Size of [1000]int32:", unsafe.Sizeof([1000]int32{}))
fmt.Println("Real size of s:", unsafe.Sizeof(s)+unsafe.Sizeof([1000]int32{}))
输出(在Go Playground上尝试一下):
Size of []int32: 12
Size of [1000]int32: 4000
Real size of s: 4012
地图是更复杂的数据结构,我不会详细介绍,但请查看这个问题+答案:Golang:计算地图的内存占用(或字节长度)
如果你想要“真实”的数字,你可以利用 Go 的测试工具,它也可以执行内存基准测试。传递
-benchmem
参数,并在基准函数内部仅分配您想要测量的内存:
func BenchmarkSlice100(b *testing.B) {
for i := 0; i < b.N; i++ { getSlice(100) }
}
func BenchmarkSlice1000(b *testing.B) {
for i := 0; i < b.N; i++ { getSlice(1000) }
}
func BenchmarkSlice10000(b *testing.B) {
for i := 0; i < b.N; i++ { getSlice(10000) }
}
func BenchmarkMap100(b *testing.B) {
for i := 0; i < b.N; i++ { getMap(100) }
}
func BenchmarkMap1000(b *testing.B) {
for i := 0; i < b.N; i++ { getMap(1000) }
}
func BenchmarkMap10000(b *testing.B) {
for i := 0; i < b.N; i++ { getMap(10000) }
}
(当然从
getSlice()
和 getMap()
中删除计时和打印调用。)
与
一起跑步go test -bench . -benchmem
输出是:
BenchmarkSlice100-4 3000000 471 ns/op 1792 B/op 1 allocs/op
BenchmarkSlice1000-4 300000 3944 ns/op 16384 B/op 1 allocs/op
BenchmarkSlice10000-4 50000 39293 ns/op 163840 B/op 1 allocs/op
BenchmarkMap100-4 200000 11651 ns/op 2843 B/op 9 allocs/op
BenchmarkMap1000-4 10000 111040 ns/op 41823 B/op 12 allocs/op
BenchmarkMap10000-4 1000 1152011 ns/op 315450 B/op 135 allocs/op
B/op
值告诉您每个操作分配了多少字节。 allocs/op
告诉每个操作发生了多少(不同的)内存分配。
在我的 64 位架构上(其中
int
的大小为 8 字节),它表明具有 2000 个元素的切片的大小约为 16 KB(与 2000 * 8 字节一致)。包含 1000 个 int-int
对的地图大约需要分配 42 KB。
这会产生一些编组开销,但我发现这是运行时获取 go 中值的大小的最简单方法。对于我的需求,编组开销不是一个大问题,所以我走了这条路。
func getRealSizeOf(v interface{}) (int, error) {
b := new(bytes.Buffer)
if err := gob.NewEncoder(b).Encode(v); err != nil {
return 0, err
}
return b.Len(), nil
}
这是正确的方法,使用
unsafe.Sizeof(s)
。只是对于给定类型(整数、字符串等),结果将保持不变,而忽略确切的值。
Sizeof 接受任何类型的表达式 x 并返回假设变量 v 的大小(以字节为单位),就好像 v 是通过 var v = x 声明的一样。该大小不包括 x 可能引用的任何内存。例如,如果 x 是切片,则 Sizeof 返回切片描述符的大小,而不是切片引用的内存的大小。
参考这里。
更新:
您可以使用编组,然后将以字节为单位的值表示与
Size()
进行比较。只需将数据转换为字节字符串即可。