需要提醒你关于 golang 中 map 使用的几点注意事项

小知识,大挑战!本文正在参与“程序员必备小知识”创作活动

本文已参与 「掘力星计划」 ,赢取创作大礼包,挑战创作激励金

xdm,我是小魔童哪吒

日常的开发工作中,map 这个数据结构相信大家并不陌生,在 golang 里面,当然也有 map 这种类型

关于 map 的使用,还是有蛮多注意事项的,如果不清楚,这些事项,关键时候可能会踩坑,我们一起来演练一下吧

1 使用 map 记得初始化

写一个 demo

  • 定义一个 map[int]int 类型的变量 myMap , 不做初始化
  • 我们可以读取 myMap 的值,默认为 零值
  • 但是我们往没有初始化的 myMap 中写入值,程序就会 panic这里切记不要踩坑
func main(){

	var myMap map[int]int
	fmt.Println("myMap[1] ==  ",myMap[1])
}
复制代码

程序运行效果:

# go run main.go
myMap[1] ==   0
复制代码

代码中加入写操作:

func main(){

	var myMap map[int]int
	fmt.Println("myMap[1] ==  ",myMap[1])

	myMap[1] = 10

	fmt.Println("myMap[1] ==  ",myMap[1])
}
复制代码

程序运行效果:

# go run main.go
myMap[1] ==   0
panic: assignment to entry in nil map

goroutine 1 [running]:
main.main()
        /home/admin/golang_study/later_learning/map_test/main.go:20 +0xf3
exit status 2
复制代码

程序果然报 panic 了,我们实际工作中需要万分小心,对代码要有敬畏之心

2 map 的遍历是无序的

  • 定义一个 map[int]int 类型的 map,并初始化 5 个数
func main() {
	myMap := map[int]int{
		1: 1,
		2: 2,
		3: 3,
		4: 4,
		5: 5}

	for k := range myMap {
		fmt.Println(myMap[k])
	}
}
复制代码

程序运行效果:

# go run main.go
1
2
3
4
5
# go run main.go
5
1
2
3
4
# go run main.go
3
4
5
1
2
复制代码

运行上述代码 3 次,3 次结果都不一样,当然,也有可能 3 次结果的顺序都是一样的

因为 GO 中的 map 是基于哈希表实现的,所以遍历的时候是无序的

若我们需要清空这个 map ,那么我们可以直接将对应的 map 变量置为 nil 即可,例如

myMap = nil
复制代码

3 map 也可以是二维的

map 也是可以像数组一样是二维的,甚至是多维的都可以,主要是看我们的需求了

可是我们要注意,只是定义的时候类似二维数组,但是具体使用的时候还是有区别的

我们可以这样来操作二维数组

func main() {
	myMap := map[int]map[string]string{}
	myMap[0] = map[string]string{
		"name":"xiaomotong",
		"hobby":"program",
	}
	fmt.Println(myMap)
}
复制代码

程序运行效果:

# go run main.go
map[0:map[name:xiaomotong hobby:program]]
复制代码

我们不可以这样来操作二维数组

func main() {
	myMap := map[int]map[string]string{}
	myMap[0]["name"] = "xiaomotong"
	myMap[0]["hobby"] = "program"

	fmt.Println(myMap)
}
复制代码

程序运行效果:

# go run main.go
panic: assignment to entry in nil map

goroutine 1 [running]:
main.main()
        /home/admin/golang_study/later_learning/map_test/main.go:17 +0x7f
exit status 2
复制代码

原因很简单,程序报的 panic 日志已经说明了原因

是因为 myMap[0] 键 是 0 没问题,但是 值是 map[string]string 类型的,需要初始化才可以做写操作,这也是我们文章第一点所说到的

要是还是想按照上面这种写法来,那也很简单,加一句初始化就好了

func main() {
	myMap := map[int]map[string]string{}
	myMap[0] = map[string]string{}
    
	myMap[0]["name"] = "xiaomotong"
	myMap[0]["hobby"] = "program"

	fmt.Println(myMap)
}
复制代码

