目录

• 一、map数据结构
• 二、bucket数据结构
• 三、哈希冲突
• 四、负载因子
• 五、渐进式扩容
• • 1.扩容的前提条件
  • 2.增量扩容
  • 3.等量扩容
• 六、查找过程
• 七、插入过程
• 八、Map的value赋值
• 九、Map的遍历赋值

一、map数据结构

Golang的map使用哈希表作为底层实现，一个哈希表里可以有多个哈希表节点，也即bucket，而每个bucket就保存了map中的一个或一组键值对。

map数据结构由runtime/map.go:hmap定义：

type hmap struct {count     int // 当前保存的元素个数...B         uint8...buckets    unsafe.Pointer // bucket数组指针，数组的大小为2^B...
}

二、bucket数据结构

bucket数据结构由runtime/map.go:bmap定义：

type bmap struct {tophash [8]uint8 //存储哈希值的高8位data    byte[1]  //key value数据:key/key/key/.../value/value/value...overflow *bmap   //溢出bucket的地址
}

每个bucket可以存储8个键值对。

• tophash是个长度为8的数组，哈希值相同的键（准确的说是哈希值低位相同的键）存入当前bucket时会将哈希值的高位存储在该数组中，以便后续匹配。
• data区存放的是key-value数据，存放的顺序是key/key/key/…value/value/value,如此存放是为了节省字节对齐带来的空间浪费。
• overflow指针指向的是下一个bucket，据此将所有冲突的键连接起来。

注意：上述中data和overflow并不是在结构体中显示定义的，而是直接通过指针运算进行访问的。

三、哈希冲突

当有两个或以上数量的键被哈希到了同一个bucket时，我们称这些键发生了冲突。Go使用链地址法来解决键冲突。由于每个bucket可以存放8个键值对，所以同一个bucket存放超过8个键值对时就会再创建一个键值对，用类似链表的方式将bucket连接起来。

bucket数据结构指示下一个bucket的指针称为overflow bucket，意为当前bucket盛不下而溢出的部分。事实上哈希冲突并不是好事情，它降低了存取的效率，好的哈希算法可以保证哈希值的随机性，但冲突过多也是要控制的。

四、负载因子

负载因子用于衡量一个哈希表冲突情况，公式为：
负载因子=键数量/bucket数量

例如，对于一个bucket数量为4，包含4个键值对的哈希表来说，这个哈希表的负载因子为1。
哈希表需要将负载因子控制在合适的大小，超过其阀值需要进行rehash，也即键值对重新组织：

• 哈希因子过小，说明空间利用率低
• 哈希因子过大，说明冲突严重，存取效率低

每个哈希表的实现对负载因子容忍程度不同，比如Redis实现中负载因子大于1时就会触发rehash，而Go则在在负载因子达到6.5时才会触发rehash，因为Redis的每个bucket只能存1个键值对，而Go的bucket可能存8个键值对，所以Go可以容忍更高的负载因子。

五、渐进式扩容

1.扩容的前提条件

为了保证访问效率，当新元素将要添加进map时，都会检查是否需要扩容，扩容实际上是以空间换时间的手段。 触发扩容的条件有二个：

1.负载因子 > 6.5时，也即平均每个bucket存储的键值对达到6.5个。
2.overflow数量 > 2^15时，也即overflow数量超过32768时。

2.增量扩容

当负载因子过大时，就新建一个bucket，新的bucket长度是原来的2倍，然后旧bucket数据搬迁到新的bucket。 考虑到如果map存储了数以亿计的key-value，一次性搬迁将会造成比较大的延时，Go采用逐步搬迁策略，即每次访问map时都会触发一次搬迁，每次搬迁2个键值对。

当前map存储了7个键值对，只有1个bucket。此地负载因子为7。再次插入数据时将会触发扩容操作，扩容了之后再将新插入键写入新的bucket。

hmap数据结构中oldbuckets成员指身原bucket，而buckets指向了新申请的bucket。新的键值对被插入新的bucket中。 后续对map的访问操作会触发迁移，将oldbuckets中的键值对逐步的搬迁过来。当oldbuckets中的键值对全部搬迁完毕后，删除oldbuckets。

数据搬迁过程中原bucket中的键值对将存在于新bucket的前面，新插入的键值对将存在于新bucket的后面。

3.等量扩容

