个人中心
gpt4 book ai didi

Golang 空map和未初始化map的注意事项说明

转载 作者：qq735679552 更新时间：2022-09-28 22:32:09 31 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章Golang 空map和未初始化map的注意事项说明由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

可以对未初始化的map进行取值，但取出来的东西是空:

?
1
2
var m1 map[string]string
fmt.Println(m1["1"])

不能对未初始化的map进行赋值，这样将会抛出一个异常:

panic: assignment to entry in nil map 。

?
1
2
var m1 map[string]string
m1["1"] = "1"

通过fmt打印map时，空map和nil map结果是一样的，都为map[]。所以，这个时候别断定map是空还是nil，而应该通过map == nil来判断.

补充：Golang清空map的两种方式及性能比拼 。

1、Golang中删除map的方法

  。

1、所有Go版本通用方法 。

?
1
2
3
4
5
a := make(map[string]int)
a["a"] = 1
a["b"] = 2
// clear all
a = make(map[string]int)

2. Go 1.11版本以上用法 。

通过Go的内部函数mapclear方法删除。这个函数并没有显示的调用方法，当你使用for循环遍历删除所有元素时，Go的编译器会优化成Go内部函数mapclear.

?
1
2
3
4
5
6
7
8
9
package main
func main() {
         m := make(map[byte]int)
         m[1] = 1
         m[2] = 2
         for k := range m {
             delete(m, k)
         }
}

把上述源代码直接编译成汇编（默认编译是会优化的）:

?
1
go tool compile -S map_clear.go

可以看到编译器把源码9行的for循环直接优化成了mapclear去删除所有元素。如下:

Golang 空map和未初始化map的注意事项说明

再来看看关闭优化后的结果:

?
1
go tool compile -l -N -S map_clear.go

关闭优化选项后，Go编译器直接通过循环遍历来删除map里面的元素.

Golang 空map和未初始化map的注意事项说明

具体的mapclear代码可以在go源码库中runtime/map.go文件中看到，代码如下:

?
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
26
27
28
29
30
31
32
33
34
35
36
37
// mapclear deletes all keys from a map.
func mapclear(t *maptype, h *hmap) {
     if raceenabled && h != nil {
         callerpc := getcallerpc()
         pc := funcPC(mapclear)
         racewritepc(unsafe.Pointer(h), callerpc, pc)
     }
     if h == nil || h.count == 0 {
         return
     }
     if h.flags&hashWriting != 0 {
         throw("concurrent map writes")
     }
     h.flags ^= hashWriting
     h.flags &^= sameSizeGrow
     h.oldbuckets = nil
     h.nevacuate = 0
     h.noverflow = 0
     h.count = 0
     // Keep the mapextra allocation but clear any extra information.
     if h.extra != nil {
         *h.extra = mapextra{}
     }
     // makeBucketArray clears the memory pointed to by h.buckets
     // and recovers any overflow buckets by generating them
     // as if h.buckets was newly alloced.
     _, nextOverflow := makeBucketArray(t, h.B, h.buckets)
     if nextOverflow != nil {
         // If overflow buckets are created then h.extra
         // will have been allocated during initial bucket creation.
         h.extra.nextOverflow = nextOverflow
     }
     if h.flags&hashWriting == 0 {
         throw("concurrent map writes")
     }
     h.flags &^= hashWriting
}

2、两种清空map方式性能比较

  。

1、先用benchmark的方式测一下两种方式 。

benchmark代码如下:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
func BenchmarkMakeNewMap(b *testing.B) {
     tmpMap := make(map[string]string, 10000)
     for i := 0; i < b.N; i++ {
         for j := 0; j < 10000; j++ {
             tmpMap["tmp"+strconv.Itoa(j)] = "tmp"
         }
         tmpMap = make(map[string]string, 10000)
     }
}
func BenchmarkDeleteMap(b *testing.B) {
     tmpMap := make(map[string]string, 10000)
     for i := 0; i < b.N; i++ {
         for j := 0; j < 10000; j++ {
             tmpMap["tmp"+strconv.Itoa(j)] = "tmp"
         }
         for k := range tmpMap {
             delete(tmpMap, k)
         }
     }
}

得到测试结果如下:

Golang 空map和未初始化map的注意事项说明

从测试结果上看，好像确实delete的方式效率更高，但是这个benchmark中总感觉没有测试到真正清空map的地方，中间穿插着put map的操作，我们用方法2再测一下.

2、单个UT测一下两种方式 。

UT代码如下:

测试过程中禁用了gc，避免gc对运行时间和内存产生干扰.

?
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
26
27
28
func TestMakeNewMap(t *testing.T) {
    debug.SetGCPercent(-1)
    var m runtime.MemStats
    tmpMap := make(map[string]string, 1000000)
    for j := 0; j < 1000000; j++ {
       tmpMap["tmp"+strconv.Itoa(j)] = "tmp"
    }
    start := time.Now()
    tmpMap = make(map[string]string, 1000000)
    fmt.Println(time.Since(start).Microseconds())
    runtime.ReadMemStats(&m)
    fmt.Printf("%d Kb\n", m.Alloc/1024)
}
func TestDeleteMap(t *testing.T) {
    debug.SetGCPercent(-1)
    var m runtime.MemStats
    tmpMap2 := make(map[string]string, 1000000)
    for j := 0; j < 1000000; j++ {
       tmpMap2["tmp"+strconv.Itoa(j)] = "tmp"
    }
    start := time.Now()
    for k := range tmpMap2 {
       delete(tmpMap2, k)
    }
    fmt.Println(time.Since(start).Microseconds())
    runtime.ReadMemStats(&m)
    fmt.Printf("%d Kb\n", m.Alloc/1024)
}

测试结果如下:

Golang 空map和未初始化map的注意事项说明

从测试结果上看，好像确实是make方式的效率更低，而且内存占用更多，但结果真的是这样吗?

我们把make方式的make map的大小改为0再试一下:

?
1
tmpMap = make(map[string]string)

得到如下结果，What？时间为0了，内存消耗也跟delete的方式一样:

Golang 空map和未初始化map的注意事项说明

我们把make方式的make map的大小改为10000再试一下:

?
1
tmpMap = make(map[string]string, 10000)

结果如下:

Golang 空map和未初始化map的注意事项说明

3、总结

  。

通过上面的测试，可以得出结论:

1、在map的数量级在10w以内的话，make方式会比delete方式速度更快，但是内存会消耗更多一点.

2、如果map数量级大于10w的话，delete的速度会更快，且内存消耗更少.

3、对于不再使用的map，直接使用make方式，长度为0清空更快.

以上为个人经验，希望能给大家一个参考，也希望大家多多支持我。如有错误或未考虑完全的地方，望不吝赐教.

原文链接：https://blog.csdn.net/qq_39920531/article/details/88103496 。

最后此篇关于Golang 空map和未初始化map的注意事项说明的文章就讲到这里了,如果你想了解更多关于Golang 空map和未初始化map的注意事项说明的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

31 4 0
文章推荐： Python还能这么玩之只用30行代码从excel提取个人值班表
文章推荐： Dapr 依赖的工具库包含「禁止使用」的许可证
文章推荐： Apple M1 上的 Linux 现可引导至 GNOME 桌面
文章推荐： 拒绝盗图!教你怎么用python给图片加水印
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
全站热门文章
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com