4 获取 map 的 key 最好使用这种方式

工作中,我们会存在需要获取一个 map 的所有 key 的方式,这个时候,我们一般是如何获取的呢,接触过反射的 xdm 肯定会说,这很简单呀,用反射一句话就搞定的事情,例如:

func main() {
	myMap := map[int]int{
		1: 1,
		2: 2,
		3: 3,
		4: 4,
		5: 5}

	myKey := reflect.ValueOf(myMap).MapKeys()

	for v :=range myKey{
		fmt.Println(v)
	}
}
复制代码

运行程序go run main.go,结果如下:

可是我们都知道,golang 中的 反射 reflect 确实写起来很简洁,但是效率真的非常低,我们平时使用最好还是使用下面这种方式

func main() {
	myMap := map[int]int{
		1: 1,
		2: 2,
		3: 3,
		4: 4,
		5: 5}

	myKey := make([]int,0,len(myMap))

	for k :=range myMap{
		myKey = append(myKey,myMap[k])
	}
	fmt.Println(myKey)
}
复制代码

这种编码方式,提前已经设置好 myKey 切片的容量和 map 的长度一致,则后续向 myKey 追加 key 的时候,就不会出现需要切片扩容的情况

程序运行效果:

# go run main.go
[2 3 4 5 1]
复制代码

我们可以看到,拿出来的 key ,也不是有序的

5 map 是并发不安全的 ,sync.Map 才是安全的

最后咱们再来模拟一下和验证一下 golang 的 map 不是安全

模拟 map 不安全的 demo, 需要多开一些协程才能模拟到效果,实验了一下,我这边模拟开 5 万 个协程

type T struct {
	myMap map[int]int
}

func (t *T) getValue(key int) int {
	return t.myMap[key]
}

func (t *T) setValue(key int, value int) {
	t.myMap[key] = value
}

func main() {

	ty := T{myMap: map[int]int{}}

	wg := sync.WaitGroup{}
	wg.Add(50000)
	for i := 0; i < 50000; i++ {

		go func(i int) {
			ty.setValue(i, i)
			fmt.Printf("get key == %d, value == %d \n", i, ty.getValue(i))
			wg.Done()
		}(i)
	}

	wg.Wait()
	fmt.Println("program over !!")
}
复制代码

运行程序变会报错如下信息:

# go run main.go
fatal error: concurrent map writes
...
复制代码

如果硬是要使用 map 的话, 也可以加上一把互斥锁就可以解决了

咱们只用修改上述的代码,结构体定义的位置,和 设置值的函数

type T struct {
	myMap map[int]int
	lock sync.RWMutex
}

func (t *T) setValue(key int, value int) {
	t.lock.Lock()
	defer t.lock.Unlock()
	t.myMap[key] = value
}
复制代码

为了检查方便,我们把程序输出的值打印到一个文件里面 go run main.go >> map.log

程序运行后,可以看到,真实打印的 key 对应数据,确实是有 5000 行,没毛病

image-20211016221550721

通过以上例子,就可以明白 golang 中的 map,确实不是并发安全的,需要加锁,才能做到并发安全 golang 也给我们提供了并发安全的 map ,sync.Map

sync.Map 的实现机制,简单来说,是他自身自带锁,因此可以控制并发安全

好了,今天就到这里,语言是好语言,工具也是好工具,我们需要实际用起来才能发挥他们的价值,不用的话一切都是白瞎

欢迎点赞,关注,收藏

朋友们,你的支持和鼓励,是我坚持分享,提高质量的动力

好了,本次就到这里

技术是开放的,我们的心态,更应是开放的。拥抱变化,向阳而生,努力向前行。

我是小魔童哪吒,欢迎点赞关注收藏,下次见~

猜你喜欢

转载自juejin.im/post/7019669136741498893

相关文章