Go专家编程-常见数据结构实现原理

本文为《Go专家编程》读书笔记~

---

---

常见数据结构实现原理

本章主要介绍常见的数据结构，比如channel、slice、map等，通过对其底层实现原理的分析，来加深认识。

1.1 chan

1.前言

channel是Golang在语言层面提供的goroutine间的通信方式，比Unix管道更易用也更轻便。channel主要用于进 程内各goroutine间通信，如果需要跨进程通信，建议使用分布式系统的方法来解决。

2.chan数据结构

从数据结构可以看出channel由队列、类型信息、goroutine等待队列组成

1. type hchan struct { 
2.  qcount uint // 当前队列中剩余元素个数 
3.  dataqsiz uint // 环形队列长度，即可以存放的元素个数 
4.  buf unsafe.Pointer // 环形队列指针 
5.  elemsize uint16 // 每个元素的大小 
6.  closed uint32 // 标识关闭状态 
7.  elemtype *_type // 元素类型 
8.  sendx uint // 队列下标，指示元素写入时存放到队列中的位置 
9.  recvx uint // 队列下标，指示元素从队列的该位置读出 
10.  recvq waitq // 等待读消息的goroutine队列 
11.  sendq waitq // 等待写消息的goroutine队列 
12. lock mutex // 互斥锁，chan不允许并发读写 
13. }

环形队列

chan内部实现了一个环形队列作为其缓冲区，队列的长度是创建chan时指定的。

等待队列

从channel读数据，如果channel缓冲区为空或者没有缓冲区，当前goroutine会被阻塞。
向channel写数据，如 果channel缓冲区已满或者没有缓冲区，当前goroutine会被阻塞。

被阻塞的goroutine将会挂在channel的等待队列中：

• 因读阻塞的goroutine会被向channel写入数据的goroutine唤醒；
• 因写阻塞的goroutine会被从channel读数据的goroutine唤醒；

一般情况下recvq和sendq至少有一个为空。只有一个例外，那就是同一个goroutine使用select语句向 channel一边写数据，一边读数据。

类型信息

一个channel只能传递一种类型的值，类型信息存储在hchan数据结构中。

锁

一个channel同时仅允许被一个goroutine读写。

3.channel读写

向channel写数据

向一个channel中写数据简单过程如下：

1. 如果等待接收队列recvq不为空，说明缓冲区中没有数据或者没有缓冲区，此时直接从recvq取出G,并把数据 写入，最后把该G唤醒，结束发送过程；
2. 如果缓冲区中有空余位置，将数据写入缓冲区，结束发送过程；
3. 如果缓冲区中没有空余位置，将待发送数据写入G，将当前G加入sendq，进入睡眠，等待被读goroutine唤醒；
   

从channel读数据

关闭channel

关闭channel时会把recvq中的G全部唤醒，本该写入G的数据位置为nil。把sendq中的G全部唤醒，但这些G会 panic。

除此之外，panic出现的常见场景还有：

1. 关闭值为nil的channel
2. 关闭已经被关闭的channel
3. 向已经关闭的channel写数据

1.2 slice

Slice又称动态数组，依托数组实现，可以方便的进行扩容、传递等
从数据结构看Slice很清晰, array指针指向底层数组，len表示切片长度，cap表示底层数组容量。

如果切片的容量小于1024个元素，那么扩容的时候slice的cap就翻番，乘以2；一旦元素个数超过1024个元素，增长因子就变成1.25，即每次增加原来容量的四分之一。
如果扩容之后，还没有触及原数组的容量，那么，切片中的指针指向的位置，就还是原数组，如果扩容之后，超过了原数组的容量，那么，Go就会开辟一块新的内存，把原来的值拷贝过来，这种情况丝毫不会影响到原数组。

//本例中实际执行了两次append操作，第一次空间增长到4， 
//所以第二次append不会再扩容，所以新旧两个切片将共用一块存储空间。程序会输出”true”。
func AddElement(slice []int, e int) []int {
	return append(slice, e)
}
func main() {
	var slice []int
	slice = append(slice, 1,2,3)
	fmt.Println("容量：", cap(slice)," 长度",len(slice))
	newSlice := AddElement(slice, 4)
	fmt.Println("容量(没变哦，所以底下相等)：", cap(newSlice)," 长度",len(newSlice))
	fmt.Println(&slice[0] == &newSlice[0])
}

Slice 扩容

使用append向Slice追加元素时，如果Slice空间不足，将会触发Slice扩容，扩容实际上重新一配一块更大的内 存，将原Slice数据拷贝进新Slice，然后返回新Slice，扩容后再将数据追加进去。
扩容容量的选择遵循以下规则：

• 如果原Slice容量小于1024，则新Slice容量将扩大为原来的2倍；
• 如果原Slice容量大于等于1024，则新Slice容量将扩大为原来的1.25倍；

