脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 脚本专栏 → Golang → Golang空map与未初始化map

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

 更新时间：2021年04月29日 10:03:33   作者：菌菇  
这篇文章主要介绍了Golang 空map和未初始化map的注意事项说明，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧

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

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

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

panic: assignment to entry in nil map

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

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

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

一、Golang中删除map的方法

1、所有Go版本通用方法

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。

package main
func main() {
        m := make(map[byte]int)
        m[1] = 1
        m[2] = 2
        for k := range m {
	        delete(m, k)
        }
}

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

go tool compile -S map_clear.go

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

在这里插入图片描述

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

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

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

在这里插入图片描述

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

// 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
}

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

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

benchmark代码如下：

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)
		}
	}
}

得到测试结果如下：

在这里插入图片描述

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

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

UT代码如下：

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

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)
}

测试结果如下：

在这里插入图片描述

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

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

tmpMap = make(map[string]string)

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

在这里插入图片描述

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

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

结果如下：

在这里插入图片描述

三、总结

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

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

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

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

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

您可能感兴趣的文章:

相关文章

  • Golang基于sync.Once实现单例的操作代码

    Golang基于sync.Once实现单例的操作代码

    这篇文章主要介绍了golang实现单例的操作代码,本文介绍基于sync.Once的方式来实现单例，熟练掌握这种模式，并理解其底层原理，对大部分人来讲已经完全够用了，需要的朋友可以参考下
    2022-10-10
  • Go初学者踩坑之go mod init与自定义包的使用

    Go初学者踩坑之go mod init与自定义包的使用

    go mod是go的一个模块管理工具,用来代替传统的GOPATH方案,下面这篇文章主要给大家介绍了关于Go初学者踩坑之go mod init与自定义包的使用,需要的朋友可以参考下
    2022-10-10
  • Golang加密解密之RSA（附带php）

    Golang加密解密之RSA（附带php）

    安全总是很重要的，各个语言对于通用的加密算法都会有实现。本文先是对RSA算法进行了简单介绍，后才进行介绍如何用Go实现RSA的加密解密，下面一起来看看吧。
    2016-08-08
  • Go 分布式链路追踪实现原理解析

    Go 分布式链路追踪实现原理解析

    分布式链路追踪作为解决分布式应用可观测问题的重要技术，愈发成为分布式应用不可缺少的基础设施，本文将详细介绍分布式链路的核心概念、架构原理和相关开源标准协议，并分享我们在实现无侵入 Go 采集 Sdk 方面的一些实践,需要的朋友可以参考下
    2022-06-06
  • Go语言使用组合的思想实现继承

    Go语言使用组合的思想实现继承

    这篇文章主要为大家详细介绍了在 Go 里面如何使用组合的思想实现“继承”，文中的示例代码讲解详细，对我们学习Go语言有一定的帮助，需要的可以了解一下
    2022-12-12
  • goland中文件头自动注释的操作

    goland中文件头自动注释的操作

    这篇文章主要介绍了goland中文件头自动注释的操作，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
    2020-12-12
  • Go并发控制WaitGroup的使用场景分析

    Go并发控制WaitGroup的使用场景分析

    WaitGroup，可理解为Wait-Goroutine-Group，即等待一组goroutine结束，本文通过具体场景结合实际例子给大家介绍使用WaitGroup控制的实现方法，感兴趣的朋友跟随小编一起看看吧
    2021-07-07
  • golang中defer执行时机的案例分析

    golang中defer执行时机的案例分析

    这篇文章主要来通过一些案例和大家一起探讨一下golang中defer的执行时机,文中的示例代码讲解详细,对我们深入了解golang有一定的帮助,感兴趣的可以跟随小编一起学习一下
    2023-11-11
  • 详解Golang time包中的结构体time.Ticker

    详解Golang time包中的结构体time.Ticker

    在日常开发过程中,会频繁遇到对时间进行操作的场景,使用 Golang 中的 time 包可以很方便地实现对时间的相关操作,接下来的几篇文章会详细讲解 time 包,本文讲解一下 time 包中的结构体 time.Ticker,需要的朋友可以参考下
    2023-08-08
  • Golang中常用的语法糖分享

    Golang中常用的语法糖分享

    语法糖，也称糖语法，是由英国计算机科学家彼得·兰丁提出的，用于表示编程语言中的某种类型的语法，这些语法不会影响功能，但使用起来却很方便，本文就来看看Golang中常用的语法糖有哪些吧
    2023-05-05

最新评论