所谓等量扩容，实际上并不是扩大容量，buckets数量不变，重新做一遍类似增量扩容的搬迁动作，把松散的键值对重新排列一次，以使bucket的使用率更高，进而保证更快的存取。 在极端场景下，比如不断地增删，而键值对正好集中在一小部分的bucket，这样会造成overflow的bucket数量增多，但负载因子又不高，从而无法执行增量搬迁的情况，如下图所示：

上图可见，overflow的bucket中大部分是空的，访问效率会很差。此时进行一次等量扩容，即buckets数量不变，经过重新组织后overflow的bucket数量会减少，即节省了空间又会提高访问效率。

六、查找过程

查找过程如下：

1.根据key值算出哈希值
2.取哈希值低位与hmap.B取模确定bucket位置
3.取哈希值高位在tophash数组中查询
4.如果tophash[i]中存储值与哈希值相等，则去找到该bucket中的key值进行比较
5.当前bucket没有找到，则继续从下个overflow的bucket中查找。
6.如果当前处于搬迁过程，则优先从oldbuckets查找
注：如果查找不到，也不会返回空值，而是返回相应类型的0值。

七、插入过程

新元素插入过程如下：

1.根据key值算出哈希值
2.取哈希值低位与hmap.B取模确定bucket位置
3.查找该key是否已经存在，如果存在则直接更新值
4.如果没找到将key，将key插入

八、Map的value赋值

package mainimport "fmt"type Student struct {Name string
}var list map[string]Studentfunc main() {list = make(map[string]Student)student := Student{"Aceld"}list["student"] = studentlist["student"].Name = "LDB"fmt.Println(list["student"])
}

结果：

编译失败，
./test7.go:18:23: cannot assign to struct field list["student"].Name in map

分析：
map[string]Student 的value是一个Student结构值，所以当list[“student”] = student,是一个值拷贝过程。而list[“student”]则是一个值引用。那么值引用的特点是只读。所以对list[“student”].Name = "LDB"的修改是不允许的。

方法一：

package mainimport "fmt"type Student struct {Name string
}var list map[string]Studentfunc main() {list = make(map[string]Student)student := Student{"Aceld"}list["student"] = student//list["student"].Name = "LDB"/*方法1:*/tmpStudent := list["student"]tmpStudent.Name = "LDB"list["student"] = tmpStudentfmt.Println(list["student"])
}

其中：

    /*方法1:*/tmpStudent := list["student"]tmpStudent.Name = "LDB"list["student"] = tmpStudent

是先做一次值拷贝，做出一个tmpStudent副本,然后修改该副本，然后再次发生一次值拷贝复制回去，list[“student”] = tmpStudent,但是这种会在整体过程中发生2次结构体值拷贝，性能很差。

方法二：

package mainimport "fmt"type Student struct {Name string
}var list map[string]*Studentfunc main() {list = make(map[string]*Student)student := Student{"Aceld"}list["student"] = &studentlist["student"].Name = "LDB"fmt.Println(list["student"])
}

我们将map的类型的value由Student值，改成Student指针。

var list map[string]*Student

这样，我们实际上每次修改的都是指针所指向的Student空间，指针本身是常指针，不能修改，只读属性，但是指向的Student是可以随便修改的，而且这里并不需要值拷贝。只是一个指针的赋值。

九、Map的遍历赋值

package mainimport ("fmt"
)type student struct {Name stringAge  int
}func main() {//定义mapm := make(map[string]*student)//定义student数组stus := []student{{Name: "zhou", Age: 24},{Name: "li", Age: 23},{Name: "wang", Age: 22},}//将数组依次添加到map中for _, stu := range stus {m[stu.Name] = &stu}//打印mapfor k,v := range m {fmt.Println(k ,"=>", v.Name)}
}

结果如下：

zhou => wang
li => wang
wang => wang

分析：

foreach中，stu是结构体的一个拷贝副本，所以m[stu.Name]=&stu实际上一致指向同一个指针， 最终该指针的值为遍历的最后一个struct的值拷贝。

正确写法：

package mainimport ("fmt"
)type student struct {Name stringAge  int
}func main() {//定义mapm := make(map[string]*student)//定义student数组stus := []student{{Name: "zhou", Age: 24},{Name: "li", Age: 23},{Name: "wang", Age: 22},}// 遍历结构体数组，依次赋值给mapfor i := 0; i < len(stus); i++  {m[stus[i].Name] = &stus[i]}//打印mapfor k,v := range m {fmt.Println(k ,"=>", v.Name)}
}