Go语言复合类型map的基本操作

　　插入新键值对
　　面对一个非 nil 的 map 类型变量，我们可以在其中插入符合 map 类型定义的任意新键值对。插入新键值对的方式很简单，我们只需要把 value 赋值给 map 中对应的 key 就可以了：  m := make(map[int]string) m[1] = ＂value1＂ m[2] = ＂value2＂ m[3] = ＂value3＂
　　Go 运行时会负责 map 变量内部的内存管理，因此除非是系统内存耗尽，我们可以不用担心向 map 中插入新数据的数量和执行结果。
　　如果我们插入新键值对的时候，某个 key 已经存在于 map 中了，那我们的插入操作就会用新值覆盖旧值：  m := map[string]int {   ＂key1＂ : 1,   ＂key2＂ : 2, }  m[＂key1＂] = 11 // 11会覆盖掉＂key1＂对应的旧值1 m[＂key3＂] = 3  // 此时m为map[key1:11 key2:2 key3:3]
　　获取键值对数量
　　想知道当前 map 类型变量中已经建立了多少个键值对，那我们可以怎么做呢？和切片一样，map 类型也可以通过内置函数 len，获取当前变量已经存储的键值对数量：  m := map[string]int {   ＂key1＂ : 1,   ＂key2＂ : 2, }  fmt.Println(len(m)) // 2 m[＂key3＂] = 3   fmt.Println(len(m)) // 3
　　查找和数据读取
　　和写入相比，map 类型更多用在查找和数据读取场合。  m := make(map[string]int) v := m[＂key1＂]
　　第二行代码在语法上好像并没有什么不当之处，但其实通过这行语句，我们还是无法确定键 key1 是否真实存在于 map 中。这是因为，当我们尝试去获取一个键对应的值的时候，如果这个键在 map 中并不存在，我们也会得到一个值，这个值是 value 元素类型的零值。
　　Go 语言的 map 类型支持通过用一种名为＂comma ok＂的惯用法，进行对某个 key 的查询。接下来我们就用＂comma ok＂惯用法改造一下上面的代码：  m := make(map[string]int) v, ok := m[＂key1＂] if !ok {     // ＂key1＂不在map中 }  // ＂key1＂在map中，v将被赋予＂key1＂键对应的value
　　这里我们通过了一个布尔类型变量 ok，来判断键＂key1＂是否存在于 map 中。如果存在，变量 v 就会被正确地赋值为键＂key1＂对应的 value。一定要记住：在 Go 语言中，请使用＂comma ok＂惯用法对 map 进行键查找和键值读取操作。
　　删除数据
　　在 Go 中，我们需要借助内置函数 delete 来从 map 中删除数据。使用 delete 函数的情况下，传入的第一个参数是我们的 map 类型变量，第二个参数就是我们想要删除的键。  m := map[string]int {   ＂key1＂ : 1,   ＂key2＂ : 2, }  fmt.Println(m) // map[key1:1 key2:2] delete(m, ＂key2＂) // 删除＂key2＂ fmt.Println(m) // map[key1:1]
　　delete 函数是从 map 中删除键的唯一方法。即便传给 delete 的键在 map 中并不存在，delete 函数的执行也不会失败，更不会抛出运行时的异常。
　　遍历 map 中的键值数据
　　在 Go 中，遍历 map 的键值对只有一种方法，那就是像对待切片那样通过 for range 语句对 map 数据进行遍历。  package main    import ＂fmt＂  func main() {     m := map[int]int{         1: 11,         2: 12,         3: 13,     }      fmt.Printf(＂{ ＂)     for k, v := range m {         fmt.Printf(＂[%d, %d] ＂, k, v)     }     fmt.Printf(＂} ＂) }
　　通过 for range 遍历 map 变量 m，每次迭代都会返回一个键值对，其中键存在于变量 k 中，它对应的值存储在变量 v 中。
　　对同一 map 做多次遍历的时候，每次遍历元素的次序都不相同。这是 Go 语言 map 类型的一个重要特点，也是很容易让 Go 初学者掉入坑中的一个地方。所以这里你一定要记住：程序逻辑千万不要依赖遍历 map 所得到的的元素次序。
　　map 的内部实现
　　Go 运行时使用一张哈希表来实现抽象的 map 类型。运行时实现了 map 类型操作的所有功能，包括查找、插入、删除等。在编译阶段，Go 编译器会将 Go 语法层面的 map 操作，重写成运行时对应的函数调用。大致的对应关系是这样的：  // 创建map类型变量实例 m := make(map[keyType]valType, capacityhint) → m := runtime.makemap(maptype, capacityhint, m)  // 插入新键值对或给键重新赋值 m[＂key＂] = ＂value＂ → v := runtime.mapassign(maptype, m, ＂key＂) v是用于后续存储value的空间的地址  // 获取某键的值  v := m[＂key＂]      → v := runtime.mapaccess1(maptype, m, ＂key＂) v, ok := m[＂key＂]  → v, ok := runtime.mapaccess2(maptype, m, ＂key＂)  // 删除某键 delete(m, ＂key＂)   → runtime.mapdelete(maptype, m, ＂key＂)
　　这是 map 类型在 Go 运行时层实现的示意图：
　　和切片的运行时表示图相比，map 的实现示意图显然要复杂得多，我们重点关注一个 map 变量在初始状态、进行键值对操作后，以及在并发场景下的 Go 运行时层的实现原理。
　　1、初始状态
　　从图中我们可以看到，与语法层面 map 类型变量（m）一一对应的是 *runtime.hmap 的实例，即 runtime.hmap 类型的指针，也就是我们前面在讲解 map 类型变量传递开销时提到的 map 类型的描述符。hmap 类型是 map 类型的头部结构（header），它存储了后续 map 类型操作所需的所有信息，包括：
　　真正用来存储键值对数据的是桶，也就是 bucket，每个 bucket 中存储的是 Hash 值低 bit 位数值相同的元素，默认的元素个数为 BUCKETSIZE（值为 8，Go 1.17 版本中在 $GOROOT/src/cmd/compile/internal/reflectdata/reflect.go 中定义，与 runtime/map.go 中常量 bucketCnt 保持一致）。当某个 bucket（比如 buckets[0]) 的 8 个空槽 slot）都填满了，且 map 尚未达到扩容的条件的情况下，运行时会建立 overflow bucket，并将这个 overflow bucket 挂在上面 bucket（如 buckets[0]）末尾的 overflow 指针上，这样两个 buckets 形成了一个链表结构，直到下一次 map 扩容之前，这个结构都会一直存在。
　　从图中我们可以看到，每个 bucket 由三部分组成，从上到下分别是 tophash 区域、key 存储区域和 value 存储区域。
　　tophash 区域：
　　当我们向 map 插入一条数据，或者是从 map 按 key 查询数据的时候，运行时都会使用哈希函数对 key 做哈希运算，并获得一个哈希值（hashcode）。这个 hashcode 非常关键，运行时会把 hashcode＂一分为二＂来看待，其中低位区的值用于选定 bucket，高位区的值用于在某个 bucket 中确定 key 的位置。如下图：
　　每个 bucket 的 tophash 区域其实是用来快速定位 key 位置的，这样就避免了逐个 key 进行比较这种代价较大的操作。
　　key 存储区域：
　　tophash 区域下面是一块连续的内存区域，存储的是这个 bucket 承载的所有 key 数据。运行时在分配 bucket 的时候需要知道 key 的 Size。那么运行时是如何知道 key 的 size 的呢？当我们声明一个 map 类型变量，比如 var m map[string]int 时，Go 运行时就会为这个变量对应的特定 map 类型，生成一个 runtime.maptype 实例。如果这个实例已经存在，就会直接复用。maptype 实例的结构是这样的：  type maptype struct {     typ        _type     key        *_type     elem       *_type     bucket     *_type // internal type representing a hash bucket     keysize    uint8  // size of key slot     elemsize   uint8  // size of elem slot     bucketsize uint16 // size of bucket     flags      uint32 }
　　这个实例包含了我们需要的 map 类型中的所有＂元信息＂。我们前面提到过，编译器会把语法层面的 map 操作重写成运行时对应的函数调用，这些运行时函数都有一个共同的特点，那就是第一个参数都是 maptype 指针类型的参数。Go 运行时就是利用 maptype 参数中的信息确定 key 的类型和大小的。map 所用的 hash 函数也存放在 maptype.key.alg.hash(key, hmap.hash0) 中。同时 maptype 的存在也让 Go 中所有 map 类型都共享一套运行时 map 操作函数，而不是像 C++ 那样为每种 map 类型创建一套 map 操作函数，这样就节省了对最终二进制文件空间的占用。
　　value 存储区域：
　　这个区域存储的是 key 对应的 value。和 key 一样，这个区域的创建也是得到了 maptype 中信息的帮助。Go 运行时采用了把 key 和 value 分开存储的方式，而不是采用一个 kv 接着一个 kv 的 kv 紧邻方式存储，这带来的其实是算法上的复杂性，但却减少了因内存对齐带来的内存浪费。
　　我们以 map[int8]int64 为例，看看下面的存储空间利用率对比图：
　　当前 Go 运行时使用的方案内存利用效率很高，而 kv 紧邻存储的方案在 map[int8]int64 这样的例子中内存浪费十分严重，它的内存利用率是 72/128=56.25%，有近一半的空间都浪费掉了。
　　如果 key 或 value 的数据长度大于一定数值，那么运行时不会在 bucket 中直接存储数据，而是会存储 key 或 value 数据的指针。目前 Go 运行时定义的最大 key 和 value 的长度是这样的：  // $GOROOT/src/runtime/map.go const (     maxKeySize  = 128     maxElemSize = 128 )
　　map 扩容
　　map 会对底层使用的内存进行自动管理。因此，在使用过程中，当插入元素个数超出一定数值后，map 一定会存在自动扩容的问题，也就是怎么扩充 bucket 的数量，并重新在 bucket 间均衡分配数据的问题。
　　Go 运行时的 map 实现中引入了一个 LoadFactor（负载因子），当 count > LoadFactor * 2^B 或 overflow bucket 过多时，运行时会自动对 map 进行扩容。
　　这两方面原因导致的扩容，在运行时的操作其实是不一样的。如果是因为 overflow bucket 过多导致的＂扩容＂，实际上运行时会新建一个和现有规模一样的 bucket 数组，然后在 assign 和 delete 时做排空和迁移。
　　map 与并发
　　从上面的实现原理来看，充当 map 描述符角色的 hmap 实例自身是有状态的（hmap.flags），而且对状态的读写是没有并发保护的。所以说 map 实例不是并发写安全的，也不支持并发读写。如果我们对 map 实例进行并发读写，程序运行时就会抛出异常。你可以看看下面这个并发读写 map 的例子：  package main  import (     ＂fmt＂     ＂time＂ )  func doIteration(m map[int]int) {     for k, v := range m {         _ = fmt.Sprintf(＂[%d, %d] ＂, k, v)     } }  func doWrite(m map[int]int) {     for k, v := range m {         m[k] = v + 1     } }  func main() {     m := map[int]int{         1: 11,         2: 12,         3: 13,     }      go func() {         for i := 0; i < 1000; i++ {             doIteration(m)         }     }()      go func() {         for i := 0; i < 1000; i++ {             doWrite(m)         }     }()      time.Sleep(5 * time.Second) }
　　我们仅仅是进行并发读，map 是没有问题的。而且，Go 1.9 版本中引入了支持并发写安全的 sync.Map 类型，可以在并发读写的场景下替换掉 map。
　　考虑到 map 可以自动扩容，map 中数据元素的 value 位置可能在这一过程中发生变化，所以 Go 不允许获取 map 中 value 的地址，这个约束是在编译期间就生效的。