Go语言map使用和并发安全

Posted 2022-08-01 行走的皮卡丘

Go语言map使用和并发安全

• 1 map使用
• • 1.1 map定义
  • 1.2 map的使用和概念
  • 1.3 map的容量
  • 1.4 map的使用
  • • 1.4.1 map的遍历
    • 1.4.2 map的删除和断言
  • 1.5 map的坑
• 2 并发安全
• • 2.1 不安全原因
  • 2.2 解决方案

1 map使用

1.1 map定义

map是一种无序的集合，对应的key （索引）会对应一个value（值），所以这个结构也称为关联数组或字典。

map在其他语言中hash、hash table等

var mapname map[keytype]valuetype

• mapname 为 map 的变量名。
• keytype 为键类型。
• valuetype 是键对应的值类型。

1.2 map的使用和概念

map是引用类型，未初始化的map是nil

package main

import "fmt"

func main() 
	var maplist map[string]int
	maplist["one"] = 1
	fmt.Println(maplist)

//报错:panic: assignment to entry in nil map
//map需要先初始化内存后使用

正确做法：

package main

import "fmt"

func main() 
	var maplist map[string]int
	maplist = map[string]int"one": 1, "two": 2
	maplist["three"] = 3
	fmt.Println(maplist)

//map[one:1 three:3 two:2]

当然也可以这样子：

package main

import "fmt"

func main() 
	maplist := make(map[string]int)//初始化内存了，想赋值就赋值
	maplist["three"] = 3
	fmt.Println(maplist)

map必须先初始化内存，后使用，也就是需要make一下，或者直接赋值一个空map

maplist := map[string]int
fmt.Println(maplist)

1.3 map的容量

和数组不同的是，map可以根据新增的key-value动态的伸缩，因此不存在固定长度或者最大限制，但是也可以选择初始化容量的值

maplist := make(map[string]float, 100)

出于性能考虑，对于大的map或者快速扩张的map，最好先标明

用切片作为map的值

maplist1 := make(map[int][]int)
maplist2 := make(map[int]*[]int)

golang里的类型使用灵活，也可以任意组合，map里的值可以是struct，也可以是int、string、甚至是切片、数组。

1.4 map的使用

1.4.1 map的遍历

scene := make(map[string]int)

scene["route"] = 66
scene["brazil"] = 4
scene["china"] = 960

for k, v := range scene 
    fmt.Println(k, v)

1.4.2 map的删除和断言

package main

import "fmt"

func main() 
	maplist := make(map[string]int)

	// 准备map数据
	maplist["LYY"] = 66
	maplist["520"] = 4
	maplist["666"] = 960

	delete(maplist, "666")

	for k, v := range maplist 
		fmt.Println(k, v)
	

1.5 map的坑

package main

import "fmt"

func main() 
	m := map[int]struct
		1: ,
		2: ,
		3: ,
		4: ,
		5: ,
	

	for k := range m 
		fmt.Println(k)
	

//没有设置v值的时候，map的遍历是随机的，起始遍历是个随机值

执行第一次：

执行第二次：

注意：map在增加值、删除时需要加互斥锁

2 并发安全

Go语言中的 map 在并发情况下，只读是线程安全的，同时读写是线程不安全的。

2.1 不安全原因

官网解释：同一个变量在多个goroutine中访问需要保证其安全性。

package main
import (
	"fmt"
	"time"
)
var TestMap map[string]string
func init() 
	TestMap = make(map[string]string, 1)

func main() 
	for i := 0; i < 1000; i++ 
		go Write("aaa")
		go Read("aaa")
		go Write("bbb")
		go Read("bbb")
	
	time.Sleep(5 * time.Second)

func Read(key string) 
	fmt.Println(TestMap[key])

func Write(key string) 
	TestMap[key] = key

//报错 fatal error: concurrent map writes

原因：因为map变量为 指针类型变量，并发写时，多个协程同时操作一个内存，类似于多线程操作同一个资源会发生竞争关系，共享资源会遭到破坏，因此golang 出于安全的考虑，抛出致命错误：fatal error: concurrent map writes。

2.2 解决方案

（1）在写操作的时候增加锁，删除时候除了加锁外，还需要增加断言避免出现错误

package main

import (
	"fmt"
	"sync"
)

func main() 
	var lock sync.Mutex
	var maplist map[string]int
	maplist = map[string]int"one": 1, "two": 2
	lock.Lock()
	maplist["three"] = 3
	lock.Unlock()
	fmt.Println(maplist)

执行结果：

（2）sync.Map包

package main

import (
	"fmt"
	"sync"
)

func main() 
	m := sync.Map //或者 var mm sync.Map
	m.Store("a", 1)
	m.Store("b", 2)
	m.Store("c", 3)                             //插入数据
	fmt.Println(m.Load("a"))                    //读取数据
	m.Range(func(key, value interface) bool  //遍历
		fmt.Println(key, value)
		return true
	)

执行结果：

我们称其为并发安全的map。