使用append()向Slice添加一个元素的实现步骤如下：

1. 假如Slice容量够用，则将新元素追加进去，Slice.len++，返回原Slice
2. 原Slice容量不够，则将Slice先扩容，扩容后得到新Slice
3. 将新元素追加进新Slice，Slice.len++，返回新的Slice。

Slice Copy

使用copy()内置函数拷贝两个切片时，会将源切片的数据逐个拷贝到目的切片指向的数组中，拷贝数量取两个切片长度的最小值。
例如长度为10的切片拷贝到长度为5的切片时，将会拷贝5个元素。
也就是说，copy过程中不会发生扩容。

总结

创建切片时可跟据实际需要预分配容量，尽量避免追加过程中扩容操作，有利于提升性能；
切片拷贝时需要判断实际拷贝的元素个数。
谨慎使用多个切片操作同一个数组，以防读写冲突。

每个切片都指向一个底层数组
每个切片都保存了当前切片的长度、底层数组可用容量
使用len()计算切片长度时间复杂度为O(1)，不需要遍历切片
使用cap()计算切片容量时间复杂度为O(1)，不需要遍历切片
通过函数传递切片时，不会拷贝整个切片，因为切片本身只是个结构体而矣
使用append()向切片追加元素时有可能触发扩容，扩容后将会生成新的切片

map

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

hmap.B=2 ， 而hmap.buckets长度是2^B为4. 元素经过哈希运算后会落到某个bucket中进行存储。查找过程类似。

bucket数据结构

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，据此将所有冲突的键连接起来。

哈希冲突

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

负载因子

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

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

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

渐进式扩容

扩容条件：

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

增量扩容

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

等量扩容

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

查找过程

1. 跟据key值算出哈希值
2. 取哈希值低位与hmpa.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插入

struct

Go的struct声明允许字段附带 Tag 来对字段做一些标记。（ Tag 其实是结构体 字段的一个组成部分。）

Tag

Tag 本身是一个字符串，但字符串中却是： 以空格分隔的 key:value 对 。

• key : 必须是非空字符串，字符串不能包含控制字符、空格、引号、冒号。
• value : 以双引号标记的字符串 注意：冒号前后不能有空格

 type Server struct { 
 	ServerName string `key1: "value1" key11:"value11"` 
 	ServerIP string `key2: "value2"` 
 	}

本文示例中tag没有任何实际意义，这是为了阐述tag的定义与操作方法，也为了避免与你之前见过的诸 如 json:xxx 混淆。
使用反射可以动态的给结构体成员赋值，正是因为有tag，在赋值前可以使用tag来决定赋值的动作。

比如，官方 的 encoding/json 包，可以将一个JSON数据 Unmarshal 进一个结构体，此过程中就使用了Tag. 该包定义一些规 则，只要参考该规则设置tag就可以将不同的JSON数据转换成结构体。
总之：正是基于struct的tag特性，才有了诸如json、orm等等的应用。

iota

iota常用于const表达式中。
iota代表了const声明块的行索引（下标从0开始）
const声明还有个特点，即第一个常量必须指定一个表达 式，后续的常量如果没有表达式，则继承上面的表达式。

string

• string可以为空（长度为0），但不会是nil；
• string对象不可以修改。

type stringStruct struct { 
	str unsafe.Pointer // 字符串的首地址
	len int // 字符串的长度
}

[]byte转string

需要注意的是这种转换需要一次内存拷贝。
转换过程如下：

1. 跟据切片的长度申请内存空间，假设内存地址为p，切片长度为len(b)；
2. 构建string（string.str = p；string.len = len；）
3. 拷贝数据(切片中数据拷贝到新申请的内存空间)

byte切片转换成string的场景很多，为了性能上的考虑，有时候只是临时需要字符串的场景下，byte切片转换成 string时并不会拷贝内存，而是直接返回一个string，这个string的指针(string.str)指向切片的内存。

使用m[string(b)]来查找map（map是string为key，临时把切片b转成string）；
字符串拼接，如”<” + “string(b)” + “>”；
字符串比较：string(b) == “foo”

字符串拼接

 str := "Str1" + "Str2" + "Str3"

即便有非常多的字符串需要拼接，性能上也有比较好的保证，因为新字符串的内存空间是一次分配完成的，所以性能 消耗主要在拷贝数据上。
一个拼接语句的字符串编译时都会被存放到一个切片中，拼接过程需要遍历两次切片，第一次遍历获取总的字符串长 度，据此申请内存，第二次遍历会把字符串逐个拷贝过去。

Go的实现中，string不包含内存空间，只有一个内存的指针，这样做的好处是string变得非常轻量，可以很方便的进行传递而不用担心内存拷贝。
因为string通常指向字符串字面量，而字符串字面量存储位置是只读段，而不是堆或栈上，所以才有了string不可 修改